多态的总结

多态：

一种事物的多种形态|多种表现形式

行为的多态

一个行为的不同的实现方式

多态的前提：

类的继承|接口的实现

多态的最终体现：

父类的引用指向子类的对象

注意：如果多态想要有意义，需要配合方法的重写，多态才有意义

多态调用：

会调用子类中重写的方法

多态的实现效果：

配合方法的重写，当父类引用指向不同的子类对象，同一个方法具有不同的实现方式-->行为多态

public class Class001_Polymorphic {
    public static void main(String[] args) {
        //对应类型的数据赋值给对应类型的变量
        int i = 1;
        Person p = new Person();
        Student s = new Student();
        //多态的最终体现
        Person person = new Teacher();
        person.test();
    }
}
//定义父类
class Person{
    void test(){
        System.out.println("Person");
    }
}
//子类
class Student extends Person{
    void test(){
        System.out.println("Student");
    }
}
//子类
class Teacher extends Person{
    void test(){
        System.out.println("Teacher");
    }
}

多态调用成员的特点：

父类引用调用

成员变量：

编译运行看父类|左边|类型

成员方法：

编译看父类|左边|类型

运行看子类|右边|对象

注意：

多态是行为的多态

多态如果不配合方法的重写没有意义

父类引用对子类新增内容不可见

类型转换：

基本数据类型：类型转换

//先定义变量
int i = 1;
byte b;
//自动类型提升
long l = i;
//强制类型转化
b = (byte)i;

引用数据类型：转型

类型的大小：看继承关系|实现关系

父类 > 子类

//向上转型：自动类型提升
    Person p = new Student();//--> 多态
//向下转型：强制类型转换
    Student s = (Student)p;
//可通过 s 引用调用Student类型所有的内容

注意：

运行过程中可能出现ClassCastException 类型转换异常

引用强转类型的时候，没有转为指向的子类对象类型，转为其他子类类型，出线的异常。

预防出现类型转换类型异常：

引用instanceof类型：判断前面的引用是否指向后面类型的对象或者后面类型子类的对象，是->true 不是->false

抽象的：

抽象类：被abstract修饰的类

抽象方法：被abstract修饰的方法

没有方法体

存在与抽象类中

特点：

1、抽象类不能实例化

2、抽象类可以定义任意内容（属性，功能（抽象的方法，具体的方法））

3、抽象方法必须要求被重写

4、抽象类使用：通过具体子类对象使用

具体子类：重写所有的抽象方法 + 按需新增

抽象子类：按需重写抽象方法 + 按需新增

5、一个抽象方法一旦被重写，可以不再被重写，根据需求决定

6、abstract 不能与 private ， final ， static ， native 一起使用

7、抽象类可以实现多态

public class Class001_Abstract {
    public static void main(String[] args) {
        //Develop d = new Develop();
        //具体子类对象
        Develop java = new Java();
        java.work();
        java.sleep();
        //java.mr();
    }
}
//父类
abstract class Develop {
    //方法体: 不知道怎么写,不知道写什么
    public abstract void work();
    //具体方法
    public void sleep(){
        System.out.println("胡吃海喝!!!!");
    }
}
//子类
class Java  extends Develop{
    @Override
    public void work() {
        System.out.println("服务器端开发");
    }
    //新增功能
    public void mr(){
        System.out.println("与测试,产品,谈论...探讨...");
    }
}
//抽象子类
abstract class Web extends Develop{
    //public abstract void work();
    public void haha(){
        System.out.println("每天哈哈傻笑...");
    }
}

接口：

接口可以理解为是一个特殊的抽象类

功能的集合

引用数据类型

接口可以帮助定义规范

解耦--> 降低耦合度

类是单继承 ， 接口多实现

定义：

insterface 定义接口

组成：

jdk7及之前：

公共的静态的常量

public static final --> 修饰符可以任意省略

公共的抽象的方法

public abstract --> 修饰符可以任意省略

使用：

