java--多态，内部类

*多态

1.* 多态的前提是向上造型
向上造型即父类型引用 指向 子类型对象
例如： MyInterfaceA a = new MyInterfaceAImpl()；
Object o = new MyInterfaceAImpl()
2.编译器编译时看等号左边类型，JVM运行时看等号右边类型
3.ClassCastException: 类型转换异常
解决方案: 转换之前先判断引用 实际上是不是要转换的类型对象
引用a instanceof 子类型 => boolean

例如：判断b是否为Dog,若果是，执行下面语句，不是，就不执行

if (b instanceof Dog) {
    Dog dog = (Dog) b;
    dog.watchHouse();
}

问 a 实际上是不是子类型对象
## 内部类
1. 种类: 成员内部类,静态内部类,局部内部类[匿名内部类]
匿名内部类也是局部内部类中的一种
2.成员内部类：权限 public,protected,(default),private
语法： public class Outer{
// …
public class Inner{
//…
}
}
3.使用:
内部类中, 可以随意使用外部类成员
外部类中, 使用内部类成员时需要创建内部类对象

public class Body {
        //定义一个私有的整型变量a
        private int a = 1;
        //创建一个公共方法walk
        public void walk () {
            System.out.println("走路走的累死了");
          //在外部类当中创建内部类对象Heart，引用heart来调用内部类当中的方法beat
            Heart heart = new Heart();
            heart.beat();
        }
        //在外部类当中创建一个内部类
        public class Heart {
            //在内部类中定义整型变量b
            int b;
            //定义了整型变量a并初始化
            int a = 2;
         //创建内部类的方法beat
            public void beat() {
                System.out.println("心脏跳动剧烈了起来");
                 System.out.println(Body.this.a);
            }
            

无关类中, 使用内部类成员
1.间接调用, 在外部类方法中调用内部类方法
main方法中, 调用外部类方法
2.直接调用, 需要创建内部类对象
外部类.内部类 a = new 外部类().new 内部类();

public static void main(String[] args) {
    //在无关类当中新建外部类的对象
     Body body=new Body();
     //用引用body直接调用外部类中的方法walk，这样间接调用了内部类的方法beat
      body.walk();
      
      //下面两句是直在无关类当中
      Body.Heart heart=body.new Heart();
      heart.beat();

内部类和外部类有同名成员变量
外部类的成员变量: 外部类.this.变量
内部类的成员变量: this.变量
（同第一张图下边可见）
4.局部内部类: 在方法内部定义类, 只在方法中有效
在局部内部类中, 使用局部变量, 必须是final的
JDK8 后, 局部变量事实上没有发生改变, 那么final可以省略
一次性的类, 只能用一次
而且不能使用权限修饰符
5.局部内部类，需要类只使用一次，优化之后就是匿名内部类了
6.匿名内部类：作用就是继承抽象类或实现接口
语法: new 接口/抽象类() {
int a;
// 实现的所有抽象方法
}
匿名内部类, 只能用一次, new一个对象
匿名对象, 只能使用一次, 只能调用一次方法
注意: 匿名内部类 和 匿名对象 不是一回事 ! ! !
7.实现匿名内部类

//实现了一个匿名内部类
public static void main(String[] args){
    Demo06 impl  = new Demo06() {
        @Override
        public void method1() {
            System.out.println("内部类实现1");
        }

        @Override
        public void method() {
            System.out.println("内部类实现2");
        }

    };
    //引用impl去调用两个方法
    impl.method1();
    impl.method();
}

接口当中定义抽象方法

public interface IntearfaceB {
    //在接口中定义两个抽象方法
    void method1();
    void method();
}

8.静态内部类

public class Outer {
    //定义一个外部类的成员变量
    int a=10;
    //定义一个外部类的静态成员变量
    static int b=20;
    //创建公共方法m1
    public void m1(){
        //输出成员变量a
        System.out.println(a);
    }
     //创建一个静态内部类
    public  static  class Inner{
        //定义一个静态内部类的成员变量c
        int c=1;
        //创建公共方法m2
        public void m2(){
            System.out.println(c);
            //由于a是在外部类中定义出来的成员变量，而b是定义的静态成员变量，所以a是属于对象，b是属于类的。
            //System.out.println(a);
            System.out.println(b);

        }

9.父类可以作为返回值或者参数
用Animal举例

//Animal作为返回值类型，该方法可以返回多种不同的参数
public Animal salePet() {
    //
    return null;
}

//Animal作为参数，可以传递多种不同的对象
public static void giveMePet(Animal b) {
    //把参数b传递给了dog
      //用dog去调用watchHouse方法
        //Dog dog = (Dog) b;
        //dog.watchHouse();
     //上面两句合并成一句
        ((Dog)b).watchHouse();


}