【Java】多态 内部类

多态

        同类型的对象，执行同一个行为，会表现出不同的行为特征

多态的常见形式：

父类类型 对象名称 = new 子类构造器;

接口 对象名称 = new 实现类构造器;

例：

Animal a = new Dog();

多态中成员访问特点

方法调用：编译看左边，运行看右边

变量调用：编译看左边，运行也看左边(多态侧重行为多态)

多态的前提

有继承/实现关系；有父类引用指向子类对象；有方法的重写

多态的特征

优势：

在多态形式下，右边对象可以实现解耦合，便于扩展和维护

劣势：

多态下不能使用子类的独有功能

引用数据类型的类型转换：

        自动类型转换(从子到父)：

                子类对象赋值给父亲类型的变量指向

        强制类型转换(从父到子)：

                此时必须进行强制类型转化：子类 子类对象变量 = (子类)父类对象变量

                作用：可以解决多态下的劣势，可以实现调用子类的独有功能

                注意：如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException

例：

Animal a = new Cat();

Dog d = (Dog)a;

//运行后出现异常ClassCastException

Java建议强制类型转换前使用instanceof判断当前对象的真实类型，在进行强制转换

例：

        变量名 instanceof 真实类型

        判断关键字左边的变量指向的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.run();

        if (a instanceof Cat){
            Cat c = (Cat) a;
            c.ClimbTree();
        }else if (a instanceof Dog) {
            Dog d = (Dog) a;
            d.LookDoor();
        }
    }
}
class Animal{
    public void run(){
        System.out.println("动物跑");
    }
}
class Cat extends Animal{
    public void ClimbTree(){
        System.out.println("猫爬树");
    }
}

class Dog extends Animal{
    public void LookDoor(){
        System.out.println("狗看门");
    }
}

1.引用数据类型的类型转换，有几种？

        自动类型转换，强制类型转换

2.强制类型转换能解决什么问题？强制类型转换需要注意什么？

        可以转换成真正的子类类型，从而调用子类独有功能

        有继承关系/实现的2个类型就可以进行强制转换，编译无问题

        运行时，如果发现强制转换后的类型不是对象真实类型则报错

        类型转换异常：ClassCastException

内部类

        内部类就是定义在一个类里面的类，里面的类可以理解成(寄生)，外部类可以理解成(宿主)

例：

public class People(){

        public class Heart{

        }

}

内部类场景 作用

        当一个事务的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为了外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。

        内部类通常可以方便访问外部类的成员，包括私有成员。

        内部类提供了更好的封装性，内部类本身就可以用private protectcd等修饰，封装性可以做更好的控制

静态内部类

        有static修饰，属于外部类本身

        它的特点和使用于普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已

例：

public class Outer{

        //静态成员内部类

        public static class Inner{

        }

}

静态内部类创建对象的格式：

        外部类名.内部类名 对象名 = new 外部类名.内部类构造器(); 

例：

        Outer.Inner in = new Outer.Inner();

静态内部类的使用场景 特点 访问总结

        如果一个类中包括了一个完整的成分，如汽车类中引擎类，人类中心脏类

        与普通类是一样的，类有的成分它都有，只有位置在别人里面而已

        可以直接访问外部类的静态成员，不能直接访问外部类的实例成员

        开发中用的还是比较少

成员内部类 

        无static修饰，属于外部类的对象

        JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员了

例：

public class Outer{

//成员内部类

        public class Inner{

        }

}

成员内部类创建对象的格式：

        外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();

例：

        Outer.Inner in = new Outer().new Inner(); 

 成员内部类的访问总结

成员内部类中是否可以直接访问外部类的静态成员？

        可以，外部类的静态成员只有一份可以被共享访问

成员内部类的实例方法中是否可以直接访问外部类的实例变量？

        可以，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。 

局部内部类 

局部内部类放在方法，代码块，构造器等执行体中(很少用到)

局部内部类的类文件名，外部类$内部类.class

匿名内部类

        本质上是一个没有名字的局部内部类，定义在方法中，代码中等

        作用是方便创建子类对象，最终目的为了简化代码编写

格式：

new 类|抽象类名|接口名(){

        重写方法;

}

例：

Animal a = new Animal(

        public void run(){

        }

);

a.run();

匿名内部类特点总结

匿名内部类的作用？

        方便创建子类对象，最终目的为了简化代码编写

匿名内部类的特点？

        匿名内部类是一个没有名字的内部类

        匿名内部类写出来就会产生一个匿名内部类的对象

        匿名内部类的对象类型相当于是当前new的那个的类型的子类类型

public class Test {
    public static void main(String[] args) {
//匿名内部类
        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("吃");
            }
        };

    run(a);

//创建run方法
    public static void run(Animal animal){ 
        animal.eat();
        System.out.println("跑起来了");
    }
}
//创建接口
interface Animal{
    void eat();
}