Java学习-10 多态

多态： 对象多态、行为多态
多态是在继承/现实情况下的一种现象，变现为：对象多态、行为多态

public class People {
    public void run(){
        System.out.println("跑步");
    }
}

public class Student extends People{
    @Override
    public void run(){
        System.out.println("跑的贼快");
    }
}

public class Teacher extends People {
    @Override
    public void run(){
        System.out.println("跑的不如学生快");
    }
}

public class Test {
    public static void main(String[] args) {
        // 行为多态
        People p1 = new Teacher();
        p1.run(); // 编译看左边 运行看右边
        People p2 = new Student();
        p2.run();

    }
}

if(p1 instanceof Student){
Student s2 = (Student) p1;
s2.test();
} else {
Teacher t2 = (Teacher) p1;
t2.teach();
}
在多态情形下，右边对象是解耦合的，更便于扩展和维护
定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强，更便利

多态缺点
不能调用子类的独有方法

解决方法
强转 子类 变量名 = (子类)父类变量

强转类型需要注意
存在继承/实现时，就可以进行强制类型转换，编译阶段不会报错，但是运行时，如果发现对象的真实类型与强转后的类型不同会报错（ClassCastException）
所以Java建议在强转前使用instanceof判断当前对象真实类型： 对象 instanceof 类型

final
最终意思，可以修饰（类、方法、变量）
修饰类：该类被称为最终类，特点是不能被继承
修饰方法：该方法被称为最终方法，特点是不能被重写
修饰变量：该变量只能被赋值一次

final修饰变量是注意
final修饰基本类的变量，变量存储的数据不能被改变
final修饰引用类型的变量，变量存储的地址不能被改变，但是地址所指向的内容可以被改变的

常量
使用static final修饰的成员变量被称为常量
作用
通常用于记录系统的配置信息
例如 public static final String LEARN_NAME = “dong”;
注意~常量名的命名规范：建议使用全大写单词，多个单词用下滑线分开

使用常量的优势
代码可读性好、可维护性也好
编程编译后，常量会被“宏替换”：出现常量的地方全部被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能一样的

抽象类
在Java中有一个关键字 abstract， 它就是抽象的意思，可以用它修饰类、成员方法
abstract修饰类就是抽象类，修饰方法就是抽象方法
修饰符 abstract class 类名 {
修饰符 abstract 返回值类型 方法名(形参列表 ){}
}

抽象类特点
抽象类中可以不写抽象方法，但有抽象方法一定要是抽象类
类有的成员（成员变量，方法、构造器）抽象类都具有
抽象类不能创建对象，仅作为一种特殊的父类，让子类继承实现
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类

抽象类的场景和好处
父类知道子类都要做某个行为，但是每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现，我们设计这样的抽象类，就是为了更好支持多态。

模板方法设计模式的写法
定义一个抽象类
在里面定义2个方法
一个是模板方法：把相同代码放里面 建议使用final关键字防止他人重写
一个是抽象方法：具体实现交给子类完成

认识接口
Java提供一个关键字interface，用这个关键字我们可以定义一个特殊结构：接口
public interface 接口名{
// 成员变量
// 成员方法（抽象方法）
}
注意： 接口不能创建对象，接口是用来被类实现的，实现接口的类称为实现类
修饰符 class 实现类 implements 接口1，接口2，接口3…{}

一个类可以实现多个接口（接口可以理解成干爹），实现类实现多个接口，必须重写完全部接口抽象方法，否则实现类需要定义成抽象类

使用接口的好处
可以解决单继承的问题，通过接口，可以让一个类有一个亲爹的同时，有多个干爹去扩展自己的功能
接口去找干爹，别人通过你的implements的接口，就可以显性的知道你是谁，从而就可以放心的把你当做谁来用
一个类可以实现多个接口，同样一个接口可以被多个类实现，这样程序员就可以面向接口编程了，程序员就可以很方便的灵活切换各种业务实现

JDK8开始接口新增三种方法
默认方法 default
私有方法 private
静态方法 static

接口一些注意实现
1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
3、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的
4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可

成员内部类
就是类中一个普通成员，类似前面我们学过的普通成员变量，成员方法
外部类名.内部类名 对象名 = new 外部类(…).new 内部类(…)
特点
可以直接访问外部类的实例成员、静态成员
可以拿到当前外部类对象，格式是：外部类.this.变量 // 内部局域变量，内部类，外部类变量名相同时 使用

静态内部类
使用static修饰 属于外部类自己持有
外部类.内部类 对象 = new 外部类.内部类(…)
只能访问外部的静态成员，不能访问实例成员

public class Outer{
		public static class Inner{}
}

匿名内部类
就是一种特殊的类，所谓匿名就是程序员不需要为这个类起名字
new 类或接口(形参列表){ 类体(一般是方法重写) }
匿名内部类本质就是一个子类，并且立即创建一个子类对象

匿名内部类在实践中，一般是作为一个参数传给方法

枚举类是一种特殊类
枚举类的第一行只能罗列一些名称，这些名字都是常量，并且每个常量记住的都是枚举类的一个对象
枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象
枚举都是最终类，不可被继承
枚举类中，从第二行开始可以定义类的其他成员
编译器为枚举类新增了几个方法，并且枚举类都是继承：java.lang.Enum类的，从enum类也会继承到一些方法。

public enum A {
    X,Y,Z;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

相当于

public final class A extends Enum<A> {
  public static final A X;
  public static final A Y;
  public static final A Z;
  public static A[] values();
  public static A valueOf(String);
  public String getName();
  public void setName(String);
  static {};
}