JAVA面向对象----多态

多态：

     1. 多态是同一个行为具有多个不同表现形式或形态的能力。

     2. 多态就是同一个接口，使用不同的实例而执行不同操作

     3.多态性是对象多种表现形式的体现。

多态的优点：

• 消除类型之间的耦合关系

• 可替换性

• 可扩充性

• 接口性

• 灵活性

• 简化性

多态存在的必要条件：

• 继承

• 重写

• 父类引用指向子类对象

多态的实现方式：

方式一：重写与重载

 Java 重写(Override)与重载(Overload)。

方式二：抽象类和抽象方法

方式三：接口

就是一些方法特征的集合，但没有方法的实现（没有方法体）

注意：
       1.具有抽象方法的类一定是抽象类但抽象类不一定有抽象方法。
       2.子类继承父类，要么子类必须重写父类中的抽象方法，要么子类也是抽象类。

例如 ：

        但注意：子类如果要继承抽象的父类：

                       1.子类要重写父类的方法。

                       2.子类也是抽象类。

                      抽象类不能被实例化，要想实例化，只能实例化它的实现类。

public abstract class Animal {
    public abstract void eat();

    public void drink() {

    }

    class Dog extends Animal{

        @Override
        public void eat() {
            
        }
    }

    class Cat extends Animals {

        @Override
        public void eat() {
        
    }
}

    public abstract class Person extends Animals{

    }
}

接口：

       1. Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。 

       2. 在接口中的方法为抽象方法 不允许出现方法体

       3. Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的

           特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这

           些实现可以具有不同的行为（功能）。

例如：

        声明两个接口，让第三个接口继承前两个接口（接口可以实现多继承）

        

/**
 * 在接口中的方法为抽象方法 不允许出现方法体
 * 从java8开始允许接口中的方法有方法体 但必须使用default或修饰
 * 在接口中 static 修饰的方法
 *  只能使用接口名点方法名的方式调用不能使用实现类的实例化对象调用
 *  不可以被子接口继承
 * 在接口中 default 修饰的方法
 *  只能使用实现类的实例化对象调用
 *  可以子接口继承
 *  可以被子接口重写
 *  可以被实现类重写
 */

public interface InterFace01 {
    void if01Fun();
}

public interface InterFace02 {
    void if02Fun();
}

public interface InterFace03 extends InterFace01,InterFace02{
    void if03Fun();
}

        实现接口：

public class InterFace03Impl implements InterFace03{
    @Override
    public void if03Fun() {
        System.out.println("我是if03Fun");
    }

    @Override
    public void if01Fun() {
        System.out.println("我是if01Fun");
    }

    @Override
    public void if02Fun() {
        System.out.println("我是if02Fun");
    }
}

        测试：

public class InterFace03Test {
    @Test
    public void test0(){
        InterFace03 interFace03=new InterFace03Impl();
        interFace03.if01Fun();
        interFace03.if02Fun();
        interFace03.if03Fun();
    }
}

​

函数式接口：

/**
*当接口中只有一个抽象方法的时候我们称这个接口为函数式接口。
*可以使用FunctionalInterface注解修饰但不是必须的。
*使用FunctionalInterface注解修饰的函数式接口会增加校验
*/

          声明一个函数式接口：

@FunctionalInterface
public interface InterFace {
    void eat();
}

        测试：实现接口，不用实现类（下面是测试类接口实现的普通形式和lambda表

                   达式形式一步一步的简化过程）

public class InterFaceTest {
    @Test
    public void test01() {
        new InterFace() {
            @Override
            public void eat() {
                System.out.println("民以食为天");
            }
        }.eat();
    }

    @Test
    public void test02() {
        InterFace interFace = new InterFace() {
            @Override
            public void eat() {
                System.out.println("民以食为天");
            }
        };
        interFace.eat();
    }

    @Test
    public void test03() {
        InterFace interFace = () -> {
            System.out.println("民以食为天");
        };
        interFace.eat();
    }

    @Test
    public void test04() {
        InterFace interFace = () -> System.out.println("民以食为天");
        interFace.eat();
    }
}