发红包案例_普通红包平均分发与发红包案例_手气红包随机分发

发红包案例_普通红包平均分发

首先得有最基本的姓名和余额两个属性，这里面有两个角色，打个比方就只能群主能发红包，还有就是群成员收红包。这里面的两个角色一个是群主发红包，还有一个就是收红包的群成员角色。不管是群主还是群成员都有共同的属性。就是姓名和余额，所以在这里可以定义一个父类，父类里面定义两个私有的属性，群主类就只需要编写发红包的方法和一个两参构造方法即可，还有群成员类也只需要写一个两参构造方法和自己的领红包方法即可。

 

 

 

package demox.demo01.hongbao;

// 用户类
public class User {
    private String name;
    private int money;

    public User() {
    }

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

    // 显示当前用户余额
    public void show() {
        System.out.println(name + "当前的余额：" + money);
    }

    public String getName() {
        return name;
    }

    public int getMoney() {
        return money;
    }

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

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

 

package demox.demo01.hongbao;

import java.util.ArrayList;
import java.util.Random;
// 群成员类
public class Menber extends User {
    public Menber() {
    }

    public Menber(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list) {
        // 抽取红包并将其从集合中删除
        int index = new Random().nextInt(list.size());
        int delta = list.remove(index);
        // 将抽取到的红包加入余额
        int money = super.getMoney();
        super.setMoney(money + delta);
    }
}

package demox.demo01.hongbao;

import java.util.ArrayList;
// 群主类
public class Manager extends User {
    public Manager() {
    }

    public Manager(String name, int money) {
        // 调用父类构造方法
        super(name, money);
    }

    public ArrayList<Integer> send(int totalMoney, int count) {
        ArrayList<Integer> redEnvelope = new ArrayList<>();
        // 安全检查：群主剩下的钱够不够发红包？
        int leftMoney = super.getMoney();
        if (totalMoney > leftMoney) {
            System.out.println("余额不足");
            return redEnvelope; // 此时返回了空集合
        }
        // 余额够的情况下，扣钱即重设群主剩下的钱
        super.setMoney(leftMoney - totalMoney);
        // 拆分红包
        int avg = totalMoney / count;
        int mod = totalMoney % count;
        //零头都放在最后一个红包里
        for (int i = 0; i < count - 1; i++) {
            redEnvelope.add(avg);
        }
        int last = avg + mod;
        redEnvelope.add(last);
        return redEnvelope;
    }
}

package demox.demo01.hongbao;

import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        Manager manager=new Manager("群主",500);
        Menber member1=new Menber("成员1",0);
        Menber member2=new Menber("成员2",0);
        Menber member3=new Menber("成员3",0);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
        System.out.println("=======================");
        
        ArrayList<Integer> redList1=manager.send(10,3);
        member1.receive(redList1);
        member2.receive(redList1);
        member3.receive(redList1);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
        System.out.println("=======================");
        
        ArrayList<Integer> redList2=manager.send(1000000,3);
    }
}

2.

package demox.demo01.hongbaopro;

public class Person {
    private String name;
    private double balance;
    
    public Person() {
    }

    public Person(String name, double balance) {
        this.name = name;
        this.balance = balance;
    }

