面向對象封裝、繼承、多態(tài)

面向對象：

     把復雜問題通過面向對象的思維方式拆分成每一個單獨負責某個分支問題的對象


     類：
        利用類中的成員變量來記錄事物的信息叫屬性
        利用方法來實現(xiàn)或者描述事事物的行為護著功能叫方法

     成員變量：
        1.可以在類中任意成員中使用，如果有同名的局部變量會被覆蓋。
        2.可以賦值也可以不賦值，不賦值則在new的時候采用屬性數(shù)據(jù)類型的默認值    
        嵌套類

     方法：
        方法聲明：
        權限控制符   修飾符  返回值類型   方法名（形參列表[,..]）{

        }

        返回值如果是void則不需要return，否則必須return ,return 必須是最后一句話
        形參本質上就是一個一定會得到實參值傳遞的方法的局部變量

        重載：
        同一類中 方法名相同，形參列表不同（類型和個數(shù)）

     構造器：
        作用
            用來配合創(chuàng)建new類的對象的
            代碼主要用來實現(xiàn)對象的屬性初始化
        語法規(guī)定
            1.所有類都必須提供構造器
            2.如果類中沒有主動聲明構造器，則系統(tǒng)自動默認提供一個無參無內容的構造器
            3.構造器必須跟所在類的名字一樣，構造器是一個代碼塊不能有返回值類型所以不是函數(shù)

    this: . 代表當前對象
          ()代表當前類的構造器
    super:.代表當前對象的父對象
          ()代表當前類的父類的構造器

          super()和this()不能同時存在一個構造器中而且如果存在則必須是第一行。

封裝：

            包：
                類文件的管理單位
                打包：package
                      import

            訪問權限控制符：
                public：同一項目下隨便用
                protected：
                被修飾的類成員正常情況下只能本包用，但是如果是其他包中的子類以子類的身份繼承用可以
                default  ：一個類的成員被default修飾代表只能被相同包中的其他類或者本類使用
                private
                ：只能本類中
            要求以后所有的類：所有屬性私有，同時提供對應的get和set方法

package mianxiangduixianggaoji;

public class text2 {
    //封裝
    private String name;
    private int age;
    public text2() {
        super();
    }
    public text2(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        //例如一些其他的方法可以在這加判斷
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }   
}

繼承：

            Object：是所有類的直接或者間接父類，Object也是個類不參與正常討論
            what：復用其他類成員的語法，利用 子類  extends 父類
                  java只允許單繼承
            why：
                減少代碼量
                支持代碼復用
                為多態(tài)做準備
            how:
                只要滿足什么是什么這種關系，就是父子關系就可以使用繼承

            繼承發(fā)生之后對于對象的影響：
                子類對象要想誕生的前提必須先創(chuàng)建父類對象
                子類構造器默認第一行有一個super()
image.png
package mianxiangduixianggaoji;
//繼承
public class test1 {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.age = 5;
    }
}

class People{
    String name;
    int age;
    People(){
        super();
        System.out.println("People");
        
    }
    
    void sayHello() {
        
    }
}

class Teacher extends People{//默認擁有父類所有屬性和方法
    int classNum;
    Teacher(){
        super();
        System.out.println("2111");
        
    }
    void sayHello() {
        
    }
}

package mianxiangduixianggaoji;

public class Tuhao {
    int money;
    public static void main(String[] args) {
        Tuhao tuhao = new Tuhao();
        tuhao.money = 2000000000;
//      Draw d = new Draw("老畫家",10);
//      SmallDraw sd = new SmallDraw("老畫家", 10);
//      DrawOther dother = new DrawOther("其他畫家",10);
        Draw d = new SmallDraw("老畫家", 10);
        tuhao.buyDraw(d);
        tuhao.printshanshuimeiren();
    }
    
    public void printshanshuimeiren() {
        Draw d = new Draw("老畫家",10);
        d.doDraw(200000000);
    }
    public void  buyDraw(Draw d) {
        d.doDraw(2000000000);
    }
}