1、接口不能实例化

2、接口需要通过实现类的对象使用

3、父类需要通过子类继承 extends --> 父类的成员，子类继承父类有权可以直接使用

接口需要通过实现类去实现 implements --> 因为接口中几乎都是抽象方法没有方法体，需要实现类自己实现方法体，所有就叫做实现

接口的实现与类的继承很想，都拥有了父类的成员使用权，或者拥有接口中定义的功能，但是一个侧重点再拿过来就用，一个侧重点在拿过来要实现才能用

4、接口的使用：

具体的实现类：重写所有的重写方法 + 按需新增

抽象的实现类：按需重写 + 按需新增

5、接口可以多实现，类只能单继承

6、如果一个类同时继承父类实现接口，要求先继承后实现

public class Class001_Interface {
    public static void main(String[] args) {
        System.out.println(MyInterface.PI);
        //根据具体的实现类的对象使用
        MyImpl my = new MyImpl();
        my.test1();
        my.test1();
        my.haha();
    }
}
//接口
interface MyInterface{
    //公共的静态的常量
    double PI = 3.14;
    //公共的抽象的方法
    public abstract void test1();
    void test2();
}
interface A{
    void a();
}
interface B{
    void b();
}
//具体实现类
class MyImpl  extends Object implements MyInterface,A,B {
    @Override
    public void test1() {
    }
    @Override
    public void test2() {
    }
    //新增内容
    public void haha(){}
    @Override
    public void a() {
​
    }
    @Override
    public void b() {
    }
}
//抽象实现类
abstract class MyImpl2 implements MyInterface{
    @Override
    public void test1() {
​
    }
}

jdk8之后：新增

1、静态方法：可以定义方法体

使用：通过接口名使用

2、默认方法：可以定义方法体

显示的被default修饰

使用：通过实现类对象使用

public class Class003_Inteface {
    public static void main(String[] args) {
        Swim.test();
        //实现类对象
        new SwimImpl().test2();
    }
}
interface Swim{
    void swimming();
    //静态方法
    public static void test(){
        System.out.println("静态方法");
    }
    //默认方法
    public default void test2(){
        System.out.println("默认方法");
    }
}
class SwimImpl implements Swim{
    @Override
    public void swimming() {
​
    }
}

注意：

1、父类与接口无法完全相互代替，如果可以建议使用接口，因为接口可以多实现非常灵活

2、类与类之间只能继承

类与接口之间，只能是类继承接口

类与类之间之只能单继承

类与接口之间可以多实现

接口与接口之间，可以多继承

3、接口可以实现多态，接口引用指向实现类对象

public class Class002_Interface {
    public static void main(String[] args) {
        testSmoke(new Teacher());
    }
    /**
     * 会继续吸烟的人
     * @param s Smoke接口的实现类对象
     */
    public static void testSmoke(Smoke s){  //Smoke s = new Teacher();  接口多态
        s.smoking();
    }
}
//父类
class Person{
    public String name;
    public int age;
​
    public void sleep(){
        System.out.println("闭上眼睛休息");
    }
}
//接口  吸烟
interface Smoke{
    void smoking();
}
//喝酒
interface Drink{
    void drinking();
}
interface Code{
    void code();
}
//总和接口 : 吸烟 喝酒 打牌...
interface Amusement extends Smoke,Drink{}
//子类
class Teacher extends Person implements Smoke,Code,Drink{
    public String subject; //学科
​
    public void teach(){
        System.out.println("教书育人");
    }
    @Override
    public void smoking() {
        System.out.println("标准的吸烟方法");
    }
    @Override
    public void code() {
​
    }
    @Override
    public void drinking() {
    }
}
class Student extends Person implements Code{
​
    @Override
    public void code() {
    }
}
//社会人
class SocialMan extends Person implements Amusement{
    @Override
    public void smoking() {
        System.out.println("社会人吸社会烟...");
    }
    @Override
    public void drinking() {
    }
}