    public String getName() {
        return name;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

package demox.demo01.hongbaopro;

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

public class Owner extends Person {

    public Owner() {
    }

    public Owner(String name, double balance) {
        super(name, balance);
    }

    /**
     * 发普通红包
     *
     * @param al    红包队列
     * @param num   人数
     * @param money 每个多少钱
     * @return al 红包队列
     */
    public ArrayList<Double> money(ArrayList<Double> al, int num, double money) {
        // 群主发普通红包
        double totalMoney = num * money;
        if (totalMoney > getBalance()) {
            System.out.println("余额不足,囊中羞涩");
            return null;
        } else {
            // 将红包装入红包队列中
            for (int i = 0; i < num; i++) {
                al.add(money);
            }
            System.out.println("红包容器");
            for (Double aDouble : al) {
                System.out.print(aDouble + " ");
            }
            setBalance(getBalance() - totalMoney);
            System.out.println("群主的余额还剩: " + this.getBalance());
            return al;
        }
    }

    /**
     * @param al    红包容器队列
     * @param num   人数
     * @param money 总钱数
     * @return al 容器
     */
    public ArrayList<Integer> money2(ArrayList<Integer> al, int num, double money) {
        // 群主发手气红包
        if (money > getBalance()) {
            System.out.println("余额不足,囊中羞涩");
            return null;
        } else {
            // 将钱随机装入红包队列中
            // 第一个红包是100 的随机数 [1,100)
            int v1 = (int)(Math.random() * (money-1))+1;
            al.add(v1);

            // 经过第一个随机后,还剩v2
            int v2 = (int) money - v1;
            // 第二个红包是 前面余额的随机数

            int v3 = (int)(Math.random() * (v2-1))+1;
            al.add(v3);
            int v4 = v2 - v3;

            al.add(v4);

            // 打印红包容器
            System.out.println("红包容器");
            for (Integer integer : al) {
                System.out.print(integer + " ");
            }
            // 群主的余额减去此处发的红包
            setBalance(getBalance() - money);
            System.out.println("群主的余额还剩: " + this.getBalance());
            FindMax(al);
            return al;
        }
    }

    // 比较最大值
    public void FindMax(ArrayList<Integer> al) {
        int max = 0;
        int index = 0;
        for (int i = 0; i < al.size(); i++) {
            if (max < al.get(i)) {
                max = al.get(i);
                index = i;
            }
        }
        System.out.println("红包最大值是: " + max);
        System.out.println("第" + (index + 1) + "个人的手气最佳");
    }
 }

package demox.demo01.hongbaopro;

import java.util.ArrayList;
import java.util.Iterator;

public class member extends Person {

    public member(String name, double balance) {
        super(name, balance);
    }

    public void money(ArrayList<Double> al) {
        // 用迭代器从容器队列中取元素,如果没有元素就不能取
        // 创建一个迭代器对象
        Iterator<Double> iterator = al.iterator();
        // 如果容器队列中有元素,则 hasNext() 为 true
        //while (iterator.hasNext()) {
            // 容器中存储的是 Double 包装类数据,直接转换为 double 基本数据类型
            Double temp = iterator.next();
            // 取过值后,移除该元素
            iterator.remove();
            System.out.println("从红包中收到 " + temp + " 元钱");

            // 包装类自动拆箱
            setBalance(this.getBalance() + temp);
            System.out.println("成员姓名:" + getName() + " 余额: " + getBalance());
       // }
    }

    public void money2(ArrayList<Integer> al) {
        Iterator<Integer> iterator = al.iterator();
        while (iterator.hasNext()) {
            double temp = iterator.next();
            iterator.remove();
            System.out.println("从红包中收到 " + temp + " 元钱");
            setBalance(this.getBalance() + temp);
            System.out.println("成员姓名:" + getName() + " 余额: " + getBalance());
        }
    }
}

package demox.demo01.hongbaopro;

import java.util.ArrayList;

/**
 *  综合 案例 : 群主发普通红包
 *  群内有1个群主,多名成员 ,发普通红包均分
 *  1.群主的一笔金额,从群主的余额总扣除,平均分成 N 等份,让成员领取
 *  2.成员领取红包后,保存在成员余额中
 *
 *
 *  拓展拼手气红包
 *  1,输出手气最佳的成员
 *  2.输出最后每位成员的余额
 */
public class mainProgram {

    public static void main(String[] args) {

        // 创建一个红包队列,保存群主发的红包钱,每个元素,就是一个红包
        ArrayList<Double> al = new ArrayList<>();

        // 创建一个红包队列,保存群主发的红包钱,每个元素,就是一个红包
        ArrayList<Integer> al2 = new ArrayList<>();

        // 群主属性有姓名和余额
        Owner owner = new Owner("群主", 1000);

        member m1 = new member("成员1",0);
        member m2 = new member("成员2",0);
        member m3 = new member("成员3",0);


        System.out.println("发普通红包");
        // 总共发3个,每个100 块钱,总共300块钱
        // 此处是为了避免除不尽的情况
        owner.money(al,3,100);
        // 成员从队列中取红包,每取一个,容器元素减一
        m1.money(al);
        m2.money(al);
        m3.money(al);


        System.out.println("随机红包");
        // 发三个红包,总共100块钱,每个人分到的都是整数
        owner.money2(al2,3,100);
        m1.money2(al2);
        m2.money2(al2);
        m3.money2(al2);

    }

}

3.

package demox.demo01.hongbaomax;

//父类
public class Uesr {
    private String name;
    private int balance;//余额
    public Uesr(){
    }
    public Uesr(String name,int balaance){
        this.balance=balaance;
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getBalance() {
        return balance;
    }
    public void setBalance(int balance) {
        this.balance = balance;
    }
    public void show(){
        System.out.println("姓名："+this.getName()+", 余额："+this.getBalance());
    }
}

package demox.demo01.hongbaomax;

import java.util.ArrayList;

public class Manager extends Uesr {
    public Manager(){
        
    }
    public Manager(String name,int balance){
        super(name,balance);
    }
    
    public ArrayList<Integer> red(int tatol, int count){
        ArrayList<Integer> list=new ArrayList<Integer>();
        if(super.getBalance()<tatol){
            System.out.println("余额不足！！");
            return list;
        }
        int average=tatol/count;//平均
        int remainder=tatol%count;//余数
        for(int i=0;i<count-1;i++){
            list.add(average);
        }
        list.add(remainder+average);
        super.setBalance(super.getBalance()-tatol);
        return list;
    }
}

package demox.demo01.hongbaomax;

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

public class Member extends Uesr{
    
    public Member(){
        
    }
    public Member(String name,int balance){
        super(name,balance);
    }
    
    public void getRed(ArrayList<Integer> list){
        
        int index=new Random().nextInt(list.size());
        int remove=list.remove(index);
        int mony=super.getBalance();
        super.setBalance(mony+remove);
        
    }
}

package demox.demo01.hongbaomax;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        Manager manager=new Manager("群主", 100);
        manager.show();
        System.out.println("=================");
        ArrayList<Integer> list=manager.red(50, 3);
        Member one=new Member("用户1",0);
        Member two=new Member("用户2",0);
        Member thrre=new Member("用户3",0);
        one.getRed(list);
        two.getRed(list);
        thrre.getRed(list);
        System.out.println("=================");
        one.show();
        two.show();
        thrre.show();
        System.out.println("=================");
        manager.show();
    }

}

 

发红包案例_手气红包随机分发

群主发普通红包。某群有多名成员，发红包规则如下：

1. 群主的发红包金额从群主余额中扣除，平均分成n等份，供成员领取。
2. 成员领取红包后保存到成员余额中。

 

 

 

发红包三要素

返回值：ArrayList< Double >

方法名称：send

参数列表：发多少：double totalMoney

分多少个：double count

 

收红包三要素

返回值：void

方法名：recieve

参数列表：ArrayList< Double > list

完成第二部分的分析，我们进行案例实现，首先我们需要定义一个用户类（父类），其中包含群主和成员都需要拥有的用户名以及用户余额。然后我们需要定义群主子类和成员子类，实现各自不同的功能，群主类发放红包，成员类接收红包。

package demox.demo01.hongbaopro;

public class Person {
    private String name;
    private double balance;
    
