>[danger] ##### 文字版格斗游戏
* 需求:格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。
* 举例：
程序运行之后结果为：
姓名为:乔峰 血量为:100
姓名为:鸠摩智 血量为:100
乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。
鸠摩智举起拳头打了鸠摩智一下，造成了XX点伤害，乔峰还剩下XXX点血。
乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。
鸠摩智举起拳头打了鸠摩智一下，造成了XX点伤害，乔峰还剩下XXX点血。
乔峰K.O.了鸠摩智
* **小知识点`printf` 可以用 `%s` 进行占位**
*****
* Role 创建角色类
~~~
import java.util.Random;
public class Role {
private String name; // 名字
private int blood; // 血量
private char gender; // 性别
private String face;// 长相是随机的
// 男的长相
String[] boyfaces = { "风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞" };
// 女生长相
String[] girlfaces = { "美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹" };
// 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 Role() {
}
public Role(String name, int blood, char gender) {
this.name = name;
this.blood = blood;
this.gender = gender;
this.setFace(gender);
}
public String getFace() {
return face;
}
public void setFace(char gender) {
Random r = new Random();
if (gender == '女') {
int index = r.nextInt(girlfaces.length);
this.face = girlfaces[index];
} else if (gender == '男') {
int index = r.nextInt(boyfaces.length);
this.face = boyfaces[index];
} else {
this.face = "面目狰狞";
}
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.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 void showRoleInfo() {
System.out.printf("姓名为%s 血量为%s 性别为%s 长相为 %s", getName(), getBlood(), getGender(), getFace());
System.out.println();
}
// 定义一个攻击方法
// 要攻击的是对方因此 需要参数知道攻击 对象
public void attack(Role role) {
// 随机扣除对方血量
Random r = new Random();
// 随机释放招数
int index = r.nextInt(attacks_desc.length);
String KungFu = attacks_desc[index];
// 输出一个攻击的效果
System.out.printf(KungFu, this.getName(), role.getName());
System.out.println();
// 计算造成的伤害 1 ~ 20
int hurt = r.nextInt(20) + 1;
// 剩余血量
int remainBoold = role.getBlood() - hurt;
// 对剩余血量做一个验证，如果为负数了，就修改为0
remainBoold = remainBoold < 0 ? 0 : remainBoold;
// 修改一下挨揍的人的血量
role.setBlood(remainBoold);
// 受伤的描述
// 血量> 90 0索引的描述
// 80 ~ 90 1索引的描述
// 70 ~ 80 2索引的描述
// 60 ~ 70 3索引的描述
// 40 ~ 60 4索引的描述
// 20 ~ 40 5索引的描述
// 10 ~ 20 6索引的描述
// 小于10的 7索引的描述
if (remainBoold > 90) {
System.out.printf(injureds_desc[0], role.getName());
} else if (remainBoold > 80 && remainBoold <= 90) {
System.out.printf(injureds_desc[1], role.getName());
} else if (remainBoold > 70 && remainBoold <= 80) {
System.out.printf(injureds_desc[2], role.getName());
} else if (remainBoold > 60 && remainBoold <= 70) {
System.out.printf(injureds_desc[3], role.getName());
} else if (remainBoold > 40 && remainBoold <= 60) {
System.out.printf(injureds_desc[4], role.getName());
} else if (remainBoold > 20 && remainBoold <= 40) {
System.out.printf(injureds_desc[5], role.getName());
} else if (remainBoold > 10 && remainBoold <= 20) {
System.out.printf(injureds_desc[6], role.getName());
} else {
System.out.printf(injureds_desc[7], role.getName());
}
System.out.println();
}
}
~~~
* 游戏执行类
~~~
public class GameTest {
public static void main(String[] args) {
Role r1 = new Role("乔峰", 100, '男');
// 2.创建第二个角色
Role r2 = new Role("鸠摩智", 100, '男');
// 展示一下角色的信息
r1.showRoleInfo();
r2.showRoleInfo();
// 开始对打
while (true) {
r1.attack(r2);
// 如果血量没有了 说明结束
if (r2.getBlood() == 0) {
System.out.println(r1.getName() + " K.O了" + r2.getName());
break;
}
// r2开始攻击r1
r2.attack(r1);
if (r1.getBlood() == 0) {
System.out.println(r2.getName() + " K.O了" + r1.getName());
break;
}
}
}
}
~~~
>[danger] ##### 创建数组将商品对象保存
* 需求：
定义数组存储3个商品对象。
商品的属性：商品的id，名字，价格，库存。
创建三个商品对象，并把商品对象存入到数组当中。
~~~
public class Goods {
private String name;
private double price;
private int count;
public Goods(String name, double price, int count) {
this.name = name;
this.price = price;
this.count = count;
}
public Goods() {
}
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 getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
~~~
* 打印商品
~~~
public class GoodsTest {
public static void main(String[] args) {
Goods g1 = new Goods("手机", 1200, 2);
Goods g2 = new Goods("汽车", 120000, 2);
Goods g3 = new Goods("飞机", 12000010, 12);
// 创建数组容器
Goods[] goodsLs = new Goods[3];
goodsLs[0] = g1;
goodsLs[1] = g2;
goodsLs[2] = g3;
// 打印商品
for (int i = 0; i < goodsLs.length; i++) {
Goods goods = goodsLs[i];
System.out.println(goods.getName() + goods.getPrice() + " " + goods.getCount());
}
}
}
~~~
>[danger] ##### 手动录入商品
* 需求：
定义数组存储3部汽车对象。
汽车的属性：品牌，价格，颜色。
创建三个汽车对象，数据通过键盘录入而来，并把数据存入到数组当中。
要求，计算出最后的平均价格
~~~
public class Car {
private String brand;// 品牌
private int price;// 价格
private String color;// 颜色
public Car(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
public Car() {
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
~~~
* 保存Car
~~~
import java.util.Scanner;
public class CarTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Car[] carLs = new Car[3];
for (int i = 0; i < carLs.length; i++) {
Car car = new Car();
System.out.println("请输入汽车的品牌");
String brand = sc.next();
car.setBrand(brand);
System.out.println("请输入汽车的价格");
int price = sc.nextInt();
car.setPrice(price);
System.out.println("请输入汽车的颜色");
String color = sc.next();
car.setColor(color);
carLs[i] = car; // 保存到数组中
}
// 计算平均加个
int sum = 0;
for (int i = 0; i < carLs.length; i++) {
sum += carLs[i].getPrice();
}
double avg2 = sum * 1.0 / carLs.length;
System.out.println(avg2);
}
}
~~~
>[danger] ##### 学生管理系统
定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
学生的属性：学号，姓名，年龄。
要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
要求2：添加完毕之后，遍历所有学生信息。
要求3：通过id删除学生信息
如果存在，则删除，如果不存在，则提示删除失败。
要求4：删除完毕之后，遍历所有学生信息。
要求5：查询数组id为“heima002”的学生，如果存在，则将他的年龄+1岁
* 创建学生类
~~~
public class Student {
private String name;
private int age;
private int id;
public Student(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
public Student() {
}
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 int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
~~~
* 创建操作
~~~
public class StudentTest {
public static void main(String[] args) {
// 创建一个Student 数组
Student[] studentLs = new Student[3];
// 创建Student 对象 并保存进数组中
Student student1 = new Student("WW", 12, 1);
Student student2 = new Student("CC", 12, 2);
studentLs[0] = student1;
studentLs[1] = student2;
// 判读创建新学生是否存在
Student student3 = new Student("CC", 12, 3);
boolean flag = contains(studentLs, student3);
if (flag) {
System.out.print("当前数据已存在");
} else {
// 如果不存在，将数据保存在数组中
// 但如果数组已经满了 需要扩容增加新的位置
int index = getCount(studentLs);
if (index == studentLs.length) {
// 此时数组已经存满 需要扩容
Student[] newStuLs = createNewArr(studentLs);
newStuLs[index] = student3;
// 要求2：添加完毕之后，遍历所有学生信息。
printArr(newStuLs);
}
}
}
// 增加年龄
public static void addAge(Student[] arr, int id) {
// 4.先要找到id为2的学生对于的索引
int index = getIndex(arr, id);
// 5.判断索引
if (index >= 0) {
// 存在， 则将他的年龄+1岁
Student stu = arr[index];
// 把原来的年龄拿出来
int newAge = stu.getAge() + 1;
// 把+1之后的年龄塞回去
stu.setAge(newAge);
// 遍历数组
printArr(arr);
} else {
// 不存在，则直接提示
System.out.println("当前id不存在，修改失败");
}
}
// 删除学生
public static void deleStu(Student[] arr, int id) {
// 先判断是否存在
int index = getIndex(arr, id);
if (index >= 0) {
// 如果存在，则删除
arr[index] = null;
// 遍历数组
printArr(arr);
} else {
// 如果不存在，则提示删除失败
System.out.println("当前id不存在，删除失败");
}
}
// 创建方法判读当前学生对象是否存在数组中
public static boolean contains(Student[] arr, Student stu) {
boolean flag = false;
for (int i = 0; i < arr.length; i++) {
Student student = arr[i];
if (student != null) {
if (student.getId() != stu.getId()) {
flag = true;
break;
}
}
}
return flag;
}
// 找到数组当前实际位置
public static int getCount(Student[] arr) {
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] != null) {
count++;
}
}
return count;
}
// 创建扩容student 数组
public static Student[] createNewArr(Student[] arr) {
Student[] newArr = new Student[arr.length + 1];
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
public static void printArr(Student[] arr) {
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if (stu != null) {
System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
}
}
}
public static int getIndex(Student[] arr, int id) {
for (int i = 0; i < arr.length; i++) {
// 依次得到每一个学生对象
Student stu = arr[i];
// 对stu进行一个非空判断
if (stu != null) {
int sid = stu.getId();
if (sid == id) {
return i;
}
}
}
// 当循环结束之后，还没有找到就表示不存在
return -1;
}
}
~~~
- windows -- 环境变量
- Vscode -- 编写java
- 初始java
- java -- 关键字
- 编写第一个java程序
- java -- 注释
- 计算机存储 -- 进制
- java -- 类型
- java -- 变量
- 数字类型
- 布尔类型
- 字符类型
- 类型转换
- 双等比较是什么
- java -- 运算符
- 算数运算符
- 字符串拼接
- 关系/比较运算符
- 自增减运算符
- 逻辑运算符
- 三目运算
- 赋值运算符
- 移位运算符
- 位运算符
- 运算符优先级
- java -- 流程控制语句
- if /else if /if -- 判断
- switch case分支结构
- for -- 循环
- 用双重for循环
- while -- 循环
- do while -- 循环
- 案例练习
- java -- 数组
- 数组的存储
- 数组的增删改查
- 数组的特点
- 数组案例
- 二维数组
- 数组的工具方法
- java -- 方法
- java -- 方法的重载
- java -- 方法的调用流程
- java -- 类方法传参注意事项
- java -- 方法练习案例
- 对比 return break continue
- for each循环
- java -- 基础练习
- java -- 面向对象
- java -- 创建类和对象
- java -- 访问控制符
- java -- 类成员方法
- java -- 构造方法
- java -- this
- java -- 封装
- java -- 对象内存图
- java -- 创建对象案例
- java -- static
- java -- 继承
- super -- 关键字
- java -- 构造块和静态代码块
- java -- 重写
- java -- final
- java -- 多态
- java -- 抽象类
- java -- 接口
- 引用类型数据转换
- 综合案例
- java -- 内部类
- java -- 回调模式
- java -- 枚举类型
- java -- switch 使用枚举
- java -- 枚举方法使用
- java -- 枚举类实现接口
- java -- javaBean
- java -- package 包
- java -- import
- java -- 递归练习
- java -- 设计模式
- 单例模式
- java -- 注解
- java -- 元注解
- Java -- 核心类库
- java -- 处理字符串
- Java -- String
- String -- 常用方法
- String -- 正则
- Java -- StringBuilder 和 StringBuffer
- 知识点
- Java -- StringJoiner 字符串拼接
- 练习题
- 字符串的总结
- Java -- 包装类
- Integer
- Double
- Boolean
- Character
- java -- 集合类
- java -- util.Collection
- Iterator接口
- java -- util.List
- java -- ArrayList
- java -- util.Queue
- java -- util.Set
- java -- util.Map
- java -- util.Collections
- Java -- Math
- Java -- java.lang
- Java -- Object
- Java -- 获取当前时间戳
- Java -- 异常
- Java -- java.util
- java -- Date
- java -- Calender
- Java -- java.text
- Java -- SimpleDateFormat
- Java -- java.time
- Java -- java.io
- java -- io.File
- java -- 泛型
- IDEA -- 用法