【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("吼吼");
    }
}