你真的了解java吗？java总结五

java冷知识：在Java中，子类数组的引用可以转换成父类数组的引用，而不需要采用强制类型转换。

1.多态

什么是多态？

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

多态成员的访问特点：

• 方法调用：编译时看左边，运行时看右边
• 变量调用：编译、运行时都看左边

public abstract class Animal {
    public String name="动物";
    public abstract void run();
}

public class Dog extends Animal{

    private String name="狗";
    @Override
    public void run() {
        System.out.println("奔跑");
    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        System.out.println(animal.name);
        animal.run();
    }
}

当我们使用多态时，父类在左边，右边是实现类。

调用成员变量时，输出的是父类变量。当调用方法时，需要父类中有这个方法，是由子类实现的。

多态好处：

• 右边对象可以实现解耦合，便于扩展和维护
• 定义方法时，使用父类类型作为参数，该方法就可以接收这父类的一起子类对象，体现多态的扩展性与便利

    public static void main(String[] args) {
        Animal animal = new Dog();
//        System.out.println(animal.name);
//        animal.run();
        go(animal);
    }

    public static void go(Animal animal){
        System.out.println("开始~");
        animal.run();
        System.out.println("结束~");
    }

虽然传参是父类类型Animal，但是调用的方法确实子类Dog的，这又被成为方法回调。

但是不能调用子类中独有的方法。

在上面我们说过，调用方法时，编译看左边，运行看右边。左边父类中如果没有定义该方法，那么在编译期间便会报错。

类型转换问题：

• 自动类型转换（从子到父）：子类对象赋值给父类类型的变量指向
• 强制类型转换（从父到子）：此时必须进行强制类型转换，子类 对象 = （子类）父类类型。

原因：父类的范围大，子类范围小，小范围转大范围不需要强转，大范围转小范围需要强转。

 public static void main(String[] args) {
        //子类转父类
        Animal animal = new Dog();
        
        //父类转子类
        Dog dog = (Dog) animal;
        
    }

注意：有继承或者实现关系，编译阶段可以强转，运行时可能报错。

    public static void main(String[] args) {
        //子类转父类
        Animal animal = new Dog();

        //父类转子类
        Cat cat = (Cat) animal;

    }

虽然编译期间不会报错，但是运行时会报错ClassCastException。

当我们在转换之前，使用instanceof判断当前对象的真实类型，在进行强转。

    public static void main(String[] args) {
        //子类转父类
        Animal animal = new Dog();

        //父类转子类
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
        }else if(animal instanceof Cat){
            Cat cat = (Cat) animal;
        }

    }

2.内部类

使用场景及作用

• 一个事物的内部有一部分需要一个完整的结构来进行描述，而这个内部完整的结构又只为了外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计
• 内部类可以直接访问外部类的静态成员，不能直接访问外部类的实例成员
• 内部类提供了更好的封装性，内部类本身就可以用private protected等修饰，封装性可以做更多控制

1.静态内部类（了解）

由static修饰，与普通类用法相同。

public class People {

    public static class Heart{
        private double width;
        private double height;

        public double getWidth() {
            return width;
        }

        public void setWidth(double width) {
            this.width = width;
        }

        public double getHeight() {
            return height;
        }

        public void setHeight(double height) {
            this.height = height;
        }
    }
}

创建方法

外部类名.内部类名 变量名 = new 外部类名.内部类名

  public static void main(String[] args) {
        People.Heart heart = new People.Heart();
    }

 静态内部类不可以直接访问外部类的实例对象。

2.成员内部类（了解）

创建方法

外部类名.内部类名 变量名 = new 外部类名().new 内部类名

    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
    }

注意：

• 成员内部类可以直接访问外部类静态成员
• 成员内部类的实例方法可以直接访问外部类的实例成员（必须先有外部类，才能有成员内部类）

成员内部类可以通过外部类名去调用外部类的成员变量

public class People {

    private int h = 666;
    public class Heart{
        private int h = 888;
        private double width;
        private double height;

        public void show(){
            int h = 999;
            System.out.println(h);
            System.out.println(this.h);
            System.out.println(People.this.h);
        }
        public double getWidth() {
            return width;
        }

        public void setWidth(double width) {
            this.width = width;
        }

        public double getHeight() {
            return height;
        }

        public void setHeight(double height) {
            this.height = height;
        }
    }
}

    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }

3.局部内部类（了解，几乎不会用到）

• 局部内部类放在方法、代码块、构造器等执行体中
• 局部内部类的类文件名为：外部类$N内部类.class

随用随消失，使用范围在main函数内

    public static void main(String[] args) {
        class Eye{
            int dre;
        }
        
        Eye eye = new Eye();
        
    }

4.匿名内部类（重要）

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

特点：

• 匿名内部类是一个没有名字的内部类
• 匿名内部类写出来就会产生一个匿名内部类对象
• 匿名内部类的对象类型相当于是当前new的内个类型的子类

举例子：

栗子1

public abstract class Animal {
    public abstract void run();
}
class t1{
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void run() {
                System.out.println("我是匿名内部类~~");
            }
        };
        animal.run();
    }
}

栗子2 

public abstract class Animal {
    public abstract void run();
}
class t1{
    public static void main(String[] args) {
        new Animal() {
            @Override
            public void run() {
                System.out.println("我是匿名内部类~~");
            }
        }.run();
    }
}