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