1. 包

1.1 包的概述

包的概述和使用】:
包其實就是檔案夾，它的作用就是進行分類管理的
格式:package 包名;(多級包用.分開)
范例:package com.demo;
方法:
1.帶包的Java類編譯和執行手動建包:按照以前的格式編java檔案

javac HelloWorld.java

2.手動創建包
在E盤建立檔案夾com,然后在com下建立檔案夾demo
把class檔案放到包的最里面，把HelloWorld.class檔案放到com 下的demo這個檔案夾下，帶包執行

java com.demo.HelloWorld

1.2 導包

對于不在同一個目錄下的java類，如果想要實作類與類之間的測驗與呼叫，那么就需要進行導包

• 格式：import 包名；
• 范例：import.com.test;

2.修飾符

2.1 權限修飾符

• private同一個包可在本類中都可以被訪問到，其他的類中不可被訪問
• protected同一個包下可進行訪問，不在同一個包下子類也進行訪問，但無關類不可進行訪問無關類：未繼承父類的類
• public 都可以進行訪問
• 默認 不同包的子類，和無關類不可進行訪問
  

2.2 狀態修飾符

final

• final 關鍵字是最終的意思，可以修飾成員方法，成員變數，類

舉例:
1.定義一個父類：

public class Fu {
public  void show(){
    System.out.println("父中方法被呼叫");
      }
}

定義子類：

public class Zi extends Fu {
    @Override//用來檢測重寫方法時方法名單詞是否拼寫錯誤
  public void show(){
      System.out.println("子中方法被呼叫");
  }
}

定義測驗類：

public class jicheng {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
    }

那么這里輸出的結果就是

子類方法被呼叫

但是，如果在父類前加入final來修飾，那么子類中將會報錯，因為最終方法不可被重寫如下面所示，在方法名前加final那么就代表是最終態，不會在被重寫

public class Fu {
public final void  show(){
    System.out.println("父中方法被呼叫");
      }
}

同樣的對于成員變數如果在前面加入final這個修飾符，就代表最終態，就是一個常量了，不可在區域變數中在進行賦值

public class demo{
public final int age=10;
public void zi(){
     age=20;//這里賦值也不會再起作用，還會報錯
     }
}

還有final修飾類，就代表是最終類，就不能被使用:

public final class Fu {
public  void  show(){
    System.out.println("父中方法被呼叫");
      }
}

上面有final修飾類，那么子類就不能繼承
總結:
final修飾的特點

• 修飾方法：修飾方法:表明該方法是最終方法，不能被重寫
• 修飾變數：表明該變數是常量，不能再次被賦值
• 修飾類：表明該類是最終類，不能被繼承

final 修飾區域變數：

• 修飾基本型別變數
  
  被它修飾后，區域變數不可再用
• 修飾參考型別
  對于修飾型別，修飾的是地址，而里面的內容可以改變
  

public class Student{
public int age=10;
}

那么它輸出的就會是100，而不是10
總結：

• 變數是基本型別: final修飾指的是基本型別的資料值不能發生改變
• 變數是參考型別: final修飾指的是參考型別的地址值不能發生改變，但是地址里面的內容是可以發生改變的

static關鍵字

static 是靜態的意思，可以修飾成員方法，成員變數
對于一個事物，別的事物都需要它來共享，這樣建議使用static來進行修飾
例如，很多個學生來自同一個大學，但年齡，性別不同，這里，賦值時，因為多個同學來自同一個大學，那么大學就是一個靜態的，共享的，賦值時如果給每個學生大學都賦值同一個大學，那么會顯得臃腫，用static修飾大學就是不錯的選擇

主函式部分：

public class main {
    public static void main(String[] args) {
        stu.university="清華大學";//直接給大學賦值，建議使用這種方式來進行給靜態賦值
        stu s1=new stu();
        s1.name="張三";
        s1.age=18;
        s1.show();
        stu s2=new stu();
        s2.name="李四";
        s2.age=19;
        s2.show();
    }

學生類部分

public class stu{
    public String name;
    public int age;
    public static String university;//加上靜態修飾符，可以共享
    public void show(){
        System.out.println(name+", "+age+", "+university);
    }
}

那么輸出結果就是：

張三, 18, 清華大學
李四, 19, 清華大學

訪問特點:

3. 多型

3.1 多型概述

**概述：**同一物件，在不同時刻表現出來的不同形態

• 有繼承關系：

public class Cat extends Animal{//繼承關系
    @Override
    public void eat(){//方法重寫
        System.out.println("貓愛吃魚");
    }
}

• 方法重寫：

public class Animal {

