類和物件

類和物件的關係

類是具有相同屬性和方法的一組物件的集合。
1. 從語義上理解：類是用於建立物件的模板，是一個抽象的概念，而物件是類的一個例項。
2. 從語法上理解：類是我們自定義的一種資料型別，而物件則是這種資料型別的變數。

類的定義

public class 類名{
     訪問修飾符 型別 屬性名      //成員變數，也叫全域性變數
     訪問修飾符 返回值型別 方法名(引數型別 引數){
         訪問修飾符 型別 屬性名  //區域性變數
         *方法體*
         }

類的方法

1. 多個方法不能相互巢狀定義；
2. Return只能返回一個值，且表示方法結束；
3. 對於引用資料型別，方法傳遞的是複製的地址；而對於簡單資料型別，方法傳遞的是複製的資料。
   例子：

public class StudentTest {
    public static void main(String[] args) {
        Student zhangsan=new Student();
        zhangsan.student(18,"zhangsan","Mr.Li");
        System.out.println(zhangsan.name);
        Student lisi=new Student();
        lisi=zhangsan;//將存放zhangsan.name的地址複製一份給lisi
 

        if(lisi.name==zhangsan.name){//lisi.name的地址就和zhangsan.name的地址指向同一個堆記憶體
            System.out.println("1");
        }
        lisi.name="lisi";
        System.out.println(zhangsan.name);
        int j=0;
        int i=j;//將j中的資料複製一份給i，當中的資料改變時，j中資料不受影響
        i++;
        System.out.println("j="
 
+j);
        System.out.println("i="+i);
    }
}

1. 方法可變引數，只允許傳入的最後一個引數為可變引數

public void function(int... is) { //要把is理解為一個int陣列
　　for (int i = 0; i < is.length; i++) {
　　　　System.out.print(is[i]+"  ");
　　}
}

對於可變引數，適用於引數個數不確定，型別確定的情況，java把可變引數當做陣列處理，且可變引數必須放在方法引數的最後。
可變引數的特點：
①只能出現在引數列表的最後；
②…位於變數型別和變數名之間，前後有無空格都可以；
③呼叫可變引數的方法時，編譯器為該可變引數隱含建立一個數組，在方法體中一陣列的形式訪問可變引數。

物件的建立和使用

1. 建立物件：類名 物件名=new 類名();
2. 使用物件：
   物件名.屬性；
   物件名.方法();

舉例

寫一個Person類

public class Person {
    int age;
    String name;
    String sex;
    public Person(int age1,String name1,String sex1){
        age=age1;
        name=name1;
        sex=sex1;
    }
    public String eat(String food){
        System.out.print("你只會吃"+food);
        return food;
    }
    public void sleep(){
        System.out.println(",還有睡覺覺！");
    }
}

寫一個測試類

public class Test {
    public static void main(String[] args) {
        Person zhangsan = new Person(18, "張三", "男");
        System.out.println("你叫" + zhangsan.name + "  性別" + zhangsan.sex + "  今年" + zhangsan.age + "歲");

        zhangsan.eat("飯");
        zhangsan.sleep();
    }
}

輸出結果為：

變數的初始化

成員變數可以只宣告，不初始化；但區域性變數必須要初始化。
不同資料型別的預設值：
1. 基本資料型別：
byte(0),short(0),int(0),long(0L),float(0.0F),double(0.0),boolean(false),char(’ ‘)
2. 引用資料型別的預設值都為：null

類的封裝

目的為保護私有屬性，新增get()和set()方法來對屬性進行封裝，提高了程式的可複用性和可維護性，降低了程式設計師保持資料與操作內容的負擔。
①修改訪問修飾符—>private
②建立get()和set()方法—>用於屬性的讀寫
③在方法內加入控制語句—>對屬性值得合法性進行判斷

public class Student{
    private int stuNo;
    public int getStuNo(){
        return stuNo;
    }
    public void setStuNo(int stuNo){
        this.stuNo=stuNo;
    }
}

構造方法

構造方法：負責物件成員的初始化工作，為例項變數賦予合適的初始值。
語法：①方法名和類名相同；②沒有返回型別
【注意】
1. 使用new關鍵字呼叫構造方法，在我們建立類的例項時會自動呼叫。
2. 一個類可以沒有構造方法（系統有隱藏的無參構造方法），也可以有多個構造方法，它們構造過載關係。
3. 如果我們定義了有參構造方法，就會自動覆蓋掉系統無參的構造方法。
4. 構造方法不能被繼承。

方法的過載（overload）

條件：①在同一個類中存在兩個以上的同名方法②方法引數不同（引數的數目不同或引數型別的組合不同）③與訪問修飾符和返回值的型別無關

繼承

1. 繼承需符合的關係：”is-a“，父類更通用，子類更具體
   子類具有父類的一般特性（包括屬性和方法），以及自身特殊的特性。
2. 繼承使用extends關鍵字，子類只能繼承父類的屬性和方法，不能繼承父類的構造方法
3. 繼承的初始化順序：先父類的屬性，後父類的構造方法，然後先子類的屬性，後子類的構造方法。

super關鍵字

1. 呼叫父類的屬性：super.屬性;
2. 呼叫父類的方法：super.方法();
3. 子類會預設呼叫父類的無參構造方法（super()，可以省略不寫），若父類有有參構造方法（super(引數),不能省略，且必須放在子類構造方法的第一行）。

this關鍵字

this關鍵字表示呼叫該類例項化的物件

1. this.屬性名：呼叫該物件的屬性
2. this.方法名：呼叫該物件的方法
3. this()：呼叫本類中的另一個構造方法，且必須寫在第一行

方法的重寫（override）

1. 在繼承關係的子類中
2. 重寫的方法名，引數，返回值型別必須與父類相同
3. 私有方法不能被繼承，因而也無法重寫
4. 重寫方法的訪問修飾符的許可權要比父類的許可權大或者相同

訪問修飾符的許可權

封裝類

把簡單資料型別封裝為引用資料型別

1. 自動裝箱
Integer i =10;
相當於：Inerger i = new Inerger(10);
2. 自動拆箱
int i = new Inerger(10);
相當於：int i =10

綜合的例子

建立一個Dog類

public class Dog {

    String color="紅色";//可以被子類呼叫

    public Dog(String s){   
        System.out.println("呼叫了父類的構造方法");
    }
    public void run(){
        System.out.println("它們都會跑");
    }
}

建立一個Jinmao子類

public class Jinmao extends Dog{

    public String weiba;
    String myColor=super.color;
    public Jinmao(){
        super("");//呼叫父類的有參構造方法，且必須放在第一句
        System.out.println("子類自己的構造方法"+"  子類呼叫父類的屬性"+myColor);
    }
    public Jinmao(int a){
        this();//呼叫子類的另一個構造方法
    }
    public void run(){  //重寫了父類的run方法
        this.weiba="長";
        System.out.println("父類方法的重寫：我還會賣萌的跑！");
        super.run();  //呼叫父類的方法
    }
    public void run(int a){  //方法的過載
        System.out.println("方法的過載"+a);
    }
}

建立一個測試類

public class test {
    public static void main(String[] args){ 
        Jinmao jm = new Jinmao();//執行子類無參的構造方法
        jm.run(); //呼叫子類的run方法
        jm.run(1); //呼叫了子類的過載的run方法
        Jinmao jm2 =new Jinmao(1);//執行子類有參的構造方法
    }
}

輸出結果：