语法——抽象类、接口

一、抽象类

1、抽象类

• 在Java中abstract是抽象的意思，可以修饰类、成员方法。
• abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

注意事项：

-- 抽象方法只有方法签名，不能声明方法体。
-- 一个类中如果定义了抽象方法，这个类必须声明为抽象类，否则报错。

2、抽象的使用场景

• 抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。
• 当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明为抽象类。

例如：定义一个Animal 父类 为抽象类，让子类Dog继承

/**
 * 抽象类：abstract 修饰
 */
public abstract class Animal {
    private String name;

    /**
     * 抽象方法：abstract 修饰，不能写方法体代码
     */
    public abstract void run();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {
    @Override
    public void run() {
        System.out.println(getName()+"跑的真快");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.setName("大黄");
        d.run();
    }
}

3、继承抽象类要注意：

• 一个类如果继承了抽象类，那么这个类必须重写完抽象类的所有抽象方法，否则这个类也必须定义为抽象类。

2、抽象类的使用案例

先定义父类：

public abstract class Card {
    private String userName;
    private double money;
    /**
     定义一个支付方法，表示卡片可以支付
     抽象方法
     */
    public abstract void pay(double money);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

再定义GoldCard继承父类

public class GoldCard extends Card{

    @Override
    public void pay(double money2) {
        System.out.println("您当前消费：" + money2);
        System.out.println("您卡片的余额为：" + getMoney());
        //优惠价
        double rs = money2 * 0.8;
        System.out.println(getUserName() + "：您实际支付" + rs);
        //更新余额
        setMoney(getMoney() - rs);

    }
}

定义SilverCard继承父类

public class SilverCard extends Card{
    @Override
    public void pay(double money3) {
        System.out.println("您当前消费：" + money3);
        System.out.println("您卡片的余额为：" + getMoney());
        //优惠价
        double rs = money3 * 0.85;
        System.out.println(getUserName() + "您实际支付" + rs);
        //更新余额
        setMoney(getMoney() - rs);
    }
}

main方法

public class Test {
    public static void main(String[] args) {
        GoldCard g = new GoldCard();
        SilverCard s = new SilverCard();
        g.setUserName("李磊");
        g.setMoney(1000);
        g.pay(500);
        System.out.println("金卡余额为：" + g.getMoney());
        System.out.println("-------------------------");
        s.setUserName("黄涛");
        s.setMoney(1000);
        s.pay(500);
        System.out.println("银卡余额为：" + s.getMoney());

    }
}

3、抽象类的特征、注意事项（面试、笔记）

• 类的成员（成员方法、成员变量、构造器）抽象类都具备。
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
• 一个类继承了抽象类，那么这个类必须重写完抽象类的所有抽象方法，否则这个类也必须定义为抽象类。
• 不能用abstract修饰变量、代码块、构造器。
  ** 最重要的特征：抽象方法不能创建对象（有得有失）。

* final 和 abstract的关系：

• 互斥关系（两个不能同时出现）。
• abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。
• 抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

4、抽象类的应用知识：模板方法模式

（1）模板方式解决了什么问题？

• 提高了代码的复用性
• 模板方法已经定义了通用结构，模板方法不能确定的部分定义成抽象方法，交给子类实现。因此，使用者只需要关心自己需要实现的功能即可。

（2）

（3）案例

代码截图：

* 模板方法建议使用final修饰，这样会更专业，为什么？

模板方法是给子类直接使用的，不是让子类重写的。一旦重写了模板方法，则模板方法就失效了。因此，加上final后可以防止子类重写模板方法，这样更安全、专业。

二、接口

1、接口概述、特点

（1）接口格式如下：

（2）JDK8之前接口中只能是抽象方法和常量，没有其他成分了。

（3）什么是接口？

• 接口也是一种规范。
• 声明了一个接口：体现了一种规范，规范一定是公开的。

注意：

• 由于接口体现规范思想，规范默认都是公开的，所以代码层面，public static final 可以省略不写。

代码：

点击查看代码

/**
 * 声明了一个接口
 */
public interface InterfaceDemo {
    //JDK8之前接口中只能是抽象方法和常量，没有其他成分了
    // 常量
    String USER_NAME = "luckylily";
//public static final String USER_NAME = "luckylily";
    
    //注意：由于接口体现规范思想，规范默认都是公开的，
    // 所以代码层面，public static final 可以省略不写。
    //抽象方法
    void run();
    // public abstract void run();

    void eat();
    // public abstract void eat();
}

2、接口的基本使用：被实现

（1）接口的用法：

• 接口是用来被类实现的（implements），实现接口的类称为实现类。实现类可以理解为所谓的子类。

• 格式
  

• 从上面可以看出，接口可以被类单实现，也可以被类多实现。

（2）接口实现的注意事项：

一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义为抽象类。

3、接口与接口的关系：多继承

（1）基本小结

• 类和类的关系：单继承
• 类和接口的关系：多实现
• 接口和接口的关系：多继承，一个接口可以同时继承多个接口。

（2）接口多继承的作用

• 规范合并，整合多个接口为同一个接口，便于子类实现。

4、JDK8开始接口新增方法

• JDK8以后，Java只对接口的成员方法进行了新增
• 

点击查看代码

public interface SportMan {
    /**
    1、 jdk 8开始：默认方法(实例方法)
     必须用default修饰，默认是public
     由实现类的对象调用
     */
    default void run(){
        System.out.println("跑步");
        go();
    }

    /**
     2、静态方法
     必须使用static修饰,默认是public
     必须用接口名调用
     */
    static void inAddr(){
        System.out.println("静态方法");
    }

    /**
     3、私有方法(实例方法)
     jdk 1.9 才支持
     必须在接口内部才能访问
     */
    private void go(){
        System.out.println("私有方法");
    }
}



class PingPongMan implements SportMan{

}

class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run(); //实现类的对象调用

        SportMan.inAddr(); //必须用接口名调用

    }
}

5、使用接口的注意事项

•