Java第一阶段（8）【 面向对象 - 继承和多态】 11.15

继承

• java集成体系：
  继承关系类与类之间的关系
  类与接口之间的关系
• extends 继承 implements 实现/接口
  一些具有相同属性的事物进行总结 自行车/公交车/的士 → 车
  把一些具有相同属性的类进行向上抽离，建立一个类
  这个类就是具有相同属性的类叫做父类（超类），这些相同属性的类称为父类的子类（派生类）
• 继承的书写方式 ：
  1.新建一个类，在类名后面 extends 跟上父类的名字
  2.在创建类时superclass文本框中写入父类的完整路径（跟上包名，可alt+/快捷）
• 继承关系的特点：
  1.类与类之间只支持单继承（一个子类只能有一个父类）
  2.java中类是支持多层继承
  3.如果子类继承父类，则继承了父类中所有的属性和成员方法。
  4.只有构造方法不会继承
  5.子类无法直接访问父类中私有的属性，可以通过父类公共的访问方式进行访问
• 继承的作用
  提高代码的可维护性和拓展性 节约代码量

方法的重写

• 子类继承父类的方法后，需要一些自己特有的功能
• 重写的概念：出现在继承体系中，方法名相同，参数列表相同，返回值类型相同
• 与重载的区别：出现在同一类中，方法名相同，参数列表不同，与返回值无关

多态

• 生活中的多态：一种事物根据不同条件，所产生不同的结果

• 面向对象中多态的前提条件(条件必须同时满足)：
  1.必须出现在继承体系中
  2.必须有方法的重写
  3.创建对象时，必须 父类引用指向 子类对象
  　　　　　　　　　父 取个名字 = new 儿子();
  　　　　　　　　　Animals an = new Cat();//向上转型（儿子穿着父亲的外套）

• 向上转型的特点：
  左边父类，右边子类
  访问特点：1.访问成员属性（编译看左边，运行看左边）
  　　　　　2.访问成员方法（编译看左边，运行看右边）

• 向下转型（强转）
  子类引用 指向 父类对象
  Cat c = (Cat) an;

• 应用：
  当 某些引用数据类型 作为形式参数

• 详解可看这里：https://blog.csdn.net/qq_42829628/article/details/84112584

练习

• 打地鼠（多敌人）
  1.将打地鼠游戏进行面向对象处理，分为：洞穴类，玩家类，地鼠类，裁判类，游戏运行类，main方法类。
  2.洞穴类：参考属性：洞穴的类型O，方法：打印洞穴的方法
  3.玩家类：属性：玩家输入的行与列，方法：玩家击打的方法
  4.地鼠类：属性：地鼠出现的行与列，地鼠的价值分数，方法：地鼠出现的方法X
  5.裁判类：属性：游戏次数，得分，击中次数，未击中次数，方法：判断打中的方法
  6.游戏运行的类： 写start（）方法
  7.游戏循环10次，统计得分，击中，未击中
  8.99-重新开始，88-退出游戏
  9.使用继承多态出现不同的敌人，敌人属性：敌人类型M 10,S 20,W 30 每次出现一只
  10.Mouse全局出现，Snake只出现在前两列，Wolf只出现在后两行

--------- 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 getDropColumn() {
		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.getDropColumn()];
		// 遍历这个数组，打印洞穴初始形态
		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-结束游戏)");
	}

}

--------- Animals 类-----------

package game_DiShu;

import java.util.Random;

//父类：动物类
public class Animals {
	private int row; // 出现的行
	private int column; // 出现的列
	private int score;// 动物的分数

	// 构造方法
	public Animals() {

	}

	public int getRow() {
		return row;
	}

	public void setRow(int row) {
		this.row = row;
	}

	public int getColumn() {
		return column;
	}

	public void setColumn(int column) {
		this.column = column;
	}

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	//动物出现的方法（后面重写）
	public void Appear(char[][] pDrop, Drop d) {

	}

	// 动物传递分数的方法
	public void score(int s) {
		score = s;
	}
	//行与列的传递（用于裁判类）
	public void rowColumn(int a, int b) {
		this.row = a;
		this.column = b;
	}

}

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

package game_DiShu;

import java.util.Random;

//地鼠类
public class Mouse extends Animals {

	// 构造方法
	public Mouse() {
		//把地鼠的分数传递给父类，供裁判类使用
		super.score(10);
	}

	// 成员方法
	// 地鼠出现的方法
	public void Appear(char[][] pDrop, Drop d) {
		// new随机对象
		Random r = new Random();
		// 地鼠随机出现位置的行与列（随机数为洞穴的行与列）
		setRow(r.nextInt(d.getDropRow()));
		setColumn(r.nextInt(d.getDropColumn()));
		// 设置洞穴的 地鼠行 与 地鼠列 为"M"
		pDrop[getRow()][getColumn()] = 'M';
		// 遍历
		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();
		}
		//把行与列传给父类rowColumn方法
		super.rowColumn(getRow(), getColumn());

	}

}

--------- Snake 类-----------

package game_DiShu;

import java.util.Random;

