Java多形性

封装

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构
同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承

继承是为了重用父类代码。两个类若存在"is--a" 的关系就可以使用继承

多态

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的
方法调用在编程时并不确定，而是在程序运行期间才确定

上溯造型 父类指向子类

父类=====>子类-----（上溯造型）
class Father {
    public int i = 1;
    public void say(){
        System.out.println("我是大头爸爸");
    }
}
class Son extends Father{
    public void say(){
        System.out.println("我是小头儿子");
    }
}

public class Test {
    public static void main(String[] args) {
               Father f = new Son();
               System.out.println(f.i);
               f.say();
    }
}
结果：
我是大头爸爸

下溯造型 父类转子类

public class Test {
    public static void main(String[] args) {
        Father f = new Son();
        Son son = (Son)f;
        son.say();
    }
}
结果：
     我是小头儿子

重写（覆盖）

重写，也称为覆盖，是指派生类重写了基础类的方法。

重载，指一个类里面的方法名相同但是参数列表不同。

过载，指在一个类中拥有多个同名但参数列表不同的方法，这样编译器就可以根据不同的参数来调用不同的方法实现过载。

class InstrumentX {
    public void play(int NoteX) {
        System.out.println("InstrumentX.play()");
    }
}
class WindX extends InstrumentX {
    // OOPS! Changes the method interface:
    public void play(int  NoteX) {
        System.out.println("WindX.play(NoteX n)");
    }
}
public class Main {
    public static void main(String[] args) {
        WindX flute = new WindX();
        flute.play(3);
    }
}
结果：
     WindX.play(NoteX n)

抽象类和方法

// 这就是一个抽象类
abstract class Animal {
    String name;
    int age;
    // 动物会叫
    public abstract void cry(); // 不确定动物怎么叫的。定义成抽象方法，来解决父类方法的不确定性。抽象方法在父类中不能实现，所以没有函数体。但在后续在继承时，要具体实现此方法。
}

// 抽象类可以被继承
// 当继承的父类是抽象类时，需要将抽象类中的所有抽象方法全部实现。
class Cat extends Animal {
    // 实现父类的cry抽象方法
    @Override
    public void cry() {
        System.out.println("喵喵喵");
    }
}
class Dog extends Animal {
    @Override
    public void cry() {
        System.out.println("汪汪汪:");
    }
}

 public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cat cat = new Cat();
        cat.cry();

        Dog dog = new Dog();
        dog.cry();
}
结果：
     喵喵喵
     汪汪汪:

总结
1、当父类的某些方法不确定时，可以用abstract关键字来修饰该方法
2、用abstract修饰的类，即抽象类；用abstract修饰的方法，即抽象方法
3、抽象方法不能有方法主体。只有定义，没有实际实现。
4、抽象类不能被实例化。因为抽象类中方法未具体化，这是一种不完整的类，所以直接实例化也就没有意义了。
5、抽象类中不一定要包含abstrace方法。也就是了，抽象中可以没有abstract方法。
6、一旦类中包含了abstract方法，那类该类必须声明为abstract类。

接口

1、它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型
2、接口也包含了基本数据类型的数据成员
3、为创建一个接口，请使用 interface 关键字

interface Animal {
    public void eat();
    public void travel();
}
 class Cat implements Animal{

    public void eat(){
        System.out.println("cat eats");
    }

    public void travel(){
        System.out.println("cat travels");
    }

    public int noOfLegs(){
        return 0;
    }

}

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal cat = new Cat();
        cat.eat();
        cat.travel();
}
结果：
     cat eats
     cat travels

总结

1、类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
2、类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
3、如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

接口与类相似点：
1、一个接口可以有多个方法。
2、接口文件保存在 .java 结尾的文件中，文件名使用接口名。
3、接口的字节码文件保存在 .class 结尾的文件中。
4、接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：
1、接口不能用于实例化对象。
2、接口没有构造方法。
3、接口中所有的方法必须是抽象方法。
4、接口不能包含成员变量，除了 static 和 final 变量。
5、接口不是被类继承了，而是要被类实现。
6、接口支持多继承。