Day 6 2021.3.7发红包案例-接口总结与补充-笔记本接口案例

Day 6:2021.3.6

继承的综合案例:群主发红包

群主发普通红包,某群有多名成员,群主给成员发普通红包,规则:

  1. 群主的一笔金额,从群主余额中扣除,平均分成n等分(随机分成n份),让成员领取。

  2. 成员领取红包后,保存到成员余额中。

主程序:

package com.hong.Day005.FaHongBao;

import java.util.ArrayList;
import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        QunZhu qunZhu = new QunZhu("群主",1000.0);
        ChenYuan chenYuanA = new ChenYuan("A",0.0);
        ChenYuan chenYuanB = new ChenYuan("B",0.0);
        ChenYuan chenYuanC = new ChenYuan("C",0.0);
        System.out.println("群主发红包的金额和数目");
        qunZhu.shouName();
        chenYuanA.shouName();
        chenYuanB.shouName();
        chenYuanC.shouName();
        System.out.println("===================");
        double a = scanner.nextDouble();
        int b = scanner.nextInt();
        ArrayList<Double> redList = qunZhu.send(a,b);
        chenYuanA.receive(redList);
        chenYuanB.receive(redList);
        chenYuanC.receive(redList);
        qunZhu.shouName();
        chenYuanA.shouName();
        chenYuanB.shouName();
        chenYuanC.shouName();
        scanner.close();
    }
}

父类:存储name,余额等数据;show方法

package com.hong.Day005.FaHongBao;
/*
父类
方法:shouName
getName;setName;
getMoney;setMoney;
 */
public class User {
    private String name;
    private Double money;

    public User() {
    }

    public User(String name, Double money) {
        this.name = name;
        this.money = money;
    }

    public void shouName(){
        System.out.println("我叫" + name + ",余额:" + money);
    }

    public String getName() {
        return name;
    }

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

    public Double getMoney() {
        return money;
    }

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

子类:

package com.hong.Day005.FaHongBao;

import java.util.ArrayList;
import java.util.Random;

/*
群主
 */
public class QunZhu extends User{
    public QunZhu() {
    }

    public QunZhu(String name, Double money) {
        super(name, money);
    }

    public ArrayList<Double> send(double totalMoney,int count){
        //用一个集合来存储若干个红包的金额
        ArrayList<Double> redList = new ArrayList<>();
        //判断群主有多少钱
        double leftMoney = super.getMoney();
        if (leftMoney > totalMoney){
            System.out.println("你的钱包里没钱了");
            return redList;//返回一个空集合
        }
        //扣钱,重新设置余额
        super.setMoney(leftMoney-totalMoney);
        Random random = new Random();
        //发红包,拆分成count份(伪随机)
        double[] a = new double[count];
        double[] avg = new double[count];
        double sum = 0.0;
        for (int i = 0; i < count; i++) {
            double b = random.nextDouble();
            sum += b;
            a[i] = b;
        }
        for (int i = 0; i < count; i++) {
            avg[i] = a[i]/sum*totalMoney;
            redList.add(avg[i]);
        }
        System.out.println(redList);
        return redList;
    }
}
package com.hong.Day005.FaHongBao;

import java.util.ArrayList;
import java.util.Random;

public class ChenYuan extends User{
    public ChenYuan() {
    }

    public ChenYuan(String name, Double money) {
        super(name, money);
    }

    public ArrayList receive(ArrayList<Double> list){
        //从红包当中抽取一个给我自己
        int index = new Random().nextInt(list.size());
        double delta = list.get(index);
        list.remove(index);
        double money = super.getMoney();
        super.setMoney(money + delta);
        return list;
    }
}

接口总结与补充

普通类:只有具体的实现

抽象类:只有具体实现和规范(抽象方法)都有

接口:只有规范

声明接口的关键字是:interface

接口的作用:

  1. 约束

  2. 定义一些方法,让不同的人实现

  3. public abstract //方法修饰
    
  4. public static final //静态常量
    
  5. 接口不能被实例化,接口中没有构造方法,也没有静态代码块

  6. 可以实现多可:implements

  7. 实现接口必须要重写接口中的方法

  8. 不能直接new接口,只能调用接口的实现类

  9. 实现类中需要对多个接口中重复的默认方法进行重写,抽象方法只需重写一次

  10. 继承优先于接口(方法名相同时)

  11. 多个父接口当中的默认方法如果重复,那么子接口必须进行默认方法的覆盖重写

  12. multi :(多态命名)

实现类:

package com.hong.Day004.Demo11;
//类可以实现接口: implements
//实现了接口的类,必须要实现接口中的方法
//侧面实现了多继承
public class UserImpl implements User , Time {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

User:

package com.hong.Day004.Demo11;

//定义的关键字:interface,接口都要有实现类
public interface User {
    //属性默认常理
    int AGE = 99;
    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

Time:

package com.hong.Day004.Demo11;
public interface Time {
    void timer();
}

接口的默认方法(default)

package com.hong.Day006.Demo01;
/*
java 8开始,接口里允许定义默认方法。
格式:
public default 返回值类型 方法名称(参数列表){方法体}
备注:接口当中的默认方法,可以解决接口升级的问题
1.接口的默认方法,可以通过接口实现类对象,直接调用
2.接口的默认方法,也可以被接口实现类进行覆盖重写
 */
public interface Demo02 {
    //抽象方法
    void method();

