java中面向对象编程的三大特征------多态

1. 多态可以理解成是封装的更进一步, 让类调用者对类的使用成本进一步降低

2. 发生多态要满足的条件？
   ①继承 --》父类需要引用子类对象（要向上转型）
   ②通过子类的引用，去调用父类和子类同名的重写（覆盖）方法

3. 向上转型：
   定义： 父类的引用，指向一个子类的实例，这种写法叫向上转型
   向上转型发生的时机：

// 父类
class Animal{
protected String name;
protected int age;
public Aniaml(String name,int age){
  this.name=name;
  this.age=age;
public void eat(){
  System.out.println(this.name+"eat()");
 }
}
// 子类
class Cat extends Animal{
public String sex;

public Cat(String name,int age,String sex){
 super（name,age）;
  this.sex=sex;
public void eat(){
  System.out.println(this.name+"eat()");

① 直接赋值：
父类引用子类对象 ，父类和子类有同名的覆盖方法，通过父类的引用去调用这个同名方法

Animal animal=new cat(eat);

② 方法传参：

public static void func(Animal animal){
  animal.eat();
}
public static void main(String[] args){
Cat cat=new Cat;
func(cat);
// 执行结果调用cat的方法

③ 方法返回：

public static Animal func2(){
Cat cat=new Cat();
return cat;
}
public static void main(String[] args){
Animal animal=func2();

== 如果发生了向上转型，父类只能调用父类自己的方法或成员属性==

3. 当父类与子类有同名的方法时，父类的引用指向不同的实例对象时，调用的方法也不同，这个过程发生在运行时期（而不是绑定时期），因此称运行时绑定（运行时多态）。

4. 子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 重写 / 覆盖 / 覆写(Override)。
   == 重写（覆盖）注意事项：==
   ① 重写的方法不能是private
   ② 子类方法的权限要大于父类方法的权限
   ③ 重写不能是一个静态的方法
   ④ 推荐在代码中进行重写方法时显式加上 @Override 注解

5. 重写和重载的区别是什么？
   重写（Override）：方法名相同，参数列表相同，返回值相同，不能是静态方法，发生在继承关系中，子类的方法权限要大于父类访问权限
   重载（Overload）；方法名相同，参数列表不同，返回值不做要求，发生在一个类当中，没有权限的要求

6. 向下转型：（慎用）
   前提是必须先向上转型。父类赋值给子类，需要强转，容易发生类型转换异常。所以向下转型前 要判断:if ( animal instance of Cat){ } ，即 cat是不是animal的实例对象

 class Bird extends Animal {
        public void fly() {
            System.out.println("fly()");
        }

        public static void main(String[] args) {
            Animal animal = new Bird();
            animal.eat;
            Bird bird = (Bird) animal;
            bird.fly();
        }
    }

7. this 和 super 的区别？
   this：当前对象的引用，访问本类中的属性和方法
   super：当前父类的引用，由子类访问父类中的属性和方法

8. 构造方法内是否可以发生运行时绑定？
   可以
   构造 子类的对象时, 会先调用父类的构造方法，父类中调用了同名方法时, 发现子类重写了该方法，此时会触发动态绑定, 会调用到子类中的同名方法。（该过程未发生向上转型）

9. 代码理解多态：
   多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可

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("□");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("♣");
    }
}
public class Test {
    public static void main1(String[] args) {
        Shape shape1 = new Flower();
        Shape shape2 = new Cycle();
        Shape shape3 = new Rect();
        drawMap(shape1);
        drawMap(shape2);
        drawMap(shape3);
    }
    // 打印单个图形
    public static void drawMap(Shape shape) {
        shape.draw();
    }
}