//蛇类
public class Snake extends Animals {

	// 构造方法
	public Snake() {
		//把蛇的分数传递给父类，供裁判类使用
		super.score(20);
	}

	// 成员方法
	// 蛇出现的方法
	public void Appear(char[][] pDrop, Drop d) {
		// new随机对象
		Random r = new Random();

		// 蛇随机出现位置的行与列
		setRow(r.nextInt(d.getDropRow()));
		//只出现在前两列
		setColumn(r.nextInt(2));
		// 设置洞穴的 蛇行 与 蛇列 为"M"
		pDrop[getRow()][getColumn()] = 'S';
		// 遍历
		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();
		}
		//把行与列传给父类rowColumn方法
		super.rowColumn(getRow(), getColumn());
	}
}

--------- Wolf 类-----------

package game_DiShu;

import java.util.Random;

public class Wolf extends Animals {
	// 构造方法
	public Wolf() {
		//把狼的分数传递给父类，供裁判类使用
		super.score(30);
	}

	// 成员方法
	// 狼出现的方法
	public void Appear(char[][] pDrop, Drop d) {
		// new随机对象
		Random r = new Random();
		// 狼随机出现位置的行与列
		//把手动输入的行数放到一维数组中，进行使用
		int[] arr = { d.getDropRow() - 1, d.getDropRow() - 2 };
		int ra = r.nextInt(2);
		//行数为随机的后两行
		setRow(arr[ra]);
		setColumn(r.nextInt(d.getDropColumn()));
		// 设置洞穴的 狼行 与 狼列 为"W"
		pDrop[getRow()][getColumn()] = 'W';
		// 遍历
		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();
		}
		//把行与列传给父类rowColumn方法
		super.rowColumn(getRow(), getColumn());
	}
}

--------- 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, Animals an) {
		// 如果玩家输入的行数和地鼠出现的行数相同，并且玩家输入的列数和地鼠出现的列数相同，则为击中
		if (p.getPlayerRow() == an.getRow() && p.getPlayerColumn() == an.getColumn()) {
			System.out.println("----------");
			System.out.println("【恭喜你击中了】");

			// 总分数等于之前的得分加上分数
			score += an.getScore();
			// 击中次数增加
			hit++;

		} else {
			System.out.println("----------");
			System.out.println("【很遗憾，未击中】");
			// 未击中次数增加
			miss++;
			score--;
		}

		// 游戏次数增加
		num++;
		// 还原洞穴
		pDrop[an.getRow()][an.getColumn()] = 'o';
	}
}

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

package game_DiShu;

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

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

		int pan = 1;// 初始个判断值，用于输入行列数处
		Drop d = new Drop();// 洞穴对象
		Player p = new Player();// 玩家对象
		Animals an = new Animals();// 动物对象（父类）
		Judge ju = new Judge();// 裁判对象
		Random r = new Random();// 随机数对象
		Scanner s = new Scanner(System.in);// 键盘输入对象

		// 欢迎的方法
		welcome();
		// 当判断值为1时，执行
		while (pan == 1) {
			System.out.println("请输入您想挑战的行数,回车确定(必须大于等于三行)");
			d.setDropRow(s.nextInt());
			System.out.println("请输入您想挑战的列数,回车确定(必须大于等于三列)");
			d.setDropColumn(s.nextInt());
			// 如果输入的数大于3，则程序继续运行，否则返回循环
			if (d.getDropRow() >= 3 && d.getDropColumn() >= 3) {
				pan = 2;
			} else {
				System.out.println("输入有误，请重新输入");
				pan = 1;
			}
		}

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

		System.out.println("--------------");
		System.out.println("请注意，地鼠出现了");
		System.out.println("↓↓↓↓↓↓↓↓↓↓↓↓↓↓");
		// 当游戏次数小于10时循环
		while (ju.getNum() <= 10) {

			int ra = r.nextInt(3);
			// 当随机数为0时，地鼠出现
			if (ra == 0) {
				an = new Mouse();
				// 出现的方法
				an.Appear(pDrop, d);
				// 当随机数为1时，蛇出现
			} else if (ra == 1) {
				an = new Snake();
				// 出现的方法
				an.Appear(pDrop, d);
				// 狼出现
			} else {
				an = new Wolf();
				// 出现的方法
				an.Appear(pDrop, d);
			}

			// 玩家击打
			p.playerWrite(ju);
			// 玩家输入行数
			p.setPlayerRow(s.nextInt() - 1);
			// 如果玩家99重新开始
			if (p.getPlayerRow() == 98) {
				System.out.println("---------");
				System.out.println("重新开始游戏");
				pDrop[an.getRow()][an.getColumn()] = 'o';
				ju = new Judge();
				continue;
			}
			// 如果玩家88退出游戏
			if (p.getPlayerRow() == 87) {
				System.out.println("---------");
				System.out.println("退出游戏");
				return;
			}
			// 玩家输入列
			p.setPlayerColumn(s.nextInt() - 1);

			// 是否打中的方法
			ju.whetherHit(pDrop, p, an);

		}

		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();
	}
}