    //新建一个默认方法
//    void method2();   //实现类会报错
    //新添加的默认方法
    public default void method3(){
        System.out.println("这是新添加的默认方法");
    }
}

接口的静态方法

接口:

package com.hong.Day006.Demo02;
/*
从java 8 开始,接口当中允许定义静态方法
格式:
public static 返回值类型 方法名称(参数列表){方法体}
提示:就是将abstract或者default换成static即可,带上方法体。
 */
public interface Demo01 {
    public static void method(){
        System.out.println("这是静态方法");
    }
}

主程序:

package com.hong.Day006.Demo02;
/*
注意:不能通过接口实现类的对象来调用接口当中的静态方法
正确用法,通过接口名称,直接调用静态方法
格式:
接口名称.静态方法名称(参数)
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建了实现类对象
        //Demo02 demo02 = new Demo02();没必要
        //错误写法
        //Demo02.method();
        Demo01.method();
    }
}

接口的私有方法

package com.hong.Day006.Demo03;
/*
问题描述:我们需要抽取一个方法,用来解决两个默认方法之间重复代码的问题
但是这个共有方法不应该让实现类使用,应该是私有化的。
解决方案:
从java 9开始,接口当中允许定义私有方法
1.普通私有方法,解决多个默认方法之间重复代码问题
格式:
private 返回值类型 方法名称(参数列表){方法体}
2.静态私有方法,解决多个静态方法之间重复代码问题
private static 返回值类型 方法名称(参数列表){方法体}
 */
public interface Demo01 {
    public default void method1(){
        System.out.println("默认方法1");
        common();
    }
    public default void method2(){
        System.out.println("默认方法2");
        common();
    }
    private void common(){
        
    }
}

接口的常量定义与使用

接口:

package com.hong.Day006.Demo04;
/*
接口当中也可以定义"成员变量",但是必须使用public static final三个关键字进行修饰
从效果上看,这其实就是接口的[常量]
格式:
public static final 数据类型 常量名称 = 数据值;
备注:
一旦使用final关键字进行修饰,说明不可改变
注意事项:
1.接口当中的常量,可以省略public static final,不写效果也是一样
2.接口当中的常量,必须进行复制
 */
public interface Demo01 {
    public static final int NUM = 10;
}

引用:

package com.hong.Day006.Demo04;

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(Demo01.NUM);
    }
}

接口多态综合案例:笔记本接口案例

笔记本电脑(laptop)通常使用USB设备的功能,在生产时,笔记本都预备了可以插入USB设备的USB接口,但具体是什么USB设备,笔记本厂商并不关心,只要符合USB规格的设备都可以。

定义USB接口,具备最基本的凯奇功能和关闭功能,鼠标和键盘要想能再电脑上使用,那么鼠标和键盘也必须遵守USB规范,实现USB接口,否则鼠标和键盘的生产出来也无法使用。

案例分析:

进行描述笔记本类,实现笔记本使用USB鼠标、USB键盘

  • USB接口,包含打开设备功能,关闭设备功能

  • 笔记本类,包含打开设备功能、关闭设备功能

  • 鼠标类,要实现USB接口,并具备点击的方法

  • 键盘类,要实现USB接口,具备敲击的方法

案例实现:

Usb接口:

package com.hong.Day006.Demo06;
/*
USB接口
 */
public interface Usb {
    public abstract void open();//打开设备
    public abstract void close();//关闭设备
}

键盘KeyBoard:

package com.hong.Day006.Demo06;

public class KeyBoard implements Usb{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }

    public void type(){
        System.out.println("键盘输入");
    }
}

鼠标Mouse:

package com.hong.Day006.Demo06;

public class Mouse implements Usb{
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("鼠标点击");
    }
}

笔记本:

package com.hong.Day006.Demo06;

public class NoteBook {
    public void poweron(){
        System.out.println("电脑开机");
    }
    public void poweroff(){
        System.out.println("电脑关机");
    }

    //使用Usb设备的方法,使用接口作为方法的参数
    public void useDevice(Usb usb){
        usb.open();//打开设备
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;//向下转型
            mouse.click();
        }else if (usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard) usb;//向下转型
            keyBoard.type();
        }
        usb.close();//关闭设备
    }
}

控制程序:

package com.hong.Day006.Demo06;

public class User {
    public static void main(String[] args) {
        //创建一个笔记本类
        NoteBook noteBook = new NoteBook();
        noteBook.poweron();
        //准备一个鼠标,供电脑使用
        Mouse mouse = new Mouse();
        //首先进行向上转型
        Usb usbMouse = mouse;//Usb usbMouse = new Mouse();多态写法
        noteBook.useDevice(usbMouse);
        //准备一个键盘,供电脑使用
        KeyBoard keyBoard = new KeyBoard();
        //方法参数是Usb类型,传递进去的是实现类
        noteBook.useDevice(keyBoard);//没有使用多态
        noteBook.poweroff();
    }
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 1024 设计师:白松林 返回首页