class DrawOther{
    private String name;
    private int money;
    public DrawOther(String name, int money) {
        super();
        this.name = name;
        this.money = money;
    }   
    public void doDraw(int money) {
        if(money>1000000) {
            System.out.println("山水大美人兒");
        }else {
            System.out.println("滾");
        }
        
    }   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }   
}
class SmallDraw extends Draw{
    public SmallDraw(String name, int money) {
        // TODO Auto-generated constructor stub
        super(name, money);
        System.out.println("跟老畫家一模一樣");
    }
    
    String name = "xixi";
    public void doDraw(int money) {
        System.out.println("機智一p寶兒姐，阿威十八式大威天龍");
    }   
}

class Draw{
    private String name;
    private int money;
    public Draw(String name, int money) {
        super();
        this.name = name;
        this.money = money;
    }   
    public void doDraw(int money) {
        if(money>1000000) {
            System.out.println("山水大美人兒");
        }else {
            System.out.println("滾");
        }       
    }   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }   
}

多態(tài)：

一個事物多種形態(tài)
對修改關閉對繼承開放利用子類來實現(xiàn)修改程序的方式，用來保證程序可維護性

              前置條件：
                必須發(fā)生繼承：只有繼承子類才能成為父類保證同一事物
                必須重寫：才能讓父類的行為和子類的同一行為表面是一個聲明其實實現(xiàn)不一，叫多種形態(tài)
                父類引用指向子類對象:
                    引用類型的數(shù)據(jù)轉換：只有存在父子關系，才可能進行轉換
                        向上轉型：父類引用指向子類對象
                                父類引用調用屬性（只能調用父類有的屬性，得到的也是父類對象的值）
                                父類引用調用方法，優(yōu)先執(zhí)行子類的方法，子類方法中優(yōu)先使用子類自己的屬性

                        向下轉型：原本的父類引用指向的對象就是子類對象
                                 前提是必須使用instanceof   判斷左邊的引用或者引用的對象是否屬于右邊的類型或者子類的類型

package mianxiangduixianggaoji;

public class test3 {
    //多態(tài)：一個事物多種形態(tài)
    //  對修改關閉，對繼承開放，利用子類來實現(xiàn)修改程序的方式，用來保證程序的可維護性
    
    //前置條件，必須發(fā)生繼承，只有繼承子類才能成為父類保證同一事物
    //必須重寫：才能讓父類的行為和子類的同一行為表面是一個聲明其實實現(xiàn)不一樣，叫多種形態(tài)
    //父類引用指向子類
    
    int money;
    public static void main(String[] args) {
        test3 tuhao = new test3();
        tuhao.money=200000000;
        
        Draw d = new Draw("老畫家",10);
        d.doDraw(200000000);
        
        SmallDraw s =new SmallDraw("小畫家",5);
    }
    public void buyDraw(Draw d) {
        
    }
}
class SmallDraw extends Draw{
    public SmallDraw(String name,int money) {
        super(name,money);
        System.out.println("跟老畫家一模一樣");
    }
    //方法的重新
    public void doDraw(int money) {
        System.out.println("大威天龍");         
    }
}
class Draw{
    private String name;
    private int money;
    public Draw(String name, int money) {
        super();
        this.name = name;
        this.money = money;
    }
    
    public void doDraw(int money) {
        if(money>1000000) {
            System.out.println("大美人兒");
        }else {
            System.out.println("滾");
        }
        
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    
    
}



    //多態(tài)向上轉型
    
    //向下轉型
    
    
    public static void main(String[] args) {
        Father f= new Child();//父類引用指向子類對象
//      System.out.println(f.a);//向上轉型的時候輸出的是父類的屬性，輸出子類的屬性會報錯；
//      f.haha();
//      Child c =(Child)f;//向下轉型
//      System.out.println(c.a);
//      System.out.println(c.b);
//      c.haha();
        new test4().getFather(f);
        
    }
    
