Java基础篇：三、接口与多态-CSDN博客

接口

接口： public interface demo{}
- 抽象方法： abstract void method();
- 默认方法： default void method(){};
- 静态方法： static void method(){};
- 私有方法： private void method(){};

概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。
接口的定义方式：使用 interface 关键字

public interface 接口名{ }

接口不能用来创建对象，但可以被实现（implements，类似继承）。实现(继承)接口的子类，必须实现接口中的所有抽象方法，创建该类对象就可以调用方法了，否则它必须是一个抽象类。

定义格式

public interface 接口名称 {
    // 接口里只能存在以下几种方法
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

注意： 接口内的方法如果没有修饰符，那么它默认为public abstract方法。

含有抽象方法

使用 abstract 修饰

public interface InterfaceTest{
    public abstract void changeSomething();
}

提示：接口下的抽象方法 public 和 abstract 都可以省略。

interface Demo{
    void method();
}

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。静态方法：使用 static 修饰，供接口直接调用。代码如下：

public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句
    }
}

含有私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。代码如下：

public interface InterfaceTest{
    private void method(){
    }
    private static void method1(){
    }
}

基本的实现(继承)

实现的概述

类与接口的关系为实现关系，即 类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。非抽象子类实现接口：

必须重写接口中所有抽象方法。
继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

class 子类名  implements 父类名{ }

抽象方法的使用：

抽象方法必须全部实现（重写）。

interface Human{
    abstract void eat();
    abstract void sing();
}
class Son implements Human{
    public void eat(){
        System.out.println("吃吃吃，吃死你");
    }
    public void sing(){
        System.out.println("鸡你太美。。。律师含警告");
    }
}

默认方法的使用

可继承，可重写。
继承无需写任何内容，自动继承

// 直接继承默认方法
public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}
public class Animal implements LiveAble {
// 继承，什么都不用写，直接调用
}
public class InterfaceDemo {
    public static void main(String[] args) {
// 创建子类对象
        Animal a = new Animal();
// 调用默认方法
        a.fly();
    }
}
//输出： 天上飞

// 重写默认方法
public class Animal implements LiveAble {
 public default void fly(){
       System.out.println("自由自在地飞");
    }
}
public class InterfaceDemo {
    public static void main(String[] args) {
// 创建子类对象
        Animal a = new Animal();
// 调用默认方法
        a.fly();
    }
}
// 输出： 自由自在地飞

静态方法的使用

接口的静态方法无法继承，因此在继承的实现类中也无法调用。
实现类中无法重写静态方法。
接口的静态方法可以直接调用，无需实例。例如：

public interface father{
    public static void rap(){
        System.out.println("我会RAP")
    }
}
public class InterfaceTest{
    public static void main(String[] args){
        father.rap();  // 输出： 我会RAP
    }
}

私有方法的使用

私有方法：只有默认方法可以调用。
私有静态方法：静态和默认方法可以调用。

接口的多实现

一个类只能继承一个父类，但是可以继承多个接口。
一个类继承一个父类的同时，也可以再继承多个接口。

写法 class 子类 extends 父类 implements 接口A,接口B{}

抽象方法： 如果多个接口有相同的抽象方法，重写时只需要重写一次。
默认方法： 如果有相同的默认方法，必须重写一次。
静态方法： 静态方法不冲突，因为静态方法只能通过各自接口进行访问。
优先级　： 如果继承的父类和接口有相同的方法，子类会就近执行父类。

接口的多继承

接口继承接口和类继承类相似，都是用 extends 。
父接口默认方法有重名的，子接口需要重写一次。
由于默认方法是供子接口/子类使用的
- 子接口重写默认方法时，default关键字可以保留。
- 子类重写默认方法时，default关键字不可以保留。

其他成员特点

接口中，无法定义成员变量，但是可以定义常量，其值不可改变，默认使用 public static final 修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

多态

多态指的是同一个行为，有多个不同的表现形式。比如一个相同的父类有一个打印方法，然后黑白打印机（子类A）执行打印时打印的是黑白的，但是彩色打印纸机（子类B）执行打印时打印的是彩色的。

前提【重点】

1. 继承或者实现【二选一】 2. 方法的重写【意义体现：不重写，无意义】 3. 父类引用指向子类对象【格式体现】

优点

1. 消除类型之间的耦合关系 2. 可替换性 3. 可扩充性 4. 接口性 5. 灵活性 6. 简化性

多态的体现

父类类型变量名 = new 子类对象; 变量名.方法名();

PS：父类类型：指子类对象继承的父类类型，或者实现的父接口类型。 代码：

Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

多态的运用实例

//  Animal 父类   cat、dog子类
public abstract class Animal {
    public abstract void eat();
}
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
}

//  测试类
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        AnimalsEat(dog);
        AnimalsEat(cat);
    }
    // 测试类方法
    public static void AnimalsEat(Animal animal){
        animal.eat();
    }
}

分析：由于Cat和Dog的父类为Animal，因此在定义AnimalsEat方法时直接将参数类型定义为 Animal，那么在调用eat()方法时，可以根据animal对象为Cat还是Dog来判定使用哪个类的eat方法。

引用类型转换

向上转型： 多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

父类类型变量名 = new 子类类型(); 如：Animal a = new Cat();

向下转型： 父类类型向子类类型向下转换的过程，这个过程是强制的。

子类类型变量名 = (子类类型) 父类变量名; 如:Cat c =(Cat) a;

小试牛刀

//进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
//        USB接口，包含开启功能、关闭功能
//        笔记本类，包含运行功能、关机功能、使用USB设备功能
//        鼠标类，要实现USB接口，并具备点击的方法
//        键盘类，要实现USB接口，具备敲击的方法
//        注意：笔记本类在实现USB设备功能时，由于部分USB设备功能是usb设备特有的，因此需要
public class Computer {
    public static void main(String[] args) {
//        向上转型
        usb u1 = new mouse();
        usb u2 = new keyboard();
//        跑起来了
        Run();
        usbFunctions(u1);
        usbFunctions(u2);
        shutdown();
    }

    public static void Run(){
        System.out.println("睡你**起来嗨");
    }
    public static void shutdown(){
        System.out.println("嗨你**滚去睡");
    }
    public static void usbFunctions(usb x){
        x.open();
        x.close();

//        判断x对象属于哪种数据类型
        if(x instanceof mouse){
//            向下转型
            ((mouse) x).click();

        }else if(x instanceof keyboard){
//            向下转型
            ((keyboard) x).click();
        }
    }

}
interface usb {
    abstract void open();
    abstract void close();
}
class mouse implements usb{
    public void open(){
        System.out.println("有的人还活着。");
    }
    public void close(){
        System.out.println("实际上他已经死了。");
    }
    public void click(){
        System.out.println("屠龙宝刀，点击就送。");
    }
}
class keyboard implements usb{
    public void open(){
        System.out.println("有的人还活着。");
    }
    public void close(){
        System.out.println("实际上他已经死了。");
    }
    public void click(){
        System.out.println("是兄弟就来砍我");
    }
}

转载于:https://my.oschina.net/chendejie/blog/3098129