Java第一阶段（7）【面向对象 - 对象的使用、类的封装】 11.14

本文为十七观察室原创文章，非商用自由转载-保持署名-注明出处，

本文链接：https://blog.csdn.net/qq_42829628/article/details/84072618

第一阶段

匿名对象
垃圾处理机制
封装
static
快捷键
练习

匿名对象

何时创建：一次性使用时
格式：new 类名()； 例如：new Game().start()

栈：局部变量，对象的引用（等号左边的）
堆：对象的实例

垃圾处理机制

java有一种机制：垃圾处理机制
每new一次，就生成一个新的对象，新的地址，会占用内存。
当一个对象长期没有一个引用去指向它的时候，就会被回收掉，从而释放内存。

封装

面向对象三大特征：封装、继承、多态
封装：类的封装
1.首先把成员属性私有化( private ) （使用private修饰隐藏起来），除了本类之外，其他地方无法直接访问到
2.然后对外提供公共的访问方式，进行访问（要么修改set，要么获取get）

//获取 age 的方法 有返回值
public int getAge() {
	return age;
}

//修改 age 的方法 无返回值
public void setAge(int a ){
	//约束 if
	if(a<1 || a>100){
		age = 18;
	}else{
		age = a;
	}
}

封装的作用：
1.提高了代码的安全性（数据的严谨）
2.保证后续框架的运行

public void setName(String name){
	//形式参数的名字和成员变量的名字一样的时候，如果直接赋值，是无用功
	//为了解决这个问题，必须使用this来区分本类还是其他参数
		this.name = name;
}

this:代表的是当前类的引用
1.区分本类属性与其他的参数，同名的情况
2.使用this 点出属性和方法
当参数列表有多个参数时，可用类当作数据类型来调用

public void check(Player p,Robot ro ){
	int pNum = p.num;//这里就可以直接用 p 点出Player类里的num
	int pName = p.name;
	int rName = ro.name;
	...
}

static

static：静态的修饰符
方法区存放：类、静态的常量/参数
static 出现的时机：随着类的加载而出现，优先于对象的存在
可以直接使用类名去调用静态的元素
静态的参数是大家共享的，整个内存只有一个

快捷键

快速生成get/set 快捷键：alt + shift + s → Generate Getters and Setters…

练习

1.打地鼠(封装版)

1.将打地鼠游戏进行面向对象处理，分为：洞穴类，玩家类，地鼠类，裁判类，游戏运行类，main方法类。
2.洞穴类：参考属性：洞穴的类型O，方法：打印洞穴的方法
3.玩家类：属性：玩家输入的行与列，方法：玩家击打的方法
4.地鼠类：属性：地鼠出现的行与列，地鼠的价值分数，方法：地鼠出现的方法
5.裁判类：属性：游戏次数，得分，击中次数，未击中次数，方法：判断打中的方法
6.游戏运行的类：写start（）方法
7.游戏循环10次，统计得分，击中，未击中
8.99-重新开始，88-退出游戏

--------- Drop 类-----------

package game_DiShu;
//洞穴类
public class Drop {
	// 成员属性
	private char dropName = 'o'; // 洞穴
	private int dropRow; // 行数
	private int dropColumn; // 列数

	// 获取洞穴名
	public char getDropName() {
		return dropName;
	}

	// 修改洞穴名
	public void setDropName(char dropName) {
		this.dropName = dropName;
	}

	// 获取洞穴行数
	public int getDropRow() {
		return dropRow;
	}

	// 修改洞穴行数
	public void setDropRow(int dropRow) {
		this.dropRow = dropRow;
	}

	// 获取洞穴列数
	public int getyDropColumn() {
		return dropColumn;
	}

	// 修改洞穴列数
	public void setDropColumn(int dropColumn) {
		this.dropColumn = dropColumn;
	}

	// 构造函数
	public Drop() {

	}

	// 成员方法

