封装 多态 继承

封装：private修饰字段以及方法
          意义：安全性，对于类的调用者降低了类的使用成本
          private 可以修饰构造方法，也可以修饰类
          被private修饰之后只能在当前类之中使用

这些语法比较抽象，所以理解起来需要过程
面向对象语言的基本特征：封装 继承 多态 组合
不要写java语言的三大特征
熟悉面向对象语言的基本特征如继承封装多态

继承：从程序上理解什么继承，将共性进行抽取，使用extends关键字实现继承
          子类 派生类
          父类 基类 超类
          is-a
          优点：代码可以进行重用
     注意：1.java中一个子类只能继承一个父类，单继承，不能继承多个类
     2.子类会继承父类的所有public的字段和方法，父类中的private字段何方子类是无法进行访问的
     3.子类的实例中也还包含着父类的实例，可以使用super关键字得到父类实例的引用
      

子类继承了父类：子类到底继承了父类的什么？继承所有的字段包含私有，但是无法访问到私有，静态的不会被继承，是在静态区的

子类中可以有和父类中相同的属性，会优先使用子类中。可以使用super调用父类的

      引入一个关键字：super父类对象的引用
      1.super.data;//访问父类的成员变量
      2.super.func();//访问父类的成员方法
      3.super();//访问父类的构造方法，放在第一行

      this当前对象的引用
      1.this.data();//访问当前对象的成员变量
      2.this.func();//访问当前对象的成员方法
      3.this();//访问当前对象的构造方法

      super：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） 。
      this：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）。

      子类对象要构先要帮助父类对象进行构造，所有的构造对象都要通过构造方法进行构造

      当将父类的属性设置为private的时候，必须使用get set 方法
      protected 修饰可以本类，同一个包中的其他类，不同包中的子类

      java中对于字段和方法共有四种访问权限：
      private只能在本类中使用
      默认的访问权限是在本包中
      protected本类，同一个包中的其他类，不同包中的子类
      public 本类 本包中的其他类 不同包中的子类 不同包中的非子类

      super和this都不能在静态方法中进行使用

      多重继承一般不要超过三个，final修饰类，表示类不能再被继承了
      final 修饰变量，不能被修改了
      final修饰类代表密封类，不能被继承了，限制类被继承
      final修饰方法
      String 类就是final密封类

组合： a part of 或者是 has a
        学校：学生和老师
        将一个类的实例对象作为另一个类的字段，相当于public String name

多态：
        向上转型：上边是父类，下面是子类，把子类对象给父类的过程，向上转型：父类引用引用子类对象
        向上转型之后只能通过父类引用来访问父类自己特有的属性和方法，不能访问子类特有的属性的方法

        向下转型：不安全，转型一定是自己的实例
      

   Animal animal1 = new Dog("dog",12);
        //判断是否是Bird的实例
        if(animal instanceof  Bird){
            Bird bird2 = (Bird) animal;
            bird2.fly();
        }

        运行时绑定：当父类对象引用子类对象，通过父类引用调用父类和子类的同名覆盖方法此时就会发生运行时绑定，绑定的是子类和父类同名的方法
        运行时绑定时多态的基础

        重写 覆盖 复写 子类于父类之间
        1.函数名称相同
        2.函数参数列表相同（类型 个数）
        3.函数的返回值相同（可以不相同但是返回值间要构成父子类关系，协变类型）

        重载：
        1.函数名称相同
        2.函数参数列表不同(类型 个数)
        3.返回值不做要求

        汇编：
        invokespecial 构造方法
        invokevirtual 普通的方法
        invokestatic  静态方法

        重写需要注意：
        1.static静态方法之间不能构成重写
        2.private方法之间也不能构成重写
        3.子类的访问权限大于父类的访问权限
        4.如果一个方法被final修饰，这个方法就不能被重写，密封方法

        向上转型发生时机
        1.直接赋值        2.方法传参
     

    public static void func(Animal animal){
                animal.eat();
        }

        public static void main(String[] args) {
            Dog dog = new Dog("HH",10);
            func(dog);
            Bird bird = new Bird("HH",10,"dd");
            func(bird);
        }

        3.返回值

      public static  Animal func2(){
            Dog dog = new Dog("HH",10);
            return dog;
        }

        1.只是通过一个叫做animal.eat()方法
        2.传的参数不一样，代表这个引用引用的对象不一样
        3.通过这个引用调用同一个方法，表现出不同的形式，这种思想，这种清形叫做多态

        构造方法中调用的方法表面是父类的方法，实际是调用子类的方法如何理解多态？
父类引用  引用子类对象，通过父类引用调用父类和子类同名的重写方法，此时，如果父类引用引用的子类对象不一样，调用这个重写的方法表现得行为也是不一样的

class Shape{
    public void draw(){

    }
}

class Cycle extends  Shape{
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}
class Rect extends  Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
public class TestExemple {
    public static void drawMap(Shape shape){
        shape.draw();
    }

    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        drawMap(cycle);
        Rect rect = new Rect();
        drawMap(rect);
    }

}

    多态的好处：
    1.类调用者对类的使用成本进一步降低了
    2.能够降低代码的圈复杂度，避免使用很多的if--else
    3.可扩展性强