【Java 接口】

final

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 18:11:06
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test08 {
    public static void main(String[] args) {
        //第一种情况
        //final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
        final int BIRTH_YEAR = 1997;
        //BIRTH_YEAR = 1998;报错，不能修改值

        //第二种情况
        //final 修饰引用类型，地址值不能改变
        final String string = new String("123");
        //string = new String("456");报错，地址值不可以更改

        //第三种情况
        a(string);

        //第四种情况
        b(string);
    }
    public static void a(String s) {
        s = new String("123");
    }

    public static void b(final String s) {
        //s = new String("123");报错，地址值不可以改变
    }
}

class Fruit {
    final public void play() {
        System.out.println("水果");
    }
}

class Banana extends Fruit {
    //第五种情况
    //final修饰方法，那么这个方法不可以被该类的子类重写
    //final public void play() {};
}

final class Tool {

}
//第六种情况
//final修饰类，代表该类没有子类，不可以被继承
//class Knife extends Tool {} 

abstract

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 18:36:31
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
//一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类
//一个抽象类中可以有0-n个抽象方法
public abstract class Person7 {
    //在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
    public void say() {
        System.out.println("我对说话很满意！");
    }
    //在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写
    //一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
    public abstract void eat();
    public abstract void sleep();
}
//一个类继承一个抽象类，那么这个类可以变成抽象类
//一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
//子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类
class Boy extends Person7 {
    @Override
    public void eat() {
        System.out.println("小男孩吃东西");
    }

    @Override
    public void sleep() {
        System.out.println("小男孩睡觉");
    }
}

class Demo {
    public static void main(String[] args) {
        //抽象类不可以创建对象
        //Person7 p7 = new Person7();

        //创建子类对象
        Boy boy = new Boy();
        boy.say();//我对说话很满意！
        boy.sleep();//小男孩睡觉
        boy.eat();//小男孩吃东西

        //多态写法
        Person7 p7 = new Boy();//父类的引用指向子类的对象，向上转型
        p7.say();//我对说话很满意！
        p7.eat();//小男孩吃东西
        p7.sleep();//小男孩睡觉
    }
}

• 抽象类中一定有构造器，构造器的作用是给子类初始化对象的时候要先super调用父类的构造器
• 抽象类不能被final修饰，因为抽象类设计的初衷就是给子类继承用的，要是被final修饰了这个抽象类了，就不存在继承了，就没有子类

interface

package com.yuzhenc.oop;

/**
 * @author: yuzhenc
 * @date: 2022-02-26 21:12:53
 * @desc: com.yuzhenc.oop
 * @version: 1.0
 */
public class Test09 {
    public static void main(String[] args) {
        //创建了一个美团
        MeiTuan mt = new MeiTuan(0,"WeiXin");
        //开始点菜
        mt.setFood(new String[]{"炸鸡","可乐"});
        //设置支付宝结账
        mt.setPayMethod("ZhiFuBao");
        //订单结算
        mt.settleMoney();
    }
}

//外卖类
class WaiMai {
    //菜品
    String[] food;
    //上架菜品
    public void setFood(String[] food) {
        this.food = food;
    }
    //展示菜品
    public String[] getFood() {
        return food;
    }

    //生成订单
    public double createOrder(String[] food) {
        //计算订单多少钱
        return Math.round(Math.random()*100);
    }
}
//微信支付接口
interface WeiXin {
    /*
        1.类是类，接口是接口，它们是同一层次的概念
        2.接口中没有构造器
        3.接口如何声明：interface
        4.在JDK1.8之前，接口中只有两部分内容：
            常量：固定修饰符：public static final （可以省略不写）
            抽象方法：固定修饰符：public abstract （可以省略不写）
    */
    /*public static final */String name = "微信支付";
    /*
        5.在JDK1.8之后，新增非抽象方法，静态方法：
            （1）被public default修饰的非抽象方法，default修饰符必须要加上，否则出错
            （2）当多个接口中有同一个用default修饰的方法时，就无法判断到底实现的是哪个接口的方法，这种情况下，就必须重写方法
            （3）一个类继承的父类和实现的接口中都有同一个方法，而这个类又没有重写时，实现的是父类的方法，而不是接口中的方法
            （4）静态方法，不能重写
    */
    //支付方法
    /*public */default void wPay(double money) {
        System.out.println("正在使用微信支付，支付金额为"+money+"元！");
    };
    //接口中的静态方法
    public static void getPayMethod(){
        System.out.println(name);
    }
}

//支付宝支付接口
interface ZhiFuBao {
    /*public static final */String name = "支付宝支付";
    //支付方法
    /*public */default void zPay(double money) {
        System.out.println("正在使用支付宝支付，支付金额为"+money+"元！");
    };
}

/*
    6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法
    7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类
    8.java只有单继承，java还有多实现
*/

//美团类
class MeiTuan extends WaiMai implements WeiXin,ZhiFuBao{
    //美团在外卖的基础上，增加了优惠券
    private double youHuiQuan = 0;
    //支付方式，默认为微信支付
    private String payMethod = "WeiXin";
    public MeiTuan() {}

    public MeiTuan(double youHuiQuan, String payMethod) {
        this.youHuiQuan = youHuiQuan;
        this.payMethod = payMethod;
    }

    public double getYouHuiQuan() {
        return youHuiQuan;
    }

    public void setYouHuiQuan(double youHuiQuan) {
        this.youHuiQuan = youHuiQuan;
    }

    public String getPayMethod() {
        return payMethod;
    }

    public void setPayMethod(String payMethod) {
        this.payMethod = payMethod;
    }

    //重写微信支付方法
    @Override
    public void wPay(double money) {
        wPay(money);//可以这么调用接口的默认方法
        //super.wPay(money);不能这么调用
        WeiXin.super.wPay(money);//也可以这么调用接口的默认方法
    }

    //我不满意支付宝的默认实现，我来重写他的支付方法
    @Override
    public void zPay(double money) {
        System.out.println("使用支付宝成功支付："+money+"元");
    }

    //美团有自己的结算方式，即订单生成返回的钱减去优惠券的金额就是支付金额
    public void settleMoney() {
        if ("WeiXin".equals(this.getPayMethod())) {
            this.wPay(super.createOrder(super.food)-this.getYouHuiQuan());
        } else if ("ZhiFuBao".equals(this.getPayMethod())) {
            this.zPay(super.createOrder(super.food)-this.getYouHuiQuan());
        } else {
            System.out.println("支付失败！");
        }
    }
}

• 抽象类
  • 抽象类使用abstract修饰
  • 抽象类不能实例化
  • 有抽象方法的类一定是抽象类，必须用abstract修饰
  • 抽象类不一定要有抽象方法
  • 如果一个子类实现了父类（抽象类）的所有抽象方法，该类可以是抽象类，也可以不是抽象类
  • 抽象类中的抽象方法只有方法声明，没有方法实现
• 接口
  • 接口使用interface修饰
  • 接口不能实例化
  • 一个类只能继承一个类，可以实现多个接口
• 多态的应用场合
  （1）父类当做方法的形参，传入具体的子类的对象
  （2）父类当做方法的返回值，返回的是具体的子类的对象
  （3）接口当做方法的形参，传入具体的实现类的对象
  （4）接口当做方法的返回值，返回的是具体的实现类的对象