Java学习笔记（新手纯小白向）
第一章 JAVA基础概念
第二章 JAVA安装和环境配置
第三章 IntelliJ IDEA安装
第四章 运算符
第五章 运算符联系
第六章 判断与循环
第七章 判断与循环练习
第八章 循环高级综合
第九章 数组介绍及其内存图
第十章 数组基础练习
第十一章 方法基础及简单应用
第十二章 方法基础练习
第十三章 前续知识综合练习
第十四章 面向对象基础
第十五章 面向对象综合训练
目录
十、Variable is already assigned to this value报错
前言
本篇章主要展示了面向对象知识板块的一些练习题目及细小知识的补充和本人在本次编程练习中出现的一些报错的解决方法
一、文字版格斗游戏
1.需求
格斗游戏，每个游戏角色的姓名、血量都不相同。在选定人物的时候（new对象的时候），这些信息就应该被确定下来。
2.参考答案
public class Role {
//定义成员变量，表示游戏角色的属性
private String name;
private int blood;
//空参构造
public Role() {
}
//带参构造
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
//定义方法用于攻击别人
public void attack(Role role) {
//计算造成的伤害
Random r = new Random();
//定义局部变量hurt，存储伤害值
int hurt = r.nextInt(20) + 1;
//定义变量remainBlood，存储被打的人的剩余血量
int remainBlood = role.getBlood() - hurt;
//对剩余血量进行判断，并修改被打的人的血量
remainBlood = remainBlood < 0 ? 0 : remainBlood;
role.setBlood(remainBlood);
//this表示方法调用者
System.out.println(this.getName() + "举起拳头，打了" + role.getName() + "一下，" +
"造成了" + hurt + "点伤害，" + role.getName() + "还剩下了" + remainBlood + "点血");
}
}public class BattleTest {
//文字版格斗游戏
//格斗游戏，每个游戏角色的姓名、血量都不相同
//在选定人物的时候（new对象的时候），这些信息就应该被确定下来
public static void main(String[] args) {
//创建对象，表示选定人物
Role player1 = new Role("乔峰", 100);
Role player2 = new Role("鸠摩智", 100);
//开始格斗
while (true) {
//player1攻击player2
player1.attack(player2);
//player2攻击player1
player2.attack(player1);
//有一个角色死了，游戏就结束
if (player2.getBlood() == 0) {
System.out.println(player1.getName() + "KO了" + player2.getName());
break;
} else if (player1.getBlood() == 0) {
System.out.println(player2.getName() + "KO了" + player1.getName());
break;
}
}
}
}二、文字版格斗游戏（进阶）
1.参考答案
public class Role01 {
//定义成员变量，表示游戏角色的属性
private String name;
private int blood;
private char gender;
private String appearence;//长相是随机的
//定义长相静态数组
String[] manAppearence = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
String[] womanAppearence = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};
//attack 攻击描述：
String[] attacks_desc = {
"%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
"%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
"%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
"%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
"%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
"%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"
};
//injured 受伤描述：
String[] injureds_desc = {
"结果%s退了半步，毫发无损",
"结果给%s造成一处瘀伤",
"结果一击命中，%s痛得弯下腰",
"结果%s痛苦地闷哼了一声，显然受了点内伤",
"结果%s摇摇晃晃，一跤摔倒在地",
"结果%s脸色一下变得惨白，连退了好几步",
"结果『轰』的一声，%s口中鲜血狂喷而出",
"结果%s一声惨叫，像滩软泥般塌了下去"
};
//空参构造
public Role01() {
}
//带参构造
public Role01(String name, int blood, char gender) {
this.name = name;
this.blood = blood;
this.gender = gender;
setAppearence(gender);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getAppearence() {
return appearence;
}
public void setAppearence(char gender) {
//随机产生长相数组索引，赋值给调用者
Random r = new Random();
if (gender == '男') {
int index = r.nextInt(manAppearence.length);
this.appearence = manAppearence[index];
} else if (gender == '女') {
int index = r.nextInt(womanAppearence.length);
this.appearence = womanAppearence[index];
} else {
this.appearence = "面目狰狞";
}
}
//定义方法用于攻击别人
public void attack(Role01 role) {
Random r = new Random();
//随机武功招式
int movement = r.nextInt(attacks_desc.length);
System.out.printf(attacks_desc[movement], this.getName(), role.getName());
System.out.println();
//定义局部变量hurt，存储伤害值
int hurt = r.nextInt(20) + 1;
//定义变量remainBlood，存储被打的人的剩余血量
int remainBlood = role.getBlood() - hurt;
//对剩余血量进行判断，并修改被打的人的血量
remainBlood = remainBlood < 0 ? 0 : remainBlood;
role.setBlood(remainBlood);
//根据剩余血量，判断受伤效果
if (remainBlood > 90) {
System.out.printf(injureds_desc[0], role.getName());
} else if (remainBlood > 80) {
System.out.printf(injureds_desc[1], role.getName());
} else if (remainBlood > 70) {
System.out.printf(injureds_desc[2], role.getName());
} else if (remainBlood > 60) {
System.out.printf(injureds_desc[3], role.getName());
} else if (remainBlood > 40) {
System.out.printf(injureds_desc[4], role.getName());
} else if (remainBlood > 20) {
System.out.printf(injureds_desc[5], role.getName());
} else if (remainBlood > 10) {
System.out.printf(injureds_desc[6], role.getName());
} else {
System.out.printf(injureds_desc[7], role.getName());
}
System.out.println();
}
//定义方法，展示角色的信息
public void showInfo() {
System.out.println("姓名为：" + getName());
System.out.println("性别为：" + getGender());
System.out.println("长相为：" + getAppearence());
System.out.println("血量为：" + getBlood());
}
}public class Battle01 {
public static void main(String[] args) {
//选择角色
Role01 player1 = new Role01("乔峰", 100, '男');
Role01 player2 = new Role01("鸠摩智", 100, '男');
//开始格斗
while (true) {
//player1攻击player2
player1.attack(player2);
//player2攻击player1
player2.attack(player1);
//有一个角色死了，游戏就结束
if (player2.getBlood() == 0) {
System.out.println(player1.getName() + "KO了" + player2.getName());
break;
} else if (player1.getBlood() == 0) {
System.out.println(player2.getName() + "KO了" + player1.getName());
break;
}
}
}
}三、商品对象数组
1.需求
定义数组存储3个商品对象。商品属性：商品的id、名字、价格、库存。创建三个商品对象，并把商品对象存入到数组中。
2.参考答案
public class Commodity {
//定义商品的属性
private String id;
private String name;
private double price;
private int inventory;
//定义空参构造
public Commodity() {
}
//定义带参构造
public Commodity(String id, String name, double price, int inventory) {
this.id = id;
this.name = name;
this.price = price;
this.inventory = inventory;
}
//提供成员变量对应的get和set方法
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getInventory() {
return inventory;
}
public void setInventory(int inventory) {
this.inventory = inventory;
}
}public class CommodityTest {
//对象数组1
//定义数组存储3个商品对象
//商品属性：商品的id、名字、价格、库存
//创建三个商品对象，并把商品对象存入到数组中
public static void main(String[] args) {
//定义动态数组，存储商品对象
Commodity[] commodity = new Commodity[3];
//创建商品对象
Commodity commodity1 = new Commodity("001", "华为P40", 5999.0, 100);
Commodity commodity2 = new Commodity("002", "保温杯", 227.0, 50);
Commodity commodity3 = new Commodity("003", "枸杞", 12.7, 70);
//将商品对象存入数组中
commodity[0] = commodity1;
commodity[1] = commodity2;
commodity[2] = commodity3;
//遍历获得商品信息
for (int i = 0; i < commodity.length; i++) {
Commodity goods = commodity[i];
System.out.println(goods.getId() + "," + goods.getName() + "," + goods.getPrice() + "," + goods.getInventory());
}
}
}四、汽车对象数组
1.需求
定义数组存储3部汽车对象。汽车的属性：品牌、价格、颜色。创建3个汽车对象，数据通过键盘录入而来，并把数据存储到数组当中。
2.参考答案
public class Car {
//定义汽车的属性
private String brand;
private double price;
private String color;
//定义空参构造
public Car() {
}
//定义带参构造
public Car(String brand, double price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
//提供每个属性的get和set方法
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}public class CarTest {
//定义数组存储3部汽车对象
//汽车的属性：品牌、价格、颜色
//创建3个汽车对象，数据通过键盘录入而来，并把数据存储到数组当中
public static void main(String[] args) {
//定义动态数组存储3部汽车对象
Car[] cars = new Car[3];
//通过键盘录入汽车对象的数据
//创建3个汽车对象，并加入数组
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.print("请输入第" + (i + 1) + "辆汽车的品牌：");
String brand = sc.next();
System.out.print("请输入第" + (i + 1) + "辆汽车的价格：");
double price = sc.nextDouble();
System.out.print("请输入第" + (i + 1) + "辆汽车的颜色：");
String color = sc.next();
cars[i] = new Car(brand, price, color);
}
//遍历数组
for (int i = 0; i < cars.length; i++) {
Car car = cars[i];
System.out.println("品牌：" + car.getBrand() + "," + "价格：" + car.getPrice() + "," + "颜色：" + car.getColor());
}
}
}五、手机对象数组
1.需求
定义数组存储3部手机对象。手机的属性：品牌、价格、颜色。要求，计算出三部手机的平均价格。
2.参考答案
public class Phone {
//定义手机的属性
private String brand;
private double price;
private String color;
//定义空参构造
public Phone() {
}
//定义带参构造
public Phone(String brand, double price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
//提供各成员变量的get和set方法
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}public class PhoneTest {
//定义数组存储3部手机对象
//手机的属性：品牌、价格、颜色
//要求，计算出三部手机的平均价格
public static void main(String[] args) {
//定义动态数组，存储手机对象
Phone[] phones = new Phone[3];
//创建手机对象，将手机对象加入数组，并计算其总价格
Phone phone1 = new Phone("小米", 1999.0, "白色");
Phone phone2 = new Phone("华为", 4999.0, "蓝色");
Phone phone3 = new Phone("魅族", 3999.0, "红色");
phones[0] = phone1;
phones[1] = phone2;
phones[2] = phone3;
//定义变量sum，记录总价格
double sum = 0;
for (int i = 0; i < phones.length; i++) {
sum = sum + phones[i].getPrice();
}
//定义变量mean，记录其平均价格
double mean = sum / phones.length;
System.out.println("3部手机的平均价格为：" + mean);
}
}六、女朋友对象数组
1.需求
定义数组存储4个女朋友的对象。女朋友的属性：姓名、年龄、性别、爱好。要求1：计算出四女朋友的平均年龄。要求2：统计年龄比平均值低的女朋友有几个?并把她们的所有信息打印出来。
2.参考答案
public class GirlFriend {
//定义女朋友的属性
private String name;
private int age;
private char gender;
private String hobby;
//定义空参构造和带参构造
public GirlFriend() {
}
public GirlFriend(String name, int age, char gender, String hobby) {
this.name = name;
this.age = age;
this.gender = gender;
this.hobby = hobby;
}
//提供所有成员变量的get和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}public class GirlFriendTest {
//定义数组存储4个女朋友的对象
//女朋友的属性：姓名、年龄、性别、爱好
//要求1：计算出四女朋友的平均年龄
//要求2：统计年龄比平均值低的女朋友有几个?并把她们的所有信息打印出来
public static void main(String[] args) {
//定义动态数组，存储4个女朋友的对象
GirlFriend[] girls = new GirlFriend[4];
//创建女朋友的对象，将其加入数组
GirlFriend g1 = new GirlFriend("春", 18, '女', "抽烟");
GirlFriend g2 = new GirlFriend("夏", 19, '女', "喝酒");
GirlFriend g3 = new GirlFriend("秋", 20, '女', "烫头");
GirlFriend g4 = new GirlFriend("冬", 27, '女', "美容");
girls[0] = g1;
girls[1] = g2;
girls[2] = g3;
girls[3] = g4;
//调用方法getMean，打印女朋友的平均年龄
double meanAge = getMean(girls);
System.out.println("女朋友的平均年龄为：" + meanAge);
System.out.println();
//调用方法getCount，统计年龄比平均值低的女朋友的数量，并把她们的所有信息打印出来
int girlCount = getCount(meanAge, girls);
System.out.println("年龄比平均值低的女朋友的数量为：" + girlCount);
}
//定义方法getMean，计算女朋友的平均年龄
public static double getMean(GirlFriend[] girlFriends) {
//定义变量sum，记录总年龄
int sum = 0;
for (int i = 0; i < girlFriends.length; i++) {
sum = sum + girlFriends[i].getAge();
}
//定义变量mean,记录其平均年龄
double mean = sum / girlFriends.length;
return mean;
}
//定义方法getCount,记录年龄比平均值低的女朋友的数量，并把她们的所有信息打印出来
public static int getCount(double mean, GirlFriend[] girlFriends) {
//定义变量count,记录年龄比平均值低的女朋友的数量
int count = 0;
//遍历数组，比较年龄
for (int i = 0; i < girlFriends.length; i++) {
//定义变量girlFriend，调用数组中的女朋友对象
GirlFriend girlFriend = girlFriends[i];
if (girlFriend.getAge() < mean) {
count++;
System.out.println("第" + (i + 1) + "位女朋友的年龄比平均值低");
System.out.println("姓名：" + girlFriend.getName() + "，" + "年龄：" + girlFriend.getAge() + "，" + "性别：" + girlFriend.getGender() + "，" + "爱好：" + girlFriend.getHobby());
System.out.println();
}
}
return count;
}
}七、学生对象数组
1.需求
定义长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号、姓名各不相同。学生的属性：学号、姓名、年龄。要求：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。添加完毕后，遍历学生的所有信息。通过id删除学生信息。如果存在，则删除；如果不存在，则提示删除失败。删除完毕后，遍历所有学生信息。查询数组id为“heima002”的学生，如果存在，则将他的年龄+1岁。
2.参考答案
public class Student {
//定义学生的属性
private int studentId;
private String name;
private int age;
//定义空参构造和带参构造
public Student() {
}
public Student(int studentId, String name, int age) {
this.studentId = studentId;
this.name = name;
this.age = age;
}
//提供各成员变量的get和set方法
public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//定义方法，遍历所有学生信息
//传入形参students代表学生对象数组
public static void getStuInfo(Student[] students) {
for (int i = 0; i < students.length; i++) {
if (students[i] != null) {
System.out.println("学生" + (i + 1) + "：学号：" + students[i].getStudentId() + ";" +
"姓名：" + students[i].getName() + ";" + "年龄：" + students[i].getAge());
}
}
}
//定义方法studentId_Judge，进行学号是否已存在的判断，即学号的唯一性判断
//传入形参students代表已存在的学生对象的数组，student代表要做修改的学生对象
public static boolean studentId_Judge(Student[] students, Student student) {
//定义变量result，记录判断结果,默认不存在新添加或要删除的学生的学号
boolean result = true;
//定义变量judgeId，记录新添加或要删除的学生的学号，即要判断的学号
int judgeId = student.getStudentId();
//遍历已有的学生数组，定义变量Id，记录之前存在的学号
for (int i = 0; i < students.length; i++) {
int Id = students[i].getStudentId();
if (judgeId == Id) {
System.out.println("存在该学号！！！");
result = false;
break;
}
}
if (result) {
System.out.println("无该学号！！！");
}
return result;
}
//定义方法appendStu，添加学生对象
//传入形参students代表已存在的学生对象的数组，student代表要添加的学生对象
public static Student[] appendStu(Student[] students, Student student) {
//根据学号的唯一性判断结果，判断是否做添加
//定义变量judege，记录学号是否存在的判断结果
boolean judege = studentId_Judge(students, student);
if (judege) {
//判断数组中已经存了几个元素。若没有存满，则直接存
//定义变量count，记录存了几个元素
int count = 0;
for (int i = 0; i < students.length; i++) {
if (students[i] == null) {
students[i] = student;
break;
} else {
count++;
}
}
//若已存满，则定义一个新数组来存
if (count == students.length) {
//定义数组，存储添加学生后的所有学生对象
Student[] newStus = new Student[students.length + 1];
//遍历已存在的学生对象的数组，将要添加的学生对象加在数组末尾
for (int i = 0; i < students.length; i++) {
newStus[i] = students[i];
}
newStus[newStus.length - 1] = student;
students = newStus;
}
System.out.println("添加成功！！！");
} else {
System.out.println("添加失败！！！");
}
return students;
}
//定义方法deleteStu，通过id删除学生信息
//传入形参students代表已存在的学生对象的数组，student代表要删除的学生对象
public static Student[] deleteStu(Student[] students, Student student) {
//定义变量judege，记录学号是否存在的判断结果
boolean judege = studentId_Judge(students, student);
//定义数组，存储删除学生后的所有学生对象
Student[] newStus = new Student[students.length - 1];
//进行判断。如果存在，则删除；如果不存在，则提示删除失败
if (judege) {
System.out.println("删除失败！！！");
} else {
//定义变量judgeId，记录要删除的学生的学号
int judgeId = student.getStudentId();
//遍历已有的学生数组
for (int i = 0, j = 0; i < students.length; i++) {
//进行非空判断
if (students[i] != null) {
//定义变量Id，记录之前存在的学号
int Id = students[i].getStudentId();
if (judgeId == Id) {
continue;
} else {
newStus[j] = students[i];
j++;
}
}
}
System.out.println("删除成功！！！");
students = newStus;
}
return students;
}
//定义方法modifyAge，查询数组id为某一值的学生，如果存在，则将他的年龄+1岁
//传入形参students代表已存在的学生对象的数组，student代表要做修改的学生对象
public static Student[] modifyAge(Student[] students, Student student) {
//定义变量judege，记录学号是否存在的判断结果
boolean judege = studentId_Judge(students, student);
//进行判断。如果存在，则将他的年龄+1岁
if (judege) {
System.out.println("不存在该学生！！！");
} else {
//定义变量judgeId，记录要修改年龄的学生的学号
int judgeId = student.getStudentId();
//遍历已有的学生数组，定义变量Id，记录之前存在的学号
for (int i = 0; i < students.length; i++) {
int Id = students[i].getStudentId();
if (judgeId == Id) {
students[i].setAge(students[i].getAge() + 1);
break;
}
}
}
System.out.println("已成功修改！！！");
return students;
}
}public class StudentTest {
//定义长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号、姓名各不相同
//学生的属性：学号、姓名、年龄
//要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断
//添加完毕后，遍历学生的所有信息
//通过id删除学生信息。如果存在，则删除；如果不存在，则提示删除失败
//删除完毕后，遍历所有学生信息
//查询数组id为“heima002”的学生，如果存在，则将他的年龄+1岁
public static void main(String[] args) {
//定义长度为3的数组，数组存储学生对象
Student[] students = new Student[3];
//创建学生对象，并加入数组
Student student1 = new Student(1, "刘备", 18);
Student student2 = new Student(2, "关羽", 19);
Student student3 = new Student(3, "张飞", 20);
students[0] = student1;
students[1] = student2;
students[2] = student3;
//添加学生对象，并遍历
Student student4 = new Student(4, "赵云", 21);
students = Student.appendStu(students, student4);
Student.getStuInfo(students);
//删除学生对象，并遍历
students = Student.deleteStu(students, student1);
Student.getStuInfo(students);
//查询id为2的学生对象，如果存在，则将他的年龄+1岁
students = Student.modifyAge(students, student2);
Student.getStuInfo(students);
}
}八、键盘录入小知识
键盘录入代码有两套体系，第一套为最常用的，我们之前的练习只使用了第一套体系中的一部分。
1.第一套体系
nextInt(); //接收整数
nextDouble(); //接收小数
next(); //接收字符串
//遇到空格、制表符、回车就停止接收。这些符号后面的数据就不会接收了2.第二套体系
nextLine(); //接收字符串
//可以接收空格、制表符，遇到回车才停止接收数据3.注意
键盘录入的两套体系不能混用。
弊端：先用nextInt，再用nextLine会导致下面的nextLine接收不到数据
九、Octal integer报错
octal literals八进制：java中0开头的数据被当成八进制
decimal literals 十进制
发生数据进制问题导致的数据错误问题
IDEA在数字上报黄色警告如下 nspection info: Reports octal integer literals. Some coding standards prohibit the use of octal literals, as they may be easily confused with decimal literals.
即以0开头的数据会被当作八进制，所以011存进去就变成了9。因此0后面跟大于7的数字会报错（八进制数据范围只有0到7）。所以，数值最好别写0开头，一定要存01、02的可以用字符串类型存储，避免数据因为进制问题产生错误。
PS:以0x开头的数值是16进制，数据范围为0到f（0-9，a-f)。
十、Variable is already assigned to this value报错
接收的参数已经获得了这个值，不需要再写一次 “变量名=”。（无伤大雅，不影响运行）
总结
在了解了面向对象的基础知识并进行一些简单练习后，一定要自己独立动手练习代码，为以后的进阶打好基础。
293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