    public void getFather(Father f) {
        f.haha();
        if(f instanceof Child) {
            Child fd= (Child)f; 
            System.out.println(fd.b);
        }   
    }
}

class Father{
    int a =1 ;
    public void haha() {
        System.out.println("father");
    }
}

class Child extends Father{
    int a =2;
    int b =3;
    public void haha() {
        System.out.println("child");
    }
}

面向對象語法的一些修飾符

            static:靜態(tài)
                類：靜態(tài)內部類
                變量：靜態(tài)變量又叫類變量，可以直接通過類名來調用，類變量整個類所有對象和類本身公用一個
                方法：類方法可以用類名來調用，但是方法中不能使用非靜態(tài)屬性
                塊：
                    靜態(tài)塊伴隨類的加載而執(zhí)行，只執(zhí)行一次

            final:不能被修改
                類：不能有子類
                變量：常量
                方法：不能被重寫

            abstract:抽象
                方法：抽象方法  ，沒有方法體
                類：抽象類 ，如果一個類中有抽象方法則類必須抽象，但是如果是抽象類可以沒有方法
                不能被實例化，有構造器



        子類對象創(chuàng)建過程：
            1.類加載 永遠只加載一次，一旦加載完就不用再加載
                1.1 先加載父類
                    1.1.1 先創(chuàng)建父類的靜態(tài)屬性
                    1.1.2 執(zhí)行父類的靜態(tài)塊代碼
                1.2 再加載子類
                    1.2.1 先創(chuàng)建子類的靜態(tài)屬性
                    1.2.2 在執(zhí)行子類的靜態(tài)代碼塊

            2.對象創(chuàng)建
                子類和父類屬性先空間先誕生
                2.1 先創(chuàng)建父類對象
                    2.1.1 先創(chuàng)建給父類屬性賦值
                    2.1.2 執(zhí)行父類的普通塊
                    2.1.3 執(zhí)行父類的構造器
                2.2 再創(chuàng)建子類對象
                    2.2.1 給子類屬性賦值
                    2.2.2 執(zhí)行子類的普通塊
                    2.2.3 執(zhí)行子類的普通塊

package mianxiangduixianggaoji;

public class test6 {
    //靜態(tài)塊
    public static void main(String[] args) {
        Fathera f1 = new Fathera();
        Fathera f2 = new Fathera();
        System.out.println(f1.a);
        System.out.println(f1.b);
        System.out.println(f1.c);
        System.out.println(f2.a);
        System.out.println(f2.b);
        System.out.println(f2.c);
        Childa c1 = new Childa();
        Childa c2 = new Childa();
        System.out.println(c1.a);
        System.out.println(c1.b);
        System.out.println(c1.c);
        System.out.println(c2.a);
        System.out.println(c2.b);
        System.out.println(c2.c);
        
    }

}

class Fathera{
    int a ;
    int b = getB();
    int c = getC(); 
    Fathera(){
        a = 1;    
        System.out.println("father");  
    }
    static int getB() {
        System.out.println("father的getb");
        return d;
    }
    static int d = 3;
     int getC() {
        System.out.println("father的getc");
        return a; 
    }
    {
        System.out.println("father 的普通塊");
    }
    static {
        System.out.println("father的靜態(tài)塊");
    }
}

class Childa extends Fathera{
    int a = 2;
    Childa(){
        System.out.println("child");        
    }
    static int getB() {
        System.out.println("child的getb");
        return d;
    }
     int getC() {
        System.out.println("child的getc");
        return a; 
    }
    {
        System.out.println("child 的普通塊");
    }
    static {
        System.out.println("child的靜態(tài)塊");
    }
}
image.png

package mianxiangduixianggaoji;

public class final1 {
//  final:不能被修改
//  類：不能有子類
//  方法:不能被重寫
//  變量:常量
}
final class x extends y {
    
} 

class y{
    final void haha() {
        System.out.println("Aaaa");
    }
}
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內容