面向2-封裝、繼承、多型

37201發表於2024-07-15
封裝繼承多型

封裝、繼承、多型

繼承的本質是對某一批類的抽象，從而實現對現實世界更好的建模

extands關鍵字擴充套件

封裝

/* 封裝-隱藏內部資訊，透過介面訪問
1、“高內聚，低耦合”-該露的露，該藏得藏  屬性私有，get/set
2、提高程式的安全性，保護資料
3、隱藏程式碼的實現細節
4、統一介面
5、提高系統的可維護性
 */
package oop;
//類 private:私有
public class B1 {
    //對於學生有 名字，學號，性別，學習方法（），睡覺方法（）
    //屬性私有
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供一些可以操作這個屬性得方法-提供一些public的get、set方法
    //get-獲得這個資料，set-給這個資料設定值

    //Alt+insert也可以自動生成get和set
    public String getName(){ //getName和setName自動生成-遵守駝峰規則
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<120 && age>0){
            this.age = age;
        }else{
            this.age = 3;
        }
    }
}


/*
//封裝的輔助程式
//println按住加countrol  方法過載-主要看方法名和引數列表是否對應
package oop;

public class BI1 {
    public static void main(String[] args) {
        B1 b1 = new B1();
     // bi.name = "";使用得private會報紅，換成public就不會
        b1.setName("小白");
        System.out.println(b1.getName());
        b1.setAge(999); //不合法的，可以在語法中輔助判斷
        System.out.println(b1.getAge());
    }
}
*/

繼承-extend

繼承和object類

/* 繼承-類跟類之間的關係（父子）  除此之外還有其他關係 object類
Control+H-開啟了一個繼承樹
java中只有單繼承，沒有多繼承，但可以有多個繼承者
私有的東西無法被繼承
在java中，所有的類都預設直接或間接繼承object類
 */
package oop;
//C1 人 父類
public class C1 {
    //public-公共的，protected-受保護的，default-預設的，private-私有的 一般繼承都是public,屬性裡才用private
    private int age = 99;
    public int money = 10_0000_0000;
    public void say(){
        System.out.println("說了一句話");
    }

}

/*
/* 輔助理解繼承
1、子類繼承了父類，就會擁有了父類的全部方法
 */
/* //extends
package oop;
//Student is 人 子類
public class Student extends C1 {

}
*/
package oop;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say(); //子類繼承了父類，就會擁有了父類的全部方法
        System.out.println(student.money);
     //   System.out.println(student.age); //父類private,會報錯
    }
}
*/

Super的定義和使用

/* super
1、super呼叫父類的構造方法，必須在構造方法的第一個
2、super必須只能出現在子類的方法或者構造方法中
3、super和this不能同時呼叫構造方法
Vs this
代表的物件不同
  this:本身呼叫者這個物件
  super:代表父類物件的引用
前提
   this：沒有繼承也可以使用
   super:只能在繼承條件下才可以使用
構造方法
   this：呼叫本類的構造
   super:呼叫父類的構造
 */
/*
package oop;
//C1 人 父類
public class C1 {
    //public-公共的，protected-受保護的，default-預設的，private-私有的 一般繼承都是public,屬性裡才用private
    protected String name = "大黑" ;
    public C1(){
        System.out.println("父類C1的無參構造器");
    }

}


*/
package oop;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("二黃");
    }
}
/*
//super
//Control+H-開啟了一個繼承樹
package oop;
//Student is 人 子類
public class Student extends C1 {
    public Student(){
        super();//呼叫父類的構造器，必須在子類構造器的第一行； 也可以不寫，它自己預設呼叫
        System.out.println("Student的無參執行了");
    }
    private String name = "小白";
    public void test(String name){
        System.out.println(name);//二黃
        System.out.println(this.name);//小白
        System.out.println(super.name); //大黑-子類呼叫父類屬性

    }
}

 */

Override重寫的定義和使用

/* 方法重寫
1、重寫都是方法的重寫，和屬性無關
2、重寫的修飾符只能說public，不能是private
重寫原因
1、父類的功能子類不一定需要或不一定滿足
2、Alt+Insert-override;
重寫總結：
重寫子類和父類的方法必須要一致，方法體不同
1、需要有繼承關係，子類重寫父類的  方法
2、方法名必須相同、引數列表必須相同、修飾符：範圍可以擴大，但不能縮小 public》Protected》Dewault》private
3、丟擲的異常範圍可以被縮小，但不能擴大：Exception(大)-->ClassNotFoundException(小）
 */
package oop;

public class Application {
    //靜態方法和非靜態方法輸出區別很大 D2會成D1
       //靜態方法:方法的呼叫只和左邊，定義的類有關
       //非靜態方法：子類重寫了父類的方法
    public static void main(String[] args) {
        D1 d1 = new D1();
        d1.test();

        // 父類的引用指向了子類
        D2 d2 = new D1();
        d2.test();
    }
}


/*
package oop;

public class D1 extends D2 {
    //Overrried-重寫
    @Override //註解-有功能的註釋！
    public void test() {
        System.out.println("D1==>test");
    }
}
/*
    public  void test() {
        System.out.println("D1==>test");
    }
 */
*/

  
  
  
/*
package oop;

public class D2 {
    public  void test(){
        System.out.println("D2==>test");
    }
}

*/

多型

/* 多型-多種方法發生方式
1、多型是方法的多型，屬性沒有多型
2、父類和子類的型別應該相同 ClassCastException！-型別異常報錯
3、存在的條件
          繼承關係
          方法需要重寫，父類引用指向子類物件
          不能重寫的方法 1、static 方法 屬於類，不屬於實列
                      2、final 常量
                      3、private 方法
*/
package oop;

public class Application {
    public static void main(String[] args) {
        //一個物件的實際型別是確定的 如：new E2();new E1();
        //但可以指向的引用型別就不確定了
        //子類能呼叫的方法都是自己的或繼承父類
        E2 s1 = new E2();
        E2 s2 = new E2();
        //透過父類的引用指向子類
        //父類雖然可以指向子類，但不能呼叫子類的方法
        E1 s3 = new E2();
        //Object 預設擁有
        Object s4 = new E2();
        //子類繼承了父類的全部方法,如果子類重寫了父類的方法就是走子類的程式
        s3.run();
        s1.run();
        //物件能執行那些型別，主要看左邊和右邊關係不大
    //  s3.eat();//此行會報錯，E1裡沒有eat;  只用透過（（E2）s3).eat;進行強制轉換
        s1.eat();

    }

}





/*
package oop;

public class E1 {
    public void run(){
        System.out.println("run");
    }
}
*/


/*
package oop;

public class E2 extends E1{
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
*/

相關文章