题目1
定义手机类,手机有品牌(brand),价格(price)和颜色(color)三个属性,有打电话call()和sendMessage()两个功能。
请定义出手机类,类中要有空参、有参构造方法,set/get方法。
定义测试类,在主方法中使用空参构造创建对象,使用set方法赋值。
调用对象的两个功能,打印效果如下:
正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....
操作步骤
定义手机类,手机类中定义String类型的品牌,int类型的价格,String类型的颜色,三个成员变量都用privice修饰。
提供空参构造方法和有参构造方法。
提供set/get方法。
编写打电话的成员方法,方法中对成员变量进行使用。
编写发短信的成员方法,方法中对成员变量进行使用。
在测试类中创建手机对象,使用set方法赋值,分别调用各个方法。
手机类:
public class Phone {
//定义品牌
private String brand;
//定义价格
private int price;
//定义颜色
private String color;
//提供空参构造
public Phone() {
}
//提供有参构造
public Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
//提供set/get方法
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//定义打电话方法
public void call(){
System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"手机打电话....");
}
//定义发短信方法
public void sendMessage(){
System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"手机发短信....");
}
}
测试类:
public class Demo1 {
public static void main(String[] args) {
//创建手机对象
Phone p = new Phone();
//调用set方法赋值
p.setBrand("小米");
p.setPrice(3998);
p.setColor("黑色");
//调用打电话功能
p.call();
//调用发短信功能
p.sendMessage();
}
}
题目2
定义一个女朋友类。女朋友的属性包含:姓名,身高,体重。行为包含:洗衣服wash(),做饭cook()。另外定义一个用于展示三个属性值的show()方法。请在测试类中通过有参构造方法创建对象并赋值,然后分别调用展示方法、洗衣服方法和做饭方法。打印效果如下:
我女朋友叫凤姐,身高155.0厘米,体重130.0斤
女朋友帮我洗衣服
女朋友给我做饭
操作步骤
定义女朋友类,定义String类型姓名,double类型身高和double类型体重三个成员变量,三个成员变量都用privice修饰。
提供空参构造方法和有参构造方法。
提供set/get方法。
编写展示方法show(),方法打印三个成员变量的值。
编写洗衣服wash()方法,输出洗衣服的语句。
编写做饭cook()方法,输出做饭的语句。
在测试类中使用有参构造创建女友对象,分别调用各个方法。
女朋友类:
public class Girlfriend {
//姓名
private String name;
//身高
private double height;
//体重
private double weight;
//空参构造
public Girlfriend() {
}
//有参构造
public Girlfriend(String name, double height, double weight) {
this.name = name;
this.height = height;
this.weight = weight;
}
//set/get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
//展示方法
public void show(){
System.out.println("我女朋友叫" +name+",身高" +height+"厘米,体重"+weight+"斤");
}
//洗衣服方法
public void wash(){
System.out.println("女朋友帮我洗衣服");
}
//做饭方法
public void cook(){
System.out.println("女朋友给我做饭");
}
}
测试类:
public class Demo2 {
public static void main(String[] args) {
//创建女朋友对象
Girlfriend gf = new Girlfriend("凤姐",155,130);
//调用展示方法
gf.show();
//调用洗衣服方法
gf.wash();
//调用做饭方法
gf.cook();
}
}
题目3
定义项目经理类Manager。属性:姓名name,工号id,工资salary,奖金bonus。行为:工作work() 定义程序员类Coder。属性:姓名name,工号id,工资salary。行为:工作work()
要求:
1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造,set和get方法 2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法) 3.调用成员方法,打印格式如下
工号为123基本工资为15000奖金为6000的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
工号为135基本工资为10000的程序员正在努力的写着代码......
操作步骤
定义项目经理类,定义成员变量,构造方法,set和get方法,work方法,方法中根据打印格式输出id,salary,bonus的值。
定义程序猿类,定义成员变量,构造方法,set和get方法,work方法,方法中根据打印格式输出id和salary的值。
在测试类中使用有参构造创建项目经理对象并赋值,调用工作方法打印结果。
在测试类中使用有参构造创建程序员对象并赋值,调用工作方法打印结果。
经理类:
public class Manager {
private String name;
private int id;
private int salary;
private int bonus;
public Manager() {
}
public Manager(String name, int id, int salary, int bonus) {
this.name = name;
this.id = id;
this.salary = salary;
this.bonus = bonus;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
public void work(){
System.out.println("工号为"+id+"基本工资为"+salary+"奖金为"+bonus+"的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....");
}
}
程序员类:
package com.day07;
public class Coder {
private String name;
private int id;
private int salary;
public Coder() {
}
public Coder(String name, int id, int salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public void work(){
System.out.println("工号为"+id+"基本工资为"+salary+"的程序员正在努力的写着代码......");
}
}
测试类:
public class Demo3 {
public static void main(String[] args) {
//创建经理对象
Manager m = new Manager("老王",123,15000,6000);
//调用工作方法
m.work();
//创建程序员对象
Coder c = new Coder("小王",135,10000);
//调用工作方法
c.work();
}
}
题目4
定义猫类Cat。属性:毛的颜色color,品种breed。行为:吃饭eat(),抓老鼠catchMouse() 定义狗类Dog。属性:毛的颜色color,品种breed。行为:吃饭(),看家lookHome()
要求:
1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造,set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:
花色的波斯猫正在吃鱼.....
花色的波斯猫正在逮老鼠....
黑色的藏獒正在啃骨头.....
黑色的藏獒正在看家.....
操作步骤
定义猫类,定义成员变量,构造方法,set和get方法,吃饭方法eat(),抓老鼠方法catchMouse(),方法中根据题目给出的格式输出成员变量的值。
定义狗类,定义成员变量,构造方法,set和get方法,吃饭方法eat(),看家方法lookHome(),方法中根据题目给出的格式输出成员变量的值。
在测试类中使用有参构造创建猫类对象,调用eat()方法和catchMouse()方法。
在测试类中使用有参构造创建狗类对象,调用eat()方法和lookHome()方法。
猫类:
public class Cat {
private String color;
private String breed;
public Cat(){}
public Cat(String color, String breed) {
this.color = color;
this.breed = breed;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getBreed() {
return breed;
}
public void setBreed(String breed) {
this.breed = breed;
}
public void eat(){
System.out.println(color+"的"+breed+"正在吃鱼.....");
}
public void catchMouse(){
System.out.println(color + "的"+ breed +"正在逮老鼠....");
}
}
狗类:
public class Dog {
private String color;
private String breed;
public Dog(){}
public Dog(String color, String breed) {
this.color = color;
this.breed = breed;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getBreed() {
return breed;
}
public void setBreed(String breed) {
this.breed = breed;
}
public void eat(){
System.out.println(color + "的"+ breed +"正在啃骨头.....");
}
public void lookhome(){
System.out.println(color + "的"+ breed +"正在看家.....");
}
}
测试类:
public class Demo4 {
public static void main(String[] args) {
//创建猫对象
Cat c = new Cat("花色","波斯猫");
//调用猫的方法
c.eat();
c.catchMouse();
//创建狗对象
Dog d = new Dog("黑色","藏獒");
d.eat();
d.lookhome();
}
}
题目5
现已知工人(Worker)类,属性包含姓名(name)、工龄(year),请编写该类,提供构造方法和get、set方法。在测试类中,请查看键盘录入Scanner类的API,创建工人类对象,属性值由键盘录入,打印对象的属性值。输出效果如下:
请录入工人姓名:
张三
请录入工人工龄:
5
该工人对象的属性信息如下:
姓名:张三
工龄:5
操作步骤
1、创建Worker类,成员变量私有修饰,提供空参和全参构造方法,提供get和set方法。
2、创建Test01类,在主方法中,创建键盘录入Scanner对象。
2.1、姓名信息为字符串,使用Scanner的nextLine()方法。
2.2、工龄信息为整数,使用Scanner的nextInt()方法。
3、创建Worker类对象,并输出对象的成员变量值。
3.1、可以在创建对象时使用构造方法为成员变量赋值,也可以创建对象后使用set方法赋值。
3.2、获取成员变量的值,使用get方法。
public class Worker {
// 成员变量
private String name;
private int year;
// 构造方法
public Worker() {
}
public Worker(String name, int age) {
this.name = name;
this.year = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
}
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入工人姓名:");
String name = sc.nextLine();
System.out.println("请输入工人工龄:");
int year = sc.nextInt();
// 创建对象
Worker w = new Worker(name, year);
// 输出信息
System.out.println("该工人对象的信息如下:");
System.out.println("姓名:" + w.getName());
System.out.println("工龄:" + w.getYear());
}
}
题目6
在登录注册页面中,除了用户名和密码外,通常也会包含验证码。验证码是用来区分用户是计算机还是人,防止恶意破解密码、刷票、灌水等行为。请查看Random、StringBuilder相关API,定义方法,获取一个包含4个字符的验证码,每一位字符是随机选择的字母和数字,可包含a-z,A-Z,0-9。例如:
7Kt5
操作步骤
1、定义方法,返回值是String,参数列表为空。
2、定义StringBuilder对象,将可选择的字符都放到StringBuilder对象中。
2.1、定义循环从a-z,使用StringBuilder的append方法依次添加所有小写字母
2.2、定义循环从A-Z,使用StringBuilder的append方法依次添加所有大写字母
2.3、定义循环从0-9,使用StringBuilder的append方法依次添加所有数字字符
3、创建Random对象。定义一个空字符串用于保存验证码。
4、定义一个执行4次的循环,用于获取4个字符。
4.1、在循环中,使用Random的nextInt方法,随机获取一个从索引0(包含)到字符串的长度(不包含)的索引。
4.2、使用StringBuilder的charAt方法,获取该索引上的字符,将其拼接到验证码字符串中。
5、返回结果,并在主方法中调用方法查看结果。
import java.util.Random;
public class Test02 {
public static void main(String[] args) {
String code = getRandomCode();
System.out.println(code);
}
public static String getRandomCode() {
// 准备数据,将可选择的字符都放入StringBuilder中
StringBuilder sb = new StringBuilder();
for (char ch = 'a'; ch <= 'z'; ch++) {
sb.append(ch);
}
for (char ch = 'A'; ch <= 'Z'; ch++) {
sb.append(ch);
}
for (char ch = '0'; ch <= '9'; ch++) {
sb.append(ch);
}
// 随机获取四位
Random r = new Random();
String code = "";
for (int i = 0; i < 4; i++) {
// 字符串中的字符有索引,随机获取一个索引即相当于随机获取到了该索引的字符
int index = r.nextInt(sb.length()); // 从索引0(包含)到字符串的长度(不包含)
code += sb.charAt(index); // 获取该索引上的字符
}
// 返回结果
return code;
}
}
题目7
在登录注册页面中,除了用户名和密码外,通常也会包含验证码。验证码是用来区分用户是计算机还是人,防止恶意破解密码、刷票、灌水等行为。在判断验证码时一般不区分大小写。请编写程序模拟验证码的判断过程,如果输入正确,给出提示,结束程序。如果输入错误,给出提示,验证码刷新,重新输入,直至正确为止。
生成4位随机验证码的功能在之前的题目中已经完成,可以直接使用。《定义方法,获取一个包含4个字符的验证码,每一位字符是随机选择的字母和数字,可包含a-z,A-Z,0-9。》
运行效果如下
生成的验证码为:BkhD
请输入验证码
abcd
输入错误,请重新输入...
生成的验证码为:n1wX
请输入验证码
aaaa
输入错误,请重新输入...
生成的验证码为:Fm1a
请输入验证码
fm1a
输入正确
操作步骤
1、定义方法,实现获取包含4个字符的随机验证码。(参考以前的练习)
2、创建键盘录入Scanner对象。
3、定义while循环,循环条件为true。
4、在循环内,获取程序生成的验证码,提示用户输入,调用Scanner对象的nextLine方法获取用户输入。
5、使用String的equalsIgnoreCase方法比较生成的验证码和用户输入,因为不区分大小写。
5.1、如果相等,给出输入正确的提示,使用break语句跳出循环。
5.2、如果不相等,给出输入错误的提示,继续下一次循环。
import java.util.Random;
import java.util.Scanner;
public class Test03 {
public static void main(String[] args) {
// 键盘录入对象
Scanner sc = new Scanner(System.in);
while (true) { // 不清楚输入多少次,定义死循环,输入正确时跳出即可。
String code = getRandomCode();
System.out.println("生成的验证码为:" + code);
System.out.println("请输入验证码");
String line = sc.nextLine();
// 不区分大小写比较是否相等
if (code.equalsIgnoreCase(line)) {
System.out.println("输入正确");
break; // 跳出循环,结束程序
} else {
System.out.println("输入错误,请重新输入...");
}
}
}
public static String getRandomCode() {
// 准备数据
StringBuilder sb = new StringBuilder();
for (char ch = 'a'; ch <= 'z'; ch++) {
sb.append(ch);
}
for (char ch = 'A'; ch <= 'Z'; ch++) {
sb.append(ch);
}
for (char ch = '0'; ch <= '9'; ch++) {
sb.append(ch);
}
// 随机获取四位
Random r = new Random();
String code = "";
for (int i = 0; i < 4; i++) {
// 字符串中的字符有索引,随机获取一个索引即相当于随机获取到了该索引的字符
int index = r.nextInt(sb.length()); // 从索引0(包含)到字符串的长度(不包含)
code += sb.charAt(index); // 获取该索引上的字符
}
// 返回结果
return code;
}
}
题目8
请编写程序,由键盘录入一个字符串,统计字符串中英文字母和数字分别有多少个。比如:Hello12345World中字母:10个,数字:5个。
操作步骤
1、创建键盘录入Scanner对象,使用nextLine方法接收输入的字符串。
2、为方便后续判断,使用String的toLowerCase方法,将字符串中的字符都转为小写。
3、需定义两个统计变量,初始值都为0
4、遍历字符串,得到每一个字符
5、判断该字符属于哪种类型,然后对应类型的统计变量+1,次数判断英文字母时只需判断小写即可。
import java.util.Scanner;
public class Test07 {
public static void main(String[] args) {
//键盘录入一个字符串,用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String line = sc.nextLine();
// 为方便统计,将字符串中的字母都转为小写
line = line.toLowerCase();
//要统计两种类型的字符个数,需定义两个统计变量,初始值都为0
int letterCount = 0;
int numberCount = 0;
// 遍历字符串,得到每一个字符
for(int i=0; i<line.length(); i++) {
char ch = line.charAt(i);
// 判断该字符属于哪种类型,然后对应类型的统计变量+1
if (ch >= 'a' && ch <= 'z') {
letterCount++;
} else if (ch >= '0' && ch <= '9') {
numberCount++;
}
}
//输出两种类型的字符个数
System.out.println("英文字母:" + letterCount + "个");
System.out.println("数字:" + numberCount + "个");
}
}
题目9
请定义一个方法用于判断一个字符串是否是对称的字符串,并在主方法中测试方法。例如:"abcba"、"上海自来水来自海上"均为对称字符串。
操作步骤
1、定义方法,返回值类型为boolean,参数列表为String类型的一个参数。
2、将字符串转换为StringBuilder类型,调用StringBuilder的reverse()方法将字符串反转。
3、将反转后的字符串再转回String类型,并与原字符串比较,如果相等,返回true,否则返回false
4、在主方法中,定义一个字符串,调用方法测试结果。
public class Test05 { public static void main(String[] args) { String str = "上海自来水来自海上"; System.out.println(isSym(str)); } public static boolean isSym(String str) { // 为了程序的健壮,如果传递的是空值,返回false if (str == null) { return false; } // 转换为StringBuilder StringBuilder sb = new StringBuilder(str); // 反转,再转成String String reStr = sb.reverse().toString(); // 比较与原字符串是否相等 // 相等返回true,不相等返回false,正好与equals的返回值一致,直接返回即可。 return reStr.equals(str); } }
题目10
我国的居民身份证号码,由由十七位数字本体码和一位数字校验码组成。请定义方法判断用户输入的身份证号码是否合法,并在主方法中调用方法测试结果。规则为:号码为18位,不能以数字0开头,前17位只可以是数字,最后一位可以是数字或者大写字母X。
操作步骤
1、定义方法,返回值类型为boolean表示是否合法,参数列表为String类型的id,表示要判断的数据。
2、对每种不符合条件的情况作出判断
2.1、如果字符串长度不是18,返回false。
2.2、如果字符串以数字"0"开头,返回false。
2.3、遍历字符串,获取每一位字符,判断前17位,如果不是数字,返回false,判断最后一位如果不是数字或者X,返回false
2.4、所以的不符合条件都筛选完成,返回true
3、在主方法中创建键盘录入Scanner对象,调用nextLine()方法,获取用户输入,调用方法,传递参数,查看结果。要多运行几次,判断各种不符合条件的数据。
import java.util.Scanner;
public class Test06 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入身份证号:");
String id = sc.nextLine();
System.out.println(check(id));
}
// 返回值boolean类型,表示是否符合规则。参数列表:需要判断的字符串
public static boolean check(String id) {
// 如果传递了空参数,返回false
if (id == null) {
return false;
}
// 如果是数字0开头,返回false
if (id.startsWith("0")) {
return false;
}
// 如果不是18位,返回false
if (id.length() != 18) {
return false;
}
// 遍历判断每一位
for (int i = 0; i < id.length(); i++) {
char ch = id.charAt(i);
// 前17位都是数字,最后一位可以是数字或者大写字母X
if (i == id.length() - 1) { // 最后一位
if (ch < '0' || ch > '9' && ch != 'X') { // 不是数字或者X
return false;
}
} else { // 其他位
if (ch < '0' || ch > '9') { // 不是数字
return false;
}
}
}
// 所有的规则都符合,返回true
return true;
}
}
题目11
定义一个方法,把 int 数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,并在控制台输出结果。
要求:
1、如果传递的参数为空,返回null
2、如果传递的数组元素个数为0,返回[]
3、如果数组为int[] arr = {1,2,3}; ,执行方法后的输出结果为:[1, 2, 3]
操作步骤
1、定义方法返回值类型:String,参数:int[] arr
2、判断对象如果为null,直接返回null
3、创建StringBuilder对象
4、遍历数组,按照要求进行拼接数组元素,如果是不是最后一个元素,还要拼接逗号和空格
5、将StringBuilder转为String返回
6、在主方法中定义数组,并调用方法,打印结果
public class Test07 {
public static void main(String[] args) {
// 定义一个 int 类型的数组,用静态初始化完成数组元素的初始化
int[] arr = {1, 2, 3};
// 调用方法,输出结果
System.out.println(arrayToString(arr));
}
/*定义一个方法,用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
返回值类型:String
参数:int[] arr
*/
public static String arrayToString(int[] arr) {
// 健壮性判断
if (arr == null) {
return null;
}
//在方法中用 StringBuilder 按照要求进行拼接,并把结果转成 String 返回
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
// 拼接元素
sb.append(arr[i]);
// 如果不是最后一个元素,再拼接逗号和空格
if (i != arr.length - 1) {
sb.append(", ");
}
}
sb.append("]");
return sb.toString();
}
}
题目12
在String类的API中,有如下两个方法:
// 查找参数字符串str在调用方法的字符串中第一次出现的索引,如果不存在,返回-1
public int indexOf(String str)// 截取字符串,从索引beginIndex(包含)开始到字符串的结尾
public String substring(int beginIndex)
请仔细阅读API中这两个方法的解释,完成如下需求。
现有如下文本:"Java语言是面向对象的,Java语言是健壮的,Java语言是安全的,Java是高性能的,Java语言是跨平台的"。请编写程序,统计该文本中"Java"一词出现的次数。
操作步骤
1、定义方法,返回值int表示次数,参数列表两个字符串,第一个表示在哪个字符串中查找,第二个表示要查找的目标子串
2、定义统计变量表示次数。
3、定义索引变量,表示每次找到子串出现的索引。
4、定义循环,判断条件为在字符串中找到了目标子串,使用indexOf实现。
5、如果找到的索引不是-1,在循环中,统计变量累加。
6、把查找过的部分剪切掉,从找到的索引+子串长度的位置开始截取,使用substring实现。
7、将统计变量返回
8、在主方法中,定义字符串表示题目中的文本,定义字符串表示要查找的子串,调用方法,获取结果。
public class Test08 {
public static void main(String[] args) {
String str = "Java语言是面向对象的,Java语言是健壮的,Java语言是安全的,Java是高性能的,Java语言是跨平台的";
String tar = "Java";
// 调用方法并输出
System.out.println(search(str, tar));
}
// 返回值int表示次数,参数列表str表示在哪个字符串中查找,tar表示要查找的目标子串
public static int search(String str, String tar) {
// 定义统计变量表示次数
int count = 0;
// 定义索引变量,表示每次找到子串出现的索引
int index = -1;
// 定义循环,判断条件为在字符串中找到了目标子串
while ((index = str.indexOf(tar)) != -1) { // 将找到的索引赋值给变量并判断
// 次数累加
count++;
// 把查找过的部分剪切掉,从找到的索引+子串长度的位置开始截取。
str = str.substring(index + tar.length());
}
return count;
}
}
题目13
现有如下字符串元素:["aaa", "bbb", "aaa", "aaa", "ccc", "bbb"],请将所有的元素按顺序存入ArrayList集合中,并遍历集合查看存储结果。
操作步骤
1、创建ArrayList集合对象,泛型声明为String类型
2、调用集合的add方法,将元素依次存入集合
3、遍历集合
3.1、定义循环,索引从0到集合的size-1
3.2、通过ArrayList集合的get方法,依次获取索引上的元素
public class Test01 {
public static void main(String[] args) {
// 创建集合对象
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("aaa");
list.add("bbb");
list.add("aaa");
list.add("aaa");
list.add("ccc");
list.add("bbb");
// 遍历集合
for (int i = 0; i < list.size(); i++) { // 索引从0到size-1
String element = list.get(i); // 根据索引获取元素
System.out.println(element);
}
}
}
题目14
请定义教师(Teacher)类,属性包含姓名和专业名称。将若干教师对象存入ArrayList集合中,并遍历集合打印教师信息,格式如下:
姓名:赵老师, 专业:javase
姓名:钱老师, 专业:javaee
姓名:孙老师, 专业:php
姓名:李老师, 专业:python
操作步骤
1、新建Teacher类,成员变量为String类型的name和course,私有修饰,提供构造方法,提供get和set方法。
2、创建ArrayList集合对象,泛型声明为Teacher类型
3、创建若干Teacher对象,可以使用构造方法为成员变量赋值,调用集合的add方法,将元素依次存入集合。
4、遍历集合
3.1、定义循环,索引从0到集合的size-1。
3.2、通过ArrayList集合的get方法,依次获取索引上的元素。
3.3、通过Teacher对象的get方法,获取属性值,拼接成要求的格式输出。
public class Teacher {
private String name; // 姓名
private String course; // 课程
public Teacher() {
}
public Teacher(String name, String course) {
this.name = name;
this.course = course;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
}
import java.util.ArrayList;
public class Test02 {
public static void main(String[] args) {
// 创建集合对象
ArrayList<Teacher> list = new ArrayList<>();
// 创建教师对象
Teacher t1 = new Teacher("赵老师", "javase");
Teacher t2 = new Teacher("钱老师", "javaee");
Teacher t3 = new Teacher("孙老师", "php");
Teacher t4 = new Teacher("李老师", "python");
// 添加元素
list.add(t1);
list.add(t2);
list.add(t3);
list.add(t4);
// 遍历
for (int i = 0; i < list.size(); i++) {
Teacher t = list.get(i);
System.out.println("姓名:" + t.getName() + ", 专业:" + t.getCourse());
}
}
}
题目15
有如下员工信息:
姓名:张三,工资:3000
姓名:李四,工资:3500
姓名:王五,工资:4000
姓名:赵六,工资:4500
姓名:田七,工资:5000先需要将所有的员工信息都存入ArrayList集合中,并完成如下操作:
1、判断是否有姓名为“王五”的员工,如果有,改名为“王小五”
2、判断是否有姓名为“赵六”的员工,如果有,将其删除
3、给姓名为“田七”的员工,涨500工资
操作步骤
1、定义员工类Worker,私有属性name和salary,分别为String和int类型,表示姓名和工资,提供构造、get、set方法
2、创建ArrayList集合,泛型为Worker类型,创建员工对象,将所有员工对象存入集合
3、使用for循环遍历集合,获取到每一个元素。
3.1、判断元素的name属性,如果符合条件,作出相应的修改或者删除。
3.2、遍历时如果删除元素,后面的元素会往前走,索引再加1就会有元素遗漏,所以删除后遍历索引要相应的减1,防止有元素遍历不到。
public class Worker {
private String name;
private int salary;
public Worker() {
}
public Worker(String name, int salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
}
import java.util.ArrayList;
public class Test03 {
public static void main(String[] args) {
// 创建集合对象
ArrayList<Worker> list = new ArrayList<>();
// 创建员工对象并添加到集合中
list.add(new Worker("张三", 2000));
list.add(new Worker("李四", 2500));
list.add(new Worker("王五", 3000));
list.add(new Worker("赵六", 3500));
list.add(new Worker("田七", 4000));
// 判断是否有王五,如果有,改名为王小五
// 判断是否有赵六,如果有,删除赵六
// 给田七加500块工资
for (int i = 0; i < list.size(); i++) {
Worker w = list.get(i);
if ("王五".equals(w.getName())) {
w.setName("王小五");
list.set(i, w);
}
if ("赵六".equals(w.getName())) {
// 注意,一旦删除元素,后面的元素会往前走,索引再加1就会有元素遗漏,所以删除后要--
list.remove(i--);
}
if ("田七".equals(w.getName())) {
w.setSalary(w.getSalary() + 500);
list.set(i, w);
}
}
// 再次遍历查看结果
for (int i = 0; i < list.size(); i++) {
Worker w = list.get(i);
System.out.println(w.getName() + "---" + w.getSalary());
}
}
}
题目16
利用面向对象的思想设计一个图书管理系统。图书的属性有:编号,书名,作者,价格。要求提供如下功能:
1、提供操作菜单,可以选择要进行的操作。
2、可以添加图书,添加图书时,编号需要唯一,添加成功,返回到菜单。
3、可以查询图书,显示所有图书信息,然后返回到菜单。
4、可以根据书名,查询单本图书信息,显示信息后,返回到菜单。
5、可以删除图书,通过编号删除,删除成功后,返回到菜单。
6、可以修改图书的信息,但编号不可以修改,修改成功后,返回到菜单。
7、可以退出系统,结束程序运行。
提示:
1、所有图书信息由键盘录入
2、图书的价格可以定义为字符串类型,因为在键盘录入时,不可以先使用nextInt()方法获取整数然后再使用nextLine()方法获取字符串,这样会导致nextLine()方法获取不到数据。
操作步骤
1、创建Book类,属性String类型的id,name,author,price。提供构造方法、get和set方法。
2、创建测试类Test04,在main方法中,创建键盘录入对象,创建ArrayList集合对象用于存储图书。
3、使用输出语句定义一个操作菜单,包含添加、查看全部、查看单个、修改、查询、退出功能,使用switch语句对键盘录入的菜单项进行判断。
4、定义方法实现判断id是否已经存在。方法返回值boolean类型,参数列表为集合ArrayList和要查找的id字符串。遍历集合,判断id是否与集合中的Book对象的id相同,如果有相同,返回true,否则返回false
5、定义方法实现添加功能。方法返回值void,参数列表为集合ArrayList。在方法中,先使用键盘录入获取用户录入的id信息,调用方法判断id是否存在,如果存在,重新录入,如果不存在,再依次获取图书的其他信息,创建图书对象,并将图书对象存入集合中,输出添加成功的提示。
6、定义方法实现查看所有图书。方法返回值void,参数列表为集合ArrayList。如果集合长度为0,给出提示,结束方法,否则遍历集合,获取每个图书对象,再调用对象的get方法,获取所有信息展示即可。
7、定义方式实现根据名称查看一本图书。方法返回值void,参数列表为集合ArrayList。键盘录入图书的名称,遍历集合,获取每个图书的名称信息进行比较,如果相同,输出该图书信息,结束方法。否则输出不存在该图书。
8、定义方法实现根据编号修改图书信息。方法返回值void,参数列表为集合ArrayList。键盘录入图书编号,查询该编号是否存在,如果存在,再依次录入图书的修改后信息,创建新的图书对象,存入集合,将原对象覆盖,给出成功的提示,否则提示该编号图书不存在。
9、定义方法实现根据编号删除图书信息。方法返回值void,参数列表为集合ArrayList。键盘录入图书编号,查询该编号是否存在,如果存在,根据索引删除该对象,返回成功的提示,否则提示该编号的图书不存在。
10、退出系统的功能直接调用System的exit方法实现即可。
public class Book {
private String bookId;
private String name;
private String author;
private String price;
public Book() {
}
public Book(String bookId, String name, String author, String price) {
this.bookId = bookId;
this.name = name;
this.author = author;
this.price = price;
}
public String getBookId() {
return bookId;
}
public void setBookId(String bookId) {
this.bookId = bookId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getPrice() {
return price;
}
public void setPrice(String price) {
this.price = price;
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
// 创建集合用于存储图书信息
ArrayList<Book> list = new ArrayList<>();
// 键盘录入
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请选择你要进行的操作");
System.out.println("1:添加图书");
System.out.println("2:查看图书");
System.out.println("3:查询图书");
System.out.println("4:修改图书");
System.out.println("5:删除图书");
System.out.println("6:退出系统");
String type = sc.nextLine();
switch (type) {
case "1":
// 添加
addBook(list);
break;
case "2":
// 查看所有图书
findAllBooks(list);
break;
case "3":
// 查询某本图书
findBookByName(list);
break;
case "4":
// 修改图书
updateBook(list);
break;
case "5":
// 删除图书
deleteBook(list);
break;
case "6":
System.out.println("感谢使用,再见");
System.exit(0); // 退出系统
default:
System.out.println("选择有误,请重新输入");
break;
}
}
}
// 删除图书
private static void deleteBook(ArrayList<Book> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要删除的图书编号:");
String id = sc.nextLine();
for (int i = 0; i < list.size(); i++) {
Book b = list.get(i);
if (id.equals(b.getBookId())) { // 编号存在
// 删除图书并结束方法
list.remove(i);
System.out.println("~~~删除成功~~~");
return;
}
}
System.out.println("没有该编号的图书信息");
}
// 修改图书
private static void updateBook(ArrayList<Book> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要修改的图书编号:");
String id = sc.nextLine();
for (int i = 0; i < list.size(); i++) {
Book b = list.get(i);
if (id.equals(b.getBookId())) { // 编号存在
System.out.println("请输入修改后图书的名称:");
String name = sc.nextLine();
System.out.println("请输入修改后图书的作者:");
String author = sc.nextLine();
System.out.println("请输入修改后图书的价格:");
String price = sc.nextLine();
Book newBook = new Book(id, name, author, price);
// 更新数据
list.set(i, newBook);
System.out.println("~~~修改成功~~~");
return;
}
}
// 如果编号不存在
System.out.println("没有该编号的图书信息");
}
// 根据图书的名称查询图书信息
private static void findBookByName(ArrayList<Book> list) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要查询的图书名称:");
String name = sc.nextLine();
for (int i = 0; i < list.size(); i++) {
Book b = list.get(i);
if (name.equals(b.getName())) {
System.out.println("编号\t" + "书名\t" + "作者\t" + "价格");
System.out.println(b.getBookId() + "\t" + b.getName() + "\t" + b.getAuthor() + "\t" + b.getPrice());
return;
}
}
System.out.println("没有该名称图书信息");
}
// 查看所有图书信息
private static void findAllBooks(ArrayList<Book> list) {
if (list == null || list.size() == 0) {
System.out.println("尚无图书信息");
return;
}
System.out.println("编号\t" + "书名\t" + "作者\t" + "价格");
for (int i = 0; i < list.size(); i++) {
Book b = list.get(i);
System.out.println(b.getBookId() + "\t" + b.getName() + "\t" + b.getAuthor() + "\t" + b.getPrice());
}
}
// 查询编号是否存在
public static boolean isExist(ArrayList<Book> list, String bookId) {
// 遍历,如果发现相同id,返回true,
for (int i = 0; i < list.size(); i++) {
if (bookId.equals(list.get(i).getBookId())) {
return true;
}
}
// 如果没有,返回false
return false;
}
// 添加图书
public static void addBook(ArrayList<Book> list) {
// 键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入图书信息:");
System.out.println("编号:");
String bookId;
while (true) {
bookId = sc.nextLine();
// 查询编号是否存在
if (isExist(list, bookId)) {
System.out.println("该编号已经存在,请重新输入");
} else {
break;
}
}
System.out.println("名称:");
String name = sc.nextLine();
System.out.println("作者:");
String author = sc.nextLine();
System.out.println("价格:");
String price = sc.nextLine();
// 将信息封装到图书对象
Book b = new Book(bookId, name, author, price);
// 添加到集合
list.add(b);
System.out.println("~~~添加成功~~~");
}
}