Java入门-08、接口、多态

接口、多态

接口是Java语言中的一种引用类型，是方法的集合
        接口内部主要封装了方法，包含抽象方法，默认方法，静态方法
        定义格式:
public interface 接口名{
//抽象方法
//默认方法
//静态方法
}

接口的使用，它不能创建对象，但是可以被实现（implements）

接口中的抽象方法需要在其实现类中实现，接口中的默认方法则可以不用重写默认方法，也可以重写

使用场景：添加新功能

public interface JieKou1 {

    public abstract void Print();//抽象方法  在继承类中实现其方法

    //静态方法
    public static void run(){
        System.out.println("接口中的静态方法");
    }

    public static void run1(){
        System.out.println("run1方法");
    }

    //默认方法在实现类中可以修改方法（重写）
    public default void Print1(){
        System.out.println("接口内的默认方法");
    }
}

public class Realize implements  JieKou1{
    //抽象方法的实现
    public void Print(){
        System.out.println("实现接口抽象类方法");
    }

    //默认方法的直接调用（直接调用则不需要些该方法体）或者重写
    //下面例子是重写Print1（）
    public  void Print1(){
        System.out.println("重写接口内的默认方法");
    }

    //接口的静态方法无法修改
    public static void run(){
        System.out.println("静态run方法");
    }
}

public class Hello {
    public static void main(String[] args) {
        Realize jieKou2 = new Realize();
        jieKou2.Print();
        jieKou2.Print1();

        /*实现类中并没有重写其run1的静态方法
                在Realize中无法调用run1方法(报错)
                用接口名调用run1方法才可以
        Realize.run1();
        */

        JieKou1.run1();
    }

}

接口的多实现，以及接口与父类知识
1、多个接口中有重名抽象函数，在其实现类中只需要重写一次
2、默认方法有重名的，必须重写一次，不然程序报错
3、接口中出现重名的静态方法并不冲突，因为可以用接口名调用其静态方法
4、优先级问题，一个类既有父类也继承了多个接口，则就近原则选着父类的同名方法

5、一个类继承一个父类的同时实现一个或多个接口，要重写所有的抽象方法

（类不能多继承，只支持单继承）

interface A{
    public abstract void run();
    public abstract void run1();

    public default void Method1(){}
    public default void Method2(){
        System.out.println("A接口的Method2方法");
    }
}


interface B{
    public abstract void run();
    public abstract void run2();

    public default void Method1(){}
    public default void Method3(){}
}

class D{
    public void Method2(){
        System.out.println("父类中的Method2方法");
    }

    public void M(){
        System.out.println("aaa");
    }

}
class C extends D implements A,B {
    //多个接口中有重名抽象函数，在其实现类中只需要重写一次
    public void run(){
        System.out.println("多个父接口中有重名抽象函数只需要重写一次");
    }
      @Override
      public void run2() {
          System.out.println("run2");
      }
      @Override
      public void run1() {
          System.out.println("run1");
      }

    //默认方法有重名的，必须重写一次，不然程序报错
    public void Method1(){
        System.out.println("必须重写一次多接口重名的默认方法，不然报错");
    }
  }


public class JKandFLei {
    public static void main(String[] args) {

        C c = new C();
        //就近原则 选着父类同名方法执行
        c.Method2();

        //向上转型
        D d=new C();
        d.M();

        //向下转型
        C c1=(C)d;
        c1.M();
    }
}

接口中的成员变量

定义格式： 修饰符 static final 数据类型 变量名 = 值 --->常量

注意：不写static final 也默认有，需要手动赋值，且不能二次赋值，一般变量名为大写（规范）

//接口
public interface InterfaceDemo {
    public static final int NUM = 10;
    int I = 20;
}

//测试
public class Test {
    public static void main(String[] args) {

        int i;
        //接口中的i的值是20，将他变为30
        //InterfaceDemo.i=30;//报错，static final修饰的成员变量不能进行二次赋值
        i = InterfaceDemo.I;
        System.out.println(i);
        System.out.println(InterfaceDemo.NUM);
    }
}

多态

定义：是指同一行为，具有多个不同表现形式

注意：

1、必须子父类继承关系（接口、实现类关系）

2、必须有方法的重写

3、父类引用指向子类对象

访问特点：只能调用重写的方法，不能调用子类特有的方法

多态的优点是其扩展性强，缺点是不能调用子类特有的方法

interface JieKou {
    public void method();

    public void method1();
}


class A implements JieKou {

    @Override
    public void method() {
        System.out.println("实现类A方法1");
    }

    @Override
    public void method1() {
        System.out.println("实现类A方法2");
    }
}


class B implements JieKou {

    @Override
    public void method() {
        System.out.println("实现类B方法1");
    }

    @Override
    public void method1() {
        System.out.println("实现类B方法2");
    }
}

public class Demo {
    public static void main(String[] args) {
        A a = new A();
        method(a);
        B b = new B();
        method(b);
    }

    public static void method(JieKou jieKou) {
        jieKou.method();
        jieKou.method1();
    }
}

class Animal {
    public void eat() {
        System.out.println("动物要吃饭");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
    public void drink(){
        System.out.println("狗喝水");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }
}

public class DuoTai {
    public static void main(String[] args) {
        //向上转型（默认）
        Animal animal = new Dog();
        animal.eat();
        animal.drink();//报错,不能调用子类特有的方法
        Animal animal1 = new Cat();
        animal1.eat();

        //向下转型  可以调用子类特有的方法
        Dog dog =(Dog) animal;
        dog.drink();

    }

    public void method(Animal animal) {
        animal.eat();
    }
}

instanceof关键字用法：

instanceof是Java的一个运算符,也是Java的保留关键字。它的作用是判断其左边对象是否为其右边类的实例，返回的是boolean类型的数据。用它来判断某个对象是否是某个Class类的实例。

用法：boolean result = object instanceof class

class Animal {
    public void eat() {
        System.out.println("动物要吃饭");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }

    public void drink() {
        System.out.println("狗喝水");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }

    public void drink() {
        System.out.println("猫喝奶");
    }
}

public class DuoTai {
    public static void main(String[] args) {

        Dog dog = new Dog();
        method(dog);

        Cat cat = new Cat();
        method(cat);

    }

    public static void method(Animal animal) {

        if (animal instanceof Dog) {
            animal.eat();
            Dog dog = (Dog) animal;
            dog.drink();
        }
        if (animal instanceof Cat) {
            animal.eat();
            Cat cat = (Cat) animal;
            cat.drink();
        }
    }
}