	//打印洞穴的方法
	public char[][] printDrop(Drop d) {
		//创建一个二维数组pDrop，值分别为洞穴的行数与列数
		char[][] pDrop = new char[d.getDropRow()][d.getyDropColumn()];
		//遍历这个数组，打印洞穴初始形态
		for (int i = 0; i < pDrop.length; i++) {
			for (int j = 0; j < pDrop[i].length; j++) {
				pDrop[i][j] = 'o';
				System.out.print(pDrop[i][j] + " ");
			}
			System.out.println();
		}
		//返回这个二维数组，后期使用
		return pDrop;
	}
}

--------- Player 类-----------

package game_DiShu;

import java.util.Scanner;

//玩家类
public class Player {
	// 成员属性
	private int playerRow; // 玩家输入的行
	private int playerColumn; // 玩家输入的列

	// 获取玩家输入的行
	public int getPlayerRow() {
		return playerRow;
	}

	// 修改玩家输入的行
	public void setPlayerRow(int playerRow) {
		this.playerRow = playerRow;
	}

	// 获取玩家输入的列
	public int getPlayerColumn() {
		return playerColumn;
	}

	// 修改玩家输入的列
	public void setPlayerColumn(int playerColumn) {
		this.playerColumn = playerColumn;
	}

	// 构造方法
	public Player() {

	}

	// 成员方法
	// 玩家打击的方法(感觉放在外面更好判断特殊情况，于是就写在了外面)
	public void playerWrite(Judge ju) {
		System.out.println("----------------");
		// 打印第几次游戏
		System.out.println("第" + ju.getNum() + "次游戏");

		System.out.println("地鼠出现了,请打击(先行后列，回车确定      99-重新开始    88-结束游戏)");
	}

}

--------- Mouse 类-----------

package game_DiShu;

import java.util.Random;

//地鼠类
public class Mouse {
	private int mouseRow; // 地鼠出现的行
	private int mouseColumn; // 地鼠出现的列
	private int mouseScore = 2; // 地鼠的分数

	// 获取地鼠出现的行
	public int getMouseRow() {
		return mouseRow;
	}

	// 修改地鼠出现的行
	public void setMouseRow(int mouseRow) {
		this.mouseRow = mouseRow;
	}

	// 获取地鼠出现的列
	public int getMouseColumn() {
		return mouseColumn;
	}

	// 修改地鼠出现的列
	public void setMouseColumn(int mouseColumn) {
		this.mouseColumn = mouseColumn;
	}

	// 获取地鼠的分数
	public int getMouseScore() {
		return mouseScore;
	}

	// 修改地鼠的分数
	public void setMouseScore(int mouseScore) {
		this.mouseScore = mouseScore;
	}

	// 构造方法
	public Mouse() {

	}

	// 成员方法
	// 地鼠出现的方法
	public void mouseAppear(char[][] pDrop, Drop d, Mouse m) {
		// new随机对象
		Random r = new Random();
		// 地鼠随机出现位置的行与列（随机数为洞穴的行与列）
		m.mouseRow = r.nextInt(d.getDropRow());
		m.mouseColumn = r.nextInt(d.getyDropColumn());

		// 设置洞穴的 地鼠行 与 地鼠列 为"x"
		pDrop[m.mouseRow][m.mouseColumn] = 'x';
		// 遍历
		for (int i = 0; i < pDrop.length; i++) {
			for (int j = 0; j < pDrop[i].length; j++) {
				System.out.print(pDrop[i][j] + " ");
			}
			System.out.println();
		}
	}
}

--------- Judge 类-----------

package game_DiShu;

//裁判类
public class Judge {

	private int num = 1; // 游戏次数
	private int score = 0; // 总得分
	private int hit; // 击中次数
	private int miss; // 未击中次数

	// 获取游戏次数
	public int getNum() {
		return num;
	}

	// 修改游戏次数
	public void setNum(int num) {
		this.num = num;
	}

