【122天】尚學堂高琪Java300集視頻精華筆記（43-46）

【122天】尚學堂高琪Java300集視頻精華筆記（43-46）

第43集:面向對象16_final、修飾變量、方法、類

1. final的用法——類——不可被子類繼承。

2. final的用法——變量——初始化一次後，變爲常量。

3. final的用法——方法——不可被子類重寫。

package com.test043;

public class TestFinal {
    public static void main(String[] args){
        final int MAX_VALUE = 200; //常量
        double d = Math.PI;
        Bird a = new Bird();
        a.run();
    }
}

package com.test043;

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

class Bird extends Animal{
    public void run(){
        super.run();
        System.out.println("I`m a bird");
    }
}

第44集:面向對象17_封裝

1. 面向對象三大特徵：繼承、封裝、多態

2. 封裝：須要讓用戶知道的暴露出來，不須要讓用戶瞭解的所有隱藏起來。這就是封裝。

   1. 白話：該露的露，該藏的藏

   2. 專業：咱們程序設計要追求「高內聚，低耦合」。高內聚就是類的內部數據操做細節本身完成，不容許外部干涉；低耦合：僅暴露少許的方法給外部使用。

3. 封裝的具體意義：

   1. 便於調用者調用。

   2. 良好的封裝，便於修改內部代碼，提升可維護性。

   3. 良好的封裝，可進行數據完整性檢測，保證數據的有效性。

4. 訪問控制符
   

5. 封裝使用細節

   1. 屬性通常使用private（除非本屬性肯定會讓子類繼承並使用）提供相應的get/set方法來訪問相關屬性，這些方法一般是public，從而提供對屬性的讀取操做。（注意：boolean變量的get方法是用：is開頭）

   2. 一些只用於本類的輔助性方法可用private，但願其餘類調用的方法用public。

   package com.test044;
   
   public class Test01 {
       private String str;
       protected void print(){
           String s = str;
           System.out.println("Test01.print()");
       }
   }
   
   class Test001 extends Test01 {
       public void pp(){
           super.print();
       }
   
       public static void main(String[] args){
           Test01 t = new Test01();
           t.print();
       }
   
   }

   package com.test044;
   
   public class Man {
       private String name;
       private String id;
       private boolean man;
       public static int cc;
       public static final int MAX_SPEED = 120;
       public String getName(){
           return name;
       }
   
       public void setName(String name){
           this.name = name;
       }
       
       public String getId(){
           return id;
       }
       
       public void setId(String id){
           this.id = id;
       }
       
       public boolean isMan(){
           return man;
       }
       
       public void setMan(boolean man){
           this.man = man;
       }
   }

   package com.test044;
   
   public class Test02 {
       public static void main(String[] args){
           Test01 t = new Test01();
           t.print();
       }
   }

第45集：面向對象18_多態、基本概念、強制轉型問題、instanceof運算符

1. 多態(polymorphism)的做用

   1. 多態性是OOP中的一個重要特性，主要是用來實現動態聯編的，換句話說，就是程序的最終狀態只有在執行過程當中才被決定而非在編譯期間就決定了。這對於大型系統來講能提升系統的靈活性和擴展性。

   2. 多態可讓咱們不用關心某個對象究竟是什麼具體類型，就可使用該對象的某些方法，從而實現更加靈活的編程，提升系統的可擴展性。

   3. 多態性容許不一樣類的對象對同一消息做出不一樣的響應。

2. Java中如何實現多態?使用多態的好處?
   引用變量的兩種類型：

   1. 編譯時類型（模糊一點，通常是一個父類）由聲明時的類型決定。

   2. 運行時類型（運行時，具體是哪一個子類就是哪一個子類）由實際對應的對象類型決定。經過動態綁定調用該對象的方法。動態綁定會使咱們的程序編寫更加靈活，可是會減慢程序運行速度。這也是JAVA比C++/C慢的主要緣由之一。

   若是編譯時類型和運行時類型不一致，就會形成多態。

    

3. 多態的使用要點

   1. 多態是方法的多態，屬性沒有多態性。

   2. 編寫程序時，若是想調用運行時類型的方法，只能進行類型轉換。否則通不過編譯器的檢查。可是若是兩個沒有關聯的類進行強制轉換，會報：ClassCastException。 好比：原本是狗，我把它轉成貓。就會報這個異常。

   3. 多態的存在要有3個必要條件：要有繼承，要有方法重寫，父類引用指向子類對象
       

4. 對象的轉型(casting)

   爲何須要強制轉換類型？由於引用變量只能調用它編譯類型的方法，不能調用它運行類型的方法。這時，咱們就須要進行類型的強制轉換！

5. 一個父類的引用類型變量能夠「指向」其子類的對象。

6. 一個父類的引用不能夠訪問其子類對象新增長的成員（屬性和方法）。

7. 可使用 引用變量 instanceof 類名 來判斷該引用型變量所「指向」的對象是否屬於該類或該類的子類。

8. 子類的對象能夠看成基類的對象來使用稱做向上轉型（upcasting），反之稱爲向下轉型（downcasting）

9. 方法綁定(method  binding)
       

    執行調用方法時，系統根據相關信息，可以執行內存地址中表明該方法的代碼。分爲靜態綁定和動態綁定。

1. 靜態綁定：在編譯期完成，能夠提升代碼執行速度。
2. 動態綁定：經過對象調用的方法，採用動態綁定機制。 這雖然讓咱們編程靈活，可是下降了代碼的執行速度。這也是JAVA比C/C++速度慢的主要因素之一。 JAVA中除了final類、final方、static方法，全部方法都是JVM在運行期才進行動態綁定的。

package com.test045;

public class Animal {
    String str;
    public void voice(){
        System.out.println("普通動物叫");
    }
}

class Cat extends Animal {
    public void voice(){
        System.out.println("喵喵");
    }
    
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void voice(){
        System.out.println("汪汪");
    }
    
    public void seeDoor(){
        System.out.println("看門");
    }
}
class Tiger extends Animal {
    public void voice(){
        System.out.println("吼吼");
    }
}

package com.test045;

public class Test {
    public static void testAnimalVoice(Animal c){
        c.voice();
        if(c instanceof Cat){
            ((Cat)c).catchMouse();
        }
    }

    public static void testAnimalVoice(Dog c){
        c.voice();
    }

    public static void testAnimalVoice(Cat c){
        c.voice();
    }

    public static void testAnimalVoice(Tiger c){
        c.voice();
    }

    public static void main(String[] args){
        Animal a = new Cat();
        Cat a2 = (Cat)a;
        testAnimalVoice(a);
    }
    
}

第46集：面向對象19_多態_內存分析

package com.test046;

public class Test {
    public static void testAnimalVoice(Animal c){
        c.voice();
        if(c instanceof Cat){
            ((Cat)c).catchMouse();
        }
    }
    
    public static void main(String[] args){
        Animal a = new Cat();
        Cat a2 = (Cat)a;
        testAnimalVoice(a);
    }
    
}

package com.test046;

public class Animal {
    String str;
    public void voice(){
        System.out.println("普通動物叫");
    }
}

class Cat extends Animal {
    public void voice(){
        System.out.println("喵喵");
    }
    
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void voice(){
        System.out.println("汪汪");
    }
    
    public void seeDoor(){
        System.out.println("看門");
    }
}
class Tiger extends Animal {
    public void voice(){
        System.out.println("吼吼");
    }
}