多态和内部类

多态和内部类

什么是多态
同一个对象，在不同时刻表现出来的不同形态。

多态的前提
要有继承或实现关系。
要有方法重写。
要有父类引用指向子类对象

多态中的成员访问特点
成员变量：编译看父类，运行看父类。
成员方法：编译看父类，运行看子类。
构造方法：同继承一样，子类会通过super访问父类的构造方法。
代码演示：

class Fu {
   int num = 10;
   public void method(){
       System.out.println("Fu.. method");
  }
}
class Zi extends Fu {
   int num = 20;
   public void method(){
       System.out.println("Zi.. method");
  }
}
​
public class Test2Polymorpic {
   /*
          多态的成员访问特点:
                 成员变量: 编译看左边 (父类), 运行看左边 (父类)
                 成员方法: 编译看左边 (父类), 运行看右边 (子类)
    */
   public static void main(String[] args) {
       Fu f = new Zi();
       System.out.println(f.num);
       f.method();
  }
}

多态的好处和弊端
好处：提高程序的扩展性。定义方法的时候，使用父类作为参数，在使用具体的子类参与操作。
弊端：
不能使用子类的特有成员。

多态的转型
向上转型：父类指向子类的对象就是向上转型。
向下转型：格式：子类型 对象名 = (子类型)父类引用;

class Fu {
   public void show(){
       System.out.println("Fu..show...");
  }
}
​
class Zi extends Fu {
   @Override
   public void show() {
       System.out.println("Zi..show...");
  }
​
   public void method(){
       System.out.println("我是子类特有的方法, method");
  }
}
​
public class Test3Polymorpic {
   public static void main(String[] args) {
       // 1. 向上转型 : 父类引用指向子类对象
       Fu f = new Zi();
       f.show();
       // 多态的弊端: 不能调用子类特有的成员
       // f.method();
​
       // A: 直接创建子类对象
       // B: 向下转型
​
       // 2. 向下转型 : 从父类类型, 转换回子类类型
       Zi z = (Zi) f;
       z.method();
  }
}

多态中转型存在的风险和解决方案

风险
如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
解决方案
关键字：instanceof
使用格式
变量名 instanceof 类型
通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean
代码演示

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){  // Animal a = new Dog();
        								  // Animal a = new Cat();
        a.eat();
        //a.watchHome();
		
        //Dog dog = (Dog) a; // ClassCastException  类型转换异常
        //dog.watchHome();  

        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }
}

内部类

成员内部类
概念：在一个类中定义一个类
创建内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
内部类的访问特点：
可以直接访问外部类的成员，包括私有
外部类访问内部类的成员，必须创建对象
代码案例：`

``java
class Outer{
public void method() {
System.out.println(“外部类的普通方法”);
}

public static void method1() {
    System.out.println("外部类的静态方法");
}

private void method2() {
    System.out.println("外部类的私有方法");
}
//外部类的私有成员变量
private int num2=20;

class Inner{
    int num1 = 10;
    public void show(){
        System.out.println("Inner...show");
        //内部类中可以访问外部类的成员变量，包括私有
        System.out.println(num1 + "..." + num2);
        //内部类中可以访问外部类的成员方法，包括私有和静态
        method();
        method1();
        method2();
    }
}

}

public class OutInnerTest{
public static void main(String[] args){
//创建内部类对象
Outer.Inner in = new Outer().new Inner();
in.show();
}
}
内部类的好处：`
``外部类不能直接访问内部类的成员，提供了一个更好的封装
内部类访问成员变量，访问顺序：
先到内部类方法中的局部范围寻找
再到内部类的成员位置寻找
到外部类的成员位置寻找
如果没找到，就报错
补充：
如果内部类和外部类有同名成员变量，如何访问外部类的成员变量：外部类名.this.成员变量
如果内部类局部范围有和内部类成员范围中相同的变量，如何访问内部类成员变量：this.成员变量
成员内部类：按照内部类在类中定义的位置不同，可以分为如下两种形式：
在类的成员位置：成员内部类
在类的局部位置：局部内部类
匿名内部类
概述：匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）
前提：需要存在一个接口或类
匿名内部类的理解：将继承\实现，方法重写，创建对象放在了一步进行
格式：
new 类名或接口名(){
重写方法;
}
代码展示：

public class Test03 {
    public static void main(String[] args) {
        //1.有了匿名内部类的使用前提，开始创建匿名内部类对象
        new Inter() {

            @Override
            public void eat() {
                System.out.println("吃饭");
            }

            @Override
            public void sleep() {
                System.out.println("和女人睡觉");
            }
        }.sleep();

匿名内部类的使用场景
当方法的形式参数是接口或抽象类时，可以将匿名内部类作为实际参数进行传递

interface Inter{
    public void swimming();
}

public class Test04 {
    public static void main(String[] args) {
        //当一个方法的形式参数是接口类型，就可以使用匿名内部类的形式调用
        useMethod(new Inter() {
            @Override
            public void swimming() {
                System.out.println("男人游泳，一定要带泳镜");
            }
        });
        //使用匿名内部类，让类的功能更加灵活
    }

    public static void useMethod(Inter in) {
        //不要忘记调用接口的方法
        in.swimming();
    }
}