    public void eat(){
        System.out.println("動物吃肉");
    }
}

• 父類參考指向子類物件：

public class AnimalDemo {
    public static void main(String[] args) {
      Animal animal=new Cat();//多型，父類參考指向子類物件，這里也就是下面說的向上轉型
    }
}

3.2 多型中成員訪問特點

成員變數：編譯看左邊，執行看左邊
成員方法：編譯看左邊，執行看右邊

//子類
public class Cat extends Animal{//繼承關系
  public int age=40;
    @Override
    public void eat(){//方法重寫
        System.out.println("貓愛吃魚");
    }
    public void playGame(){
    System.out.println("貓愛玩");//非重寫
    }
}

//父類
public class Animal {
  public int age=30;
    public void eat(){
        System.out.println("動物吃肉");
    }
}

//測驗類
public class AnimalDemo {
    public static void main(String[] args) {
      Animal animal=new Cat();//多型
      System.out.println(animal.age);
      //運行結果是左邊Animal,則age=30,
      //如果Animal沒有age，則會報錯
      //----------------------------------
      animal.eat();//方法重寫執行看右面
      //輸出的是Cat里面的方法
      //----------------------------------
       animal.playGame();//這時就會報錯
       //執行左面Animal里面沒有這個方法
    }
}

為什么成員變數和成員方法的訪問不一樣呢?
因為成員方法有重寫,而成員變數沒有

3.3 多型的好處與弊端

測驗類

狗類：

貓類：

操作類：

測驗結果：

3.4 多型中的轉型

• 向上轉型 從子到父，父類參考指向子類物件
• 向下轉型 從父到子，父類參考轉為子類物件
  向上轉型，上面的有實體，這里不在敘述，
  關于向下轉型，也就是在子類中，如果不用父類的方法時，想要用自己的方法時，還不能出現報錯，這里就要用向下轉型，從而實作
  例如：
  在貓類中有方法eat，而貓類繼承父類，父類也有eat方法，這就實作了貓類方法重寫，而在貓類中還有方法Game(),而父類沒有此方法，那么使用時就會報錯，如果不想報錯，就要實施類似強轉

//子類

public class Cat extends Animal{//繼承關系
    @Override
    public void eat(){//方法重寫
        System.out.println("貓愛吃魚");
    }
    public void playGame(){//這里方法沒被重寫，按照編譯看左面，看父類中沒有就會報錯，
    //下面向下轉型就可以實作這個問題
    System.out.println("貓愛玩");//非重寫
    }
}

//父類
public class Animal {
    public void eat(){
        System.out.println("動物吃肉");
    }
}

//測驗類
public class AnimalDemo {
    public static void main(String[] args) {
      Animal animal=new Cat();//多型，向上轉型，父類參考指向子類物件
     animal.eat();//這里因為有重寫方法，所以執行看右面，看cat中的eat,所以會輸出貓愛吃魚
     /*這里我如果還想呼叫cat中的playGame()方法，顯然會報錯，那么、怎末不讓它報錯呢，就要用到向下轉型
     */
   Cat c= (Cat)animal;//后面的(Cat)animal是父類參考作為子類物件，轉為Cat,
   //那么就可以實作呼叫子類獨有的方法了
   c.playGame();
    }
    
}

4.抽象類

4.1 抽象類概述

概述
在Java中，一個沒有方法體的方法應該定義為抽象方法，而類中如果有抽象方法，該類必須定義為抽象類
用abstract表示抽象

public abstract class Animal {//抽象類
   public abstract  void eat();//定義抽象方法
}

4.2 抽象類特點

實體化

//貓類
public class Cat extends Animal{//繼承關系
    public void eat() {//重寫父類方法，有抽象類的方法
        System.out.println("貓吃魚");
    }
}

//Animal類
public abstract class Animal {//抽象類
   public abstract  void eat();//定義抽象方法
   public void sleep(){//抽象類中一定有抽象的方法，但也可有不抽象的方法
       System.out.println("睡覺");
   }
}

//狗類
public abstract class dog extends Animal {
    //這里如果不想重寫所有方法，就需要在加abstract
}

測驗類
public class AnimalDemo {
    public static void main(String[] args) {
        Animal c = new Cat(); //采用多型方式
        c.eat();//呼叫eat方法，遵循編譯看左面，執行看右面
        c.sleep();//盡管貓類中沒有，但是會繼承父類中的
    }
}

運行結果

貓吃魚
睡覺

4.3 抽象類的成員特點

• 可以提供構造方法，但是不能實體化
• 構造方法作用是子類訪問父類資料的初始化
• 成員變數可以是變數，也可以是常量
• 成員方法 可以有抽象方法：限定子類完成某些動作；也有非抽象方法：提高代碼復用性

public abstract class xxx(){
    public xxx(){}//無參構造方法
    public xxx(String name){//有參構造方法
    this.name=name;
    }
}

public abstract class xxx(){
   
    private final int age=10;//可以是常量
    private String name;//也可以是變數
}

public abstract class xxx(){
   public void sleep(){//非抽象方法，提高復用性
   System.out.println("睡覺");
   
   }
}

public abstract class xxx(){
   public abstract void eat();
   //限定貓類中重寫eat方法，否則報錯
}