	// 获取总得分
	public int getScore() {
		return score;
	}

	// 修改总得分
	public void setScore(int score) {
		this.score = score;
	}

	// 获取击中数
	public int getHit() {
		return hit;
	}

	// 修改击中数
	public void setHit(int hit) {
		this.hit = hit;
	}

	// 获取未击中数
	public int getMiss() {
		return miss;
	}

	// 修改未击中数
	public void setMiss(int miss) {
		this.miss = miss;
	}

	// 构造方法
	public Judge() {

	}

	// 成员方法
	//判断是否打中的方法
	
	public void whetherHit(char[][] pDrop, Player p, Mouse m) {
		//如果玩家输入的行数和地鼠出现的行数相同，并且玩家输入的列数和地鼠出现的列数相同，则为击中
		if (p.getPlayerRow() == m.getMouseRow() && p.getPlayerColumn() == m.getMouseColumn()) {
			System.out.println("----------");
			System.out.println("【恭喜你击中了】");
			//总分数等于之前的得分加上地鼠的分数
			score += m.getMouseScore();
			//击中次数增加
			hit++;

		} else {
			System.out.println("----------");
			System.out.println("【很遗憾，未击中地鼠】");
			//未击中次数增加
			miss++;
		}
		//游戏次数增加
		num++;
		//还原洞穴
		pDrop[m.getMouseRow()][m.getMouseColumn()] = 'o';
	}
}

--------- Game 类-----------

package game_DiShu;

import java.util.Random;
import java.util.Scanner;

//运行类
public class Game {
	public void start() {

		Drop d = new Drop();// 洞穴对象
		Player p = new Player();// 玩家对象
		Mouse mo = new Mouse();// 地鼠对象
		Judge ju = new Judge();// 裁判对象
		Random r = new Random();// 随机数对象
		Scanner s = new Scanner(System.in);// 键盘输入对象

		// 欢迎的方法
		welcome();
		System.out.println("请输入您想挑战的行数,回车确定");
		d.setDropRow(s.nextInt());
		System.out.println("请输入您想挑战的列数,回车确定");
		d.setDropColumn(s.nextInt());

		// 创建一个二维数组去获取洞穴
		char[][] pDrop = d.printDrop(d);

		System.out.println("--------------");
		System.out.println("请注意，地鼠出现了");
		System.out.println("↓↓↓↓↓↓↓↓↓↓↓↓↓↓");
		// 当游戏次数小于10时循环
		while (ju.getNum() <= 10) {
			// 洞穴出现的方法
			mo.mouseAppear(pDrop, d, mo);
			// 玩家击打
			p.playerWrite(ju);
			// 玩家输入行数
			p.setPlayerRow(s.nextInt() - 1);
			// 如果玩家99重新开始
			if (p.getPlayerRow() == 98) {
				System.out.println("---------");
				System.out.println("重新开始游戏");
				pDrop[mo.getMouseRow()][mo.getMouseColumn()] = 'o';
				ju.setNum(1);
				ju.setScore(0);
				ju.setHit(0);
				ju.setMiss(0);
				continue;
			}
			// 如果玩家88退出游戏
			if (p.getPlayerRow() == 87) {
				System.out.println("---------");
				System.out.println("退出游戏");
				return;
			}
			// 玩家输入列
			p.setPlayerColumn(s.nextInt() - 1);
			// 是否打中的方法
			ju.whetherHit(pDrop, p, mo);

		}

		System.out.println("--------");
		System.out.println("游戏结束");
		System.out.println("最终得分：" + ju.getScore() + "分");
		System.out.println("击中" + ju.getHit() + "次");
		System.out.println("未击中" + ju.getMiss() + "次");

	}

	public void welcome() {
		System.out.println("欢迎来到打地鼠游戏");
		System.out.println("--------------");
	}
}

--------- Test 类-----------

package game_DiShu;
//测试类
public class Test {
	public static void main(String[] args) {
		new Game().start();
	}
}