面向对象基础案例(1)

📋 个人简介
💖 作者简介：大家好，我是W_chuanqi，一个编程爱好者
📙 个人主页：W_chaunqi
😀 支持我：点赞👍+收藏⭐️+留言📝
💬 愿你我共勉：“没有什么比勇气更温文尔雅，没有什么比怯懦更冷酷无情!”✨✨✨

面向对象基础案例(1)

1.汽车加油

一辆油车的油箱为30L，油箱里现剩余6L汽油。加油站每5秒为这辆车加2L汽油直至加满，控制台输出加油过程和加油时间。

🎇代码实现

public class AutoMobile {
	public AutoMobile(int oilVolume, int leftOilVolume) {
		int addOilVolume = oilVolume - leftOilVolume;//需要加的油量
		int time = 0;//初始化时间
		System.out.println("即将加满油箱……");
		while (addOilVolume != 0) {
			System.out.println("还剩余" + addOilVolume + "L，已耗时" + time + "秒。");
			addOilVolume -= 2;//每次加2L油
			time += 5;//加一次油用时5s
		}
		System.out.println("还剩余" + addOilVolume + "L，已耗时" + time + "秒。");
	}

	public static void main(String[] args) {
		AutoMobile am = new AutoMobile(30, 6);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

🎇运行结果

2.买可乐

张三去KFC买可乐，商家默认不加冰块，但是张三可以要求加3个冰块。请利用构造方法实现上述功能。

🎇代码实现

public class IceBlock {
	
	public IceBlock() {
		System.out.println("商家默认可乐里没有冰块……");
	}
	
	public IceBlock(String name, int number) {
		System.out.println(name + "要求向可乐里放入" + number + "个冰块。");
	}
	
	public static void main(String[] args) {
		IceBlock block = new IceBlock();
		IceBlock iceBlock = new IceBlock("张三", 3);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

🎇运行结果

3.设置信用卡密码

创建信用卡类，有两个成员变量，分别是卡号和密码，如果用户开户时没有设置初始密码，则使用“123456”作为默认密码。设计两个不同的构造方法，分别用于用户设置密码和用户未设置密码两种构造场景。

🎇代码实现

public class Credit {
	String cardNum;// 卡号
	String password;// 密码

	public Credit(String cardNum, String password) {// 用户设置密码
		this.cardNum = cardNum;
		this.password = password;
		if (password.equals("123456")) {
			System.out.println("信用卡" + cardNum + "的默认密码为" + password);
		} else {
			System.out.println("重置信用卡" + cardNum + "的密码为" + password);
		}
	}

	public Credit(String cardNum) {// 用户不设置密码
		this(cardNum, "123456");
	}

	public static void main(String[] args) {
		Credit initialCredit = new Credit("4013735633800642");
		Credit resetedCredit = new Credit("4013735633800642", "168779");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

🎇运行结果

4.信用卡消费记录

使用静态变量定义使用信用卡消费的总次数，控制台先输出使用信用卡消费的每一条交易信息，在输出信用卡消费的总次数。

🎇代码实现

public class CreditCard {
	double amount;//金额
	public static int times = 0;//初始化次数
	
	public CreditCard(double amount) {
		times++;
		this.amount = amount;
	}
	
	public void output() {
		System.out.println("您有一笔大额消费，交易金额：" + amount + "元。");
	}
	
	public static void main(String[] args) {
		CreditCard cr = new CreditCard(1550);
		cr.output();
		CreditCard ce = new CreditCard(1920);
		ce.output();
		CreditCard cd = new CreditCard(1979);
		cd.output();
		CreditCard ci = new CreditCard(2259);
		ci.output();
		CreditCard ct = new CreditCard(1835);
		ct.output();
		CreditCard cc = new CreditCard(1799);
		cc.output();
		CreditCard ca = new CreditCard(2688);
		ca.output();
		System.out.println("您最近有" + CreditCard.times + "笔交易。");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

🎇运行结果

5.水池放水

创建一个水池类，在类中先定义一个静态变量表示水池的水量，并初始化为0；再定义两个静态方法，即注水(一次性注入3个单位)方法和放水(一次性放出2个单位)方法。通过调用这两个静态方法，控制水池的水量。

🎇代码实现

public class Pool { // 创建水池类
	public static int water = 0; // 初始化静态变量之水池中的水量为0

	public static void outlet() { // 放水，一次放出2个单位
		if (water >= 2) { // 如果水池中的水量大于等于2个单位
			water = water - 2; // 放出2个单位的水
		} else { // 如果水池中的水量小于2个单位
			water = 0; // 水池中的水量为0
		}
	}

	public static void inlet() { // 注水，一次注入3个单位
		water = water + 3; // 注入3个单位的水
	}

	public static void main(String[] args) {
		System.out.println("水池的水量：" + Pool.water); // 输出水池当前水量
		System.out.println("水池注水两次。");
		Pool.inlet(); // 调用静态的注水方法
		Pool.inlet(); // 调用静态的注水方法
		System.out.println("水池的水量：" + Pool.water); // 输出水池当前水量
		System.out.println("水池放水一次。");
		Pool.outlet(); // 调用静态的放水方法
		System.out.println("水池的水量：" + Pool.water); // 输出水池当前水量
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

🎇运行结果

6.创建猫类

编写一个猫类，然后分别创建3只猫的对象，分别是黑猫、白猫和黄猫，让三只猫都去抓老鼠。

🎇代码实现

public class Cat {
	String color;

	public Cat(String color) {
		this.color = color;
	}

	public void catchMice() {
		System.out.println(color + "猫去抓老鼠了……");
	}

	public static void main(String[] args) {
		Cat black = new Cat("黑");
		black.catchMice();
		Cat white = new Cat("白");
		white.catchMice();
		Cat yellow = new Cat("黄");
		yellow.catchMice();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

🎇运行结果

7.购买电影票

购买电影票有优惠：满18周岁的付40元，未满18周岁的享受半价。使用成员变量、成员方法、构造方法和this关键字，控制台输出姓名、年龄、票价等信息。

🎇代码实现

public class Audience {
	String name; // 姓名
	int age; // 年龄

	public Audience(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public void buyTicket() { // 购票方法
		if (this.age >= 18) { // 观众已满18周岁
			System.out.println(name + "\t\t" + age + "\t\t" + 40);
		} else {// 观众未满18周岁
			System.out.println(name + "\t\t" + age + "\t\t" + 40 / 2);
		}
	}

	public static void main(String[] args) {
		System.out.println("姓名\t\t年龄\t\t票价(元)");
		System.out.println("———————————————————————————————————————");

		Audience audience1 = new Audience("李明", 20); // 李明，20岁
		audience1.buyTicket(); // 李明购票

		Audience audience2 = new Audience("钱丽", 16); // 钱丽， 16岁
		audience2.buyTicket(); // 钱丽购票

		Audience audience3 = new Audience("周刚", 8); // 周刚， 8岁
		audience3.buyTicket(); // 周刚购票

		Audience audience4 = new Audience("吴红", 32); // 吴红，32岁
		audience4.buyTicket(); // 吴红购票
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

🎇运行结果

8.计算平均分

使用成员变量、成员方法、构造方法和this关键字，先记录4名学生的语文、数学、英语这三科的成绩，再计算每个人的平均分。

🎇代码实现

public class Student {
	int number; // 学号
	String name; // 姓名
	float chinese; // 语文成绩
	float math; // 数学成绩
	float english; // 英语成绩

	public Student(int number, String name, float chinese, float math, float english) { // 构造有参方法，并用this关键字区分重名的成员变量与变量
		this.number = number;
		this.name = name;
		this.chinese = chinese;
		this.math = math;
		this.english = english;
	}

	public void average() { // 计算平均分的方法
		float aver = (chinese + math + english) / 3; // aver表示平均分
		System.out.println(number + "\t" + name + "\t" + chinese + "\t" + math + "\t" + english + "\t" + aver);
	}

	public static void main(String[] args) {
		System.out.println("学号\t姓名\t语文\t数学\t英语\t平均分");
		System.out.println("——————————————————————————————————————————————————");
		Student student1 = new Student(1, "张三", 91.5f, 98f, 89f); // 张三的各科成绩
		student1.average(); // 计算张三的平均分

		Student student2 = new Student(2, "李四", 96f, 98.5f, 93f); // 李四的各科成绩
		student2.average(); // 计算李四的平均分

		Student student3 = new Student(3, "王五", 97f, 100f, 98.5f); // 王五的各科成绩
		student3.average(); // 计算王五的平均分

		Student student4 = new Student(4, "钱六", 77f, 83f, 81f); // 钱六的各科成绩
		student4.average(); // 计算钱六的平均分
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

🎇运行结果

9.基于控制台的购书系统

🎇案例描述

伴随互联网的蓬勃发展，网络购书系统作为电子商务的一种形式，正以其高效、低成本的优势逐步成为新兴的经营模式，人们已经不再满足互联网的用途仅仅局限于信息的浏览和发布，更渴望着能够充分享受互联网所带来的更多便利。网络购书系统正适应了当今社会快节奏地生活，使顾客足不出户便可以方便快捷轻松地选购自己喜欢的图书。

本任务要求，使用所学知识编写一个基于控制台的购书系统，实现购书功能。输出所有图书的信息：包括每本书的编号、书名、单价、库存。

顾客购买书时，根据提示输入图书编号来选购需要的书，并根据提示输入购买书的的数量。

购买完毕后输出顾客的订单信息，包括：订单号、订单明细、订单总额。

🎇案例分析

（1）通过任务描述可知，该系统中必须包括3个实体类，类名及属性设置如下：

• 图书类（Book）：
  • a) 图书编号（id）
  • b) 图书名称（name）
  • c) 图书单价（price）
  • d) 库存数量（storage）
• 订单项类（OrderItem）：
  • a) 图书（book）
  • b) 购买数量（num）
• 订单类（Order）：
  • a) 订单号（orderID）
  • b) 订单总额（total）
  • c) 订单项列表（items）

（2）由于购买图书时，需要选择图书的数量，所以需要在订单项类里定义获取图书对象以及图书数量的方法。

（3）由于需要指定订单项以及获取订单的订单列表、订单号、订单总额等信息，所以需要有订单列表、订单号、订单总额指定订单项等方法。

🎇案例实现

定义图书类Book，其代码如下所示。

public class Book {

    private int id; // 编号
    private String name; // 书名
    private double price; // 价格
    private int storage; // 库存

    // 有参构造
    public Book(int id, String name, double price, int storage) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.storage = storage;
    }

    // 获取书号
    public int getId() {
        return id;
    }

    // 获取书名
    public String getName() {
        return name;
    }

    // 获取价格
    public double getPrice() {
        return price;
    }

    // 获取库存
    public int getStorage() {
        return storage;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

上述代码中，声明了图书标号id、书名name、价格price、库存storage,并提供了其getter和setter方法。

定义订单项类OrderItem，其代码如下所示。

public class OrderItem {
    private Book book;
    private int num;

    // 有参构造方法
    public OrderItem(Book book, int num) {
        this.book = book;
        this.num = num;
    }

    // 获取图书对象
    public Book getBook() {
        return book;
    }

    // 获取订购图书数量
    public int getNum() {
        return num;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上述代码中，声明了图书对象Book,购买数量num，并提供了其getter和setter方法。

定义订单类Order，其代码如下所示。

public class Order {
    private String orderId;
    private OrderItem items[];
    private double total;

    // 有参构造
    public Order(String orderId) {
        this.orderId = orderId;
        this.items = new OrderItem[3];
    }

    // 获取订单号
    public String getOrderId() {
        return orderId;
    }

    // 获取订单列表
    public OrderItem[] getItems() {
        return items;
    }

    // 获取订单总额
    public double getTotal() {
        calTotal();
        return total;
    }

    // 指定一个订单项
    public void setItem(OrderItem item, int i) {
        this.items[i] = item;
    }

    // 计算订单总额
    public void calTotal() {
        double total = 0;
        for (int i = 0; i < items.length; i++) {
            total += items[i].getNum() * items[i].getBook().getPrice();
        }
        this.total = total;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

上述代码中，声明了订单id、订单项数组，并声明了获取订单号方法getOrderId()、获取订单列表方法getItems()、获取订单总额方法getTotal()、指定一个订单项setItem()、计算订单总额的方法calTotal()。

import java.util.Scanner;

public class PayBooks {
    public static void main(String[] args) {
        Book books[] = new Book[3];
        // 模拟从数据库中读取图书信息并输出
        outBooks(books);
        // 顾客购买图书
        Order order = purchase(books);
        // 输出订单信息
        outOrder(order);
    }

    // 顾客购买图书
    public static Order purchase(Book books[]) {
        Order order = new Order("00001");
        OrderItem item = null;
        Scanner in = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入图书编号选择图书：");
            int cno = in.nextInt();
            System.out.println("请输入购买图书数量：");
            int pnum = in.nextInt();
            item = new OrderItem(books[cno - 1], pnum);
            order.setItem(item, i);
            System.out.println("请继续购买图书。");
        }
        in.close();
        return order;
    }

    // 输出订单信息
    public static void outOrder(Order order) {
        System.out.println("\n\t图书订单");
        System.out.println("图书订单号：" + order.getOrderId());
        System.out.println("图书名称\t购买数量\t图书单价");
        System.out.println("--------------------------------------");
        OrderItem items[] = order.getItems();
        for (int i = 0; i < items.length; i++) {
            System.out.println(
                    items[i].getBook().getName() + "\t" + items[i].getNum() + "\t" + items[i].getBook().getPrice());
            // System.out.println("\n");
        }
        System.out.println("---------------------------------------");
        System.out.println("订单总额：\t\t" + order.getTotal());
    }

    // 模拟从数据库中读取图书信息并输出
    public static void outBooks(Book books[]) {
        books[0] = new Book(1, "Java教程", 30.6, 30);
        books[1] = new Book(2, "JSP教程 ", 42.1, 40);
        books[2] = new Book(3, "SSH架构 ", 47.3, 15);
        System.out.println("\t图书列表");
        System.out.println("图书编号\t图书名称\t图书单价\t库存数量");
        System.out.println("---------------------------------------");
        for (int i = 0; i < books.length; i++) {
            System.out.println(
                    i + 1 + "\t\t" + books[i].getName() + "\t" + books[i].getPrice() + "\t\t" + books[i].getStorage());
        }
        System.out.println("---------------------------------------");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

上述代码中，输出了图书列表信息包括：图书编号、图书名称、图书单价、库存数量，用户根据图书列表信息，输入图书编号、购买数量等，系统根据用户输入的图书编号及购买数量计算总金额。

🎇运行结果

10.银行存取款程序设计

🎇案例描述

银行存取款的流程是人们非常熟悉的事情，用户可在银行对自己的资金账户进行存款、取款、查询余额等操作，极大的便利了人民群众对资金的管理。

本任务要求，使用所学知识编写一个银行存取款程序，实现存取款功能。编写一个帐户类实现银行帐户的概念，创建帐户类的对象ba，假设ba的账号为:123456，初始的存款余额为500元。首先向该账户存入1000元，再取出800元。

🎇案例分析

（1）通过任务描述可知，需要定义一个银行帐户类BankAccount实现银行帐户的概念。

（2）账户的属性包括账号和存款余额，所以还需要在BankAccount类中定义两个变量：“帐号” (account_number) 和“存款余额”(leftmoney)。

（3）对账户的操作包括存款、取款、查询余额，所以再定义四个方法：“存款”(savemoney)、“取款”(getmoney) 、“查询余额”(getleftmoney)以及构造方法(BankAccount)。

（4）最后，编写测试类，在main()方法中创建一个BankAccount类的对象ba，假设ba的账号为:123456，初始的存款余额为500元。首先向该账户存入1000元，再取出2000元。

🎇案例实现

public class BankAccount {
    int account_number;// 账号
    double leftmoney;// 存款余额

    public double getleftmoney() { // 查询余额
        return leftmoney;
    }

    public void savemoney(double money) { // 存款
        leftmoney += money;
    }

    public void getmoney(double money) { // 取款
        leftmoney -= money;
    }

    public BankAccount(int number, double money) { // 构造方法，用来初始化变量
        account_number = number;
        leftmoney = money;
    }

    public static void main(String[] args) {
        BankAccount ba = new BankAccount(123456, 500);
        ba.savemoney(1000);
        System.out.println("存入1000元后，您的余额为：" + ba.getleftmoney());
        ba.getmoney(2000);
        System.out.println("取款2000元后，您的余额为：" + ba.getleftmoney());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

上述代码中，声明了一个int类型的account_number属性设一个double类型的leftmoney属性，并编写了其存款方法savemoney（）、取款方法getmoney（）、查询余额方法getleftmoney（）以及用来初始化变量的构造方法BankAccount（）。最后，在main()方法中进行测试：创建了一个ba对象，账号为123456，初始余额为500元，首先向该账户存入了1000元，随后又取出2000元。

🎇运行结果

11.多功能手机

🎇案例描述

随着科技的发展，手机的使用已经普及到每个家庭甚至个人，手机的属性越来越强大，功能也越来越多，因此人们在生活中越来越依赖于手机。

任务要求，使用所学知识编写一个手机属性及功能分析程序设计，测试各个手机的属性及功能。使用手机时，输出当前手机的各个属性参数以及正在使用的功能。

🎇实现思路

（1）通过任务描述可知，需要定义一个手机类Phone实现手机的概念。

（2）手机具有属性：品牌（brand）、型号（type）、价格（price）、操作系统（os）和内存（memory）。因此，需要在手机类中定义品牌（brand）、型号（type）、价格（price）、操作系统（os）和内存（memory）的变量。

（3）手机具有功能：查看手机信息（about（））、打电话（call（String no））、玩游戏（playGame()）、下载音乐（downloadMusic()）、播放音乐（playMusic()）。所以，可以定义对应的方法about（）、call（）、playGame()、downloadMusic()、playMusic()。

🎇代码实现

public class Phone {
    String brand; // 品牌
    String type; // 型号
    String os; // 操作系统
    int price; // 价格
    int memorySize; // 内存

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

    // 有参构造
    public Phone(String brand, String type, String os, int price, int memorySize) {
        this.brand = brand;
        this.type = type;
        this.os = os;
        this.price = price;
        this.memorySize = memorySize;
    }

    // 关于本机
    public void about() {
        System.out.println("品牌：" + brand + "\n" + "型号：" + type + "\n" +
                "操作系统：" + os + "\n" + "价格：" + price + "\n" + "内存：" + memorySize + "\n");
    }

    // 打电话
    public void call(int num) {
        System.out.println("使用自动拨号功能：");
        String phoneNo = "";
        switch (num) {
            case 1:
                phoneNo = "爸爸的号。";
                break;
            case 2:
                phoneNo = "妈妈的号。";
                break;
            case 3:
                phoneNo = "爷爷的号。";
                break;
            case 4:
                phoneNo = "奶奶的号。";
                break;
        }
        System.out.println(phoneNo);
    }

    // 打游戏
    public void playGame() {
        System.out.println("玩扫雷游戏。");
    }

    // 下载音乐
    public void downloadMusic(String song) {
        System.out.println("开始下载。。。。");
        System.out.println("下载完成。。。。");
    }

    // 播放音乐
    public void playMusic(String song) {
        System.out.println("播放歌曲：" + song);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

上述代码中，定义了手机的品牌brand、型号type、价格price、操作系统os、内存memorySize等属性，并提供了手机类的无参和参构造，以及打电话call()、打游戏playGame()、下载音乐downloadMusic()、播放音乐playMusic()等方法。

public class PhoneTest {
    public static void main(String[] args) {
        // 通过无参构造创建手机对象一
        Phone p1 = new Phone();
        p1.brand = "苹果";
        p1.type = "iphoneX";
        p1.os = "ios";
        p1.price = 8888;
        p1.memorySize = 16;
        // 测试p1的各项功能
        p1.about();
        p1.call(3);
        p1.playGame();
        p1.playMusic("我的中国心");
        System.out.println("********************");
        Phone p2 = new Phone("华为", "华为荣耀20", "Android", 6666, 16);
        // 测试p2 的各项功能
        p2.about();
        p2.call(4);
        p2.playGame();
        p2.playMusic("北京欢迎你");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

上述代码中，创建了两个手机对象，并输出了这两个手机对象的属性及功能。

🎇运行结果

12.学生投票系统

🎇案例描述

某班级投票竞选班干部，班级学生人数为100人，每个学生只能投一票。

本任务要求，编程实现一个投票程序，每个学生只能投一次票，投票成功提示“感谢你的投票”，若重复投票，提示“请勿重复投票”。当投票总数达到100时或者主观结束投票时，同时统计投票学生人数和投票结果。

🎇实现思路

（1）通过任务描述可知，需要定义一个参与投票的学生类Voter类，它具有姓名，最大投票数，当前投票总数，和投票意见。

（2）因为所有参与投票的学生都会改变同一个数据，即投票次数，一次把它定义成静态变量：private static int count；

（3）另外，为了防止学生重复投票，必须保存参与投票的学生信息，可采用一个集合来存放已经投票的学生对象。

private static Set<Voter> voters = new HashSet<Voter>();
1

（4）最后编写测试Voter类的投票和打印投票结果功能。

🎇代码实现

import java.util.HashSet;
import java.util.Set;

public class Voter {
    // 属性的定义
    private static final int MAX_COUNT = 100; // 最大投票数
    private static int count; // 投票数

    // 静态变量，存放已经投票的学生
    private static Set<Voter> voters = new HashSet<Voter>();
    private String name;
    private String answer;

    // 构造方法
    public Voter(String name) {
        this.name = name;
    }

    // 投票
    public void voterFor(String answer) {
        if (count == MAX_COUNT) {
            System.out.println("投票结束。");
            return;
        }
        if (voters.contains(this)) {
            System.out.println(name + "，请勿重复投票。");
        } else {
            this.answer = answer;
            count++;
            voters.add(this);
            System.out.println(name + " 感谢你的投票。");
        }
    }

    // 打印投票结果
    public static void printVoterResult() {
        System.out.println("当前投票数为：" + count);
        System.out.println("参与投票的学生和结果如下：");

        for (Voter voter : voters) {
            System.out.println(voter.name + " 意见 " + voter.answer);
        }
    }

    public static void main(String[] args) {
        // 创建参与投票的学生对象
        Voter tom = new Voter("Tom");
        Voter jack = new Voter("Jack");
        Voter mike = new Voter("Mike");
        // 学生开始投票
        tom.voterFor("是");
        tom.voterFor("否");
        jack.voterFor("是");
        mike.voterFor("是");
        // 打印投票结果
        Voter.printVoterResult();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

🎇运行结果