    public Person() {
    }

    public Person(String name, double balance) {
        this.name = name;
        this.balance = balance;
    }

    public String getName() {
        return name;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

package demox.demo01.hongbaopro;

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

public class Owner extends Person {

    public Owner() {
    }

    public Owner(String name, double balance) {
        super(name, balance);
    }

    /**
     * 发普通红包
     *
     * @param al    红包队列
     * @param num   人数
     * @param money 每个多少钱
     * @return al 红包队列
     */
    public ArrayList<Double> money(ArrayList<Double> al, int num, double money) {
        // 群主发普通红包
        double totalMoney = num * money;
        if (totalMoney > getBalance()) {
            System.out.println("余额不足,囊中羞涩");
            return null;
        } else {
            // 将红包装入红包队列中
            for (int i = 0; i < num; i++) {
                al.add(money);
            }
            System.out.println("红包容器");
            for (Double aDouble : al) {
                System.out.print(aDouble + " ");
            }
            setBalance(getBalance() - totalMoney);
            System.out.println("群主的余额还剩: " + this.getBalance());
            return al;
        }
    }

    /**
     * @param al    红包容器队列
     * @param num   人数
     * @param money 总钱数
     * @return al 容器
     */
    public ArrayList<Integer> money2(ArrayList<Integer> al, int num, double money) {
        // 群主发手气红包
        if (money > getBalance()) {
            System.out.println("余额不足,囊中羞涩");
            return null;
        } else {
            // 将钱随机装入红包队列中
            // 第一个红包是100 的随机数 [1,100)
            int v1 = (int)(Math.random() * (money-1))+1;
            al.add(v1);

            // 经过第一个随机后,还剩v2
            int v2 = (int) money - v1;
            // 第二个红包是 前面余额的随机数

            int v3 = (int)(Math.random() * (v2-1))+1;
            al.add(v3);
            int v4 = v2 - v3;

            al.add(v4);

            // 打印红包容器
            System.out.println("红包容器");
            for (Integer integer : al) {
                System.out.print(integer + " ");
            }
            // 群主的余额减去此处发的红包
            setBalance(getBalance() - money);
            System.out.println("群主的余额还剩: " + this.getBalance());
            FindMax(al);
            return al;
        }
    }

    // 比较最大值
    public void FindMax(ArrayList<Integer> al) {
        int max = 0;
        int index = 0;
        for (int i = 0; i < al.size(); i++) {
            if (max < al.get(i)) {
                max = al.get(i);
                index = i;
            }
        }
        System.out.println("红包最大值是: " + max);
        System.out.println("第" + (index + 1) + "个人的手气最佳");
    }
 }

package demox.demo01.hongbaopro;

import java.util.ArrayList;
import java.util.Iterator;

public class member extends Person {

    public member(String name, double balance) {
        super(name, balance);
    }

    public void money(ArrayList<Double> al) {
        // 用迭代器从容器队列中取元素,如果没有元素就不能取
        // 创建一个迭代器对象
        Iterator<Double> iterator = al.iterator();
        // 如果容器队列中有元素,则 hasNext() 为 true
        //while (iterator.hasNext()) {
            // 容器中存储的是 Double 包装类数据,直接转换为 double 基本数据类型
            Double temp = iterator.next();
            // 取过值后,移除该元素
            iterator.remove();
            System.out.println("从红包中收到 " + temp + " 元钱");

            // 包装类自动拆箱
            setBalance(this.getBalance() + temp);
            System.out.println("成员姓名:" + getName() + " 余额: " + getBalance());
       // }
    }

    public void money2(ArrayList<Integer> al) {
        Iterator<Integer> iterator = al.iterator();
        while (iterator.hasNext()) {
            double temp = iterator.next();
            iterator.remove();
            System.out.println("从红包中收到 " + temp + " 元钱");
            setBalance(this.getBalance() + temp);
            System.out.println("成员姓名:" + getName() + " 余额: " + getBalance());
        }
    }
}

package demox.demo01.hongbaopro;

import java.util.ArrayList;

/**
 *  综合 案例 : 群主发普通红包
 *  群内有1个群主,多名成员 ,发普通红包均分
 *  1.群主的一笔金额,从群主的余额总扣除,平均分成 N 等份,让成员领取
 *  2.成员领取红包后,保存在成员余额中
 *
 *
 *  拓展拼手气红包
 *  1,输出手气最佳的成员
 *  2.输出最后每位成员的余额
 */
public class mainProgram {

    public static void main(String[] args) {

        // 创建一个红包队列,保存群主发的红包钱,每个元素,就是一个红包
        ArrayList<Double> al = new ArrayList<>();

        // 创建一个红包队列,保存群主发的红包钱,每个元素,就是一个红包
        ArrayList<Integer> al2 = new ArrayList<>();

        // 群主属性有姓名和余额
        Owner owner = new Owner("群主", 1000);

        member m1 = new member("成员1",0);
        member m2 = new member("成员2",0);
        member m3 = new member("成员3",0);


        System.out.println("发普通红包");
        // 总共发3个,每个100 块钱,总共300块钱
        // 此处是为了避免除不尽的情况
        owner.money(al,3,100);
        // 成员从队列中取红包,每取一个,容器元素减一
        m1.money(al);
        m2.money(al);
        m3.money(al);


        System.out.println("随机红包");
        // 发三个红包,总共100块钱,每个人分到的都是整数
        owner.money2(al2,3,100);
        m1.money2(al2);
        m2.money2(al2);
        m3.money2(al2);

    }

}

2.

package demox.demo01.hongbaopromax;

public class User {
    private String username;//定义用户名
    private double leftMoney;//余额

    public User() {  //无参构造
    }

    public User(String username, double leftMoney) {  //有参构造
        this.username = username;
        this.leftMoney = leftMoney;
    }

    //显示当前用户有多少钱
    public void show() {
        System.out.println(username+"当前余额为："+leftMoney);
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public double getLeftMoney() {
        return leftMoney;
    }

    public void setLeftMoney(double leftMoney) {
        this.leftMoney = leftMoney;
    }
}

 

package demox.demo01.hongbaopromax;

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

public class Member extends User{

    public Member() {

    }

    public Member(String username, double leftMoney) {
        super(username, leftMoney);
    }

    public void recieve(ArrayList<Double> list) {
        //从多个红包中随机抽取一个
        //随机获取一个集合的索引编号
        int flag = list.size();
        if (flag == 0) {
            System.out.println(getUsername() + "抢到的红包金额为：" + 0);
            //当前用户自己本来有多少钱
            double money = super.getLeftMoney();
            setLeftMoney(money +0);//当前用户余额
        }else {
            int index = new Random().nextInt(list.size());
            //从集合中删除，并且得到被删除的红包给我自己
            double delta = list.remove(index);
            System.out.println(getUsername() + "抢到的红包金额为：" + delta);
            //当前用户自己本来有多少钱
            double money = super.getLeftMoney();
            setLeftMoney(money + delta);//当前用户余额
        }
    }
}

package demox.demo01.hongbaopromax;

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

public class Master extends User {

    public Master() {

    }

    public Master(String username,double leftMoney) {
        super(username, leftMoney);
    }

    public ArrayList<Double> send(int totalMoney,int count) {
        //首先需要一个集合来存储若干红包的集合
        ArrayList<Double> redlist = new ArrayList<>();

        System.out.println("红包总额为："+totalMoney+"，红包个数为："+count);
        //看一下群主有多少钱
        double leftMoney = super.getLeftMoney();
        //判断
        if (totalMoney > leftMoney) {

            return null;
        }

        //扣钱后余额（重新设置余额）
        super.setLeftMoney(leftMoney - totalMoney);

        //发红包平均拆分为count个
        double avg = totalMoney / count;
        double mod = totalMoney % count;//余数

        //除不开的零头放进最后一个红包中
        for (int i = 0; i < count; i++) {
            if (i == count - 1) {
                redlist.add(avg + mod);
            } else {
                redlist.add(avg);
            }
        }
        return redlist;
    }
}

package demox.demo01.hongbaopromax;

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

public class demo01RedPackage {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入金额：");
        int totalMoney = sc.nextInt();
        System.out.println("请输入个数");
        int count = sc.nextInt();
        Master master = new Master("群主",100);
        ArrayList<Double> redlist = master.send(totalMoney,count);
        if(redlist ==null) {
            System.out.println("余额不足");
            return;
        }
        Member member1 = new Member("成员1",0);
        Member member2 = new Member("成员2",20);
        Member member3 = new Member("成员3",54);
        Member member4 = new Member("成员4",43);
        Member member5 = new Member("成员5",32);
        Member member6 = new Member("成员6",87);

        master.show();

        member1.show();
        member2.show(); 
        member3.show();
        member4.show();
        member5.show();
        member6.show();


        member1.recieve(redlist);
        member2.recieve(redlist);
        member3.recieve(redlist);
        member4.recieve(redlist);
        member5.recieve(redlist);
        member6.recieve(redlist);

        master.show();
        member1.show();
        member2.show();
        member3.show();
        member4.show();
        member5.show();
        member6.show();


    }
}

 

 

案例分析

2.1 继承关系