Java知识点细节简易汇总——(5)面向对象编程(基础部分）

一、 老鼠走迷宫

// 思路
		// 1. 先创建迷宫，用二维数组表示 int[][] map = new int[8][7];
		// 2. 先规定 map 数组的元素值: 0 表示可以走 1 表示障碍物
		int[][] map = new int[8][7];
		// 3. 将最上面的一行和最下面的一行，全部设置为 1
		for (int i = 0; i < 7; i++) {
			map[0][i] = 1;
			map[7][i] = 1;
		}

		// 4.将最右面的一列和最左面的一列，全部设置为 1
		for (int i = 0; i < 8; i++) {
			map[i][0] = 1;
			map[i][6] = 1;
		}
		map[3][1] = 1;
		map[3][2] = 1;
		map[2][2] = 1; // 测试回溯

		// 输出当前的地图
		System.out.println("=====当前地图情况======");
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");// 输出一行
			}
			System.out.println();
		}

		// 使用 findWay 给老鼠找路
		T t1 = new T();
		// 下右上左
		t1.findWay(map, 1, 1);

		System.out.println("\n====找路的情况如下=====");
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");// 输出一行
			}
			System.out.println();
		}

class T {
	// 使用递归回溯的思想来解决老鼠出迷宫
	// 1. findWay 方法就是专门来找出迷宫的路径
	// 2. 如果找到，就返回 true ,否则返回 false
	// 3. map 就是二维数组，即表示迷宫
	// 4. i,j 就是老鼠的位置，初始化的位置为(1,1)
	// 5. 因为我们是递归的找路，所以我先规定 map 数组的各个值的含义
	// 0 表示可以走 1 表示障碍物 2 表示可以走 3 表示走过，但是走不通是死路
	// 6. 当 map[6][5] =2 就说明找到通路,就可以结束，否则就继续找. //7. 先确定老鼠找路策略 下->右->上->左
	public boolean findWay(int[][] map, int i, int j) {
		if (map[6][5] == 2) {               // 说明已经找到
			return true;
		} else {
			if (map[i][j] == 0) {          // 当前这个位置 0,说明表示可以走
				// 我们假定可以走通
				map[i][j] = 2;
				// 使用找路策略，来确定该位置是否真的可以走通
				// 下->右->上->左
				if (findWay(map, i + 1, j)) {          // 先走下
					return true;
				} else if (findWay(map, i, j + 1)) {   // 右
					return true;
				} else if (findWay(map, i - 1, j)) {  // 上
					return true;
				} else if (findWay(map, i, j - 1)) {  // 左
					return true;
				} else {
					map[i][j] = 3;
					return false;
				}
			} else {                 // map[i][j] = 1 , 2, 3
				return false;
			}
		}
	}
}

总结：
1) 将复杂问题简单话，将复杂问题拆分成相同的小块，每一个小块都必须要考虑：“下->右->上->左”的顺序步骤。这也是递归的精髓所在！！！
2) 老鼠走迷宫代码：“站在原地观察下一步该怎么走。”

细节：结束条件放在递归方法的首行。

二、汉诺塔

public class HanoiTower {
//编写一个 main 方法
	public static void main(String[] args) {
		Tower tower = new Tower();
		tower.move(64, 'A', 'B', 'C');
	}
}

class Tower {
	//方法
	//num 表示要移动的个数, a, b, c 分别表示 A 塔，B 塔, C 塔
	public void move(int num, char a, char b, char c) {
		//如果只有一个盘 num = 1
		if (num == 1) {
			System.out.println(a + "->" + c);
		} else {
			//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
			//(1)先移动上面所有的盘到 b, 借助 c
			move(num - 1, a, c, b);
			
			//(2)把最下面的这个盘，移动到 c
			System.out.println(a + "->" + c);
			
			//(3)再把 b 塔的所有盘，移动到 c ,借助 a
			move(num - 1, b, a, c);
		}
	}
}

总结：
1) 将复杂问题简单话，将复杂问题拆分成相同的小块：不管再多盘子（1个除外），都统一按两个盘子考虑。

三、方法重载

3.1基本介绍
java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！

3.2重载的好处

1. 减轻了起名的麻烦
2. 减轻了记名的麻烦

四、可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现

4.2基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) {
}

//编写一个 main 方法
public static void main(String[] args) {
		HspMethod m = new HspMethod();
		System.out.println(m.sum(1, 5, 100)); // 106
		System.out.println(m.sum(1, 19)); // 20
	}
}

class HspMethod {
	// 可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。
	// 可以使用方法重载
	// public int sum(int n1, int n2) {//2 个数的和
	// return n1 + n2;
	// }
	// public int sum(int n1, int n2, int n3) {//3 个数的和
	// return n1 + n2 + n3;
	// }
	// public int sum(int n1, int n2, int n3, int n4) {//4 个数的和
	// return n1 + n2 + n3 + n4;
	//
	// 1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
	// 2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
	// 3. 遍历 nums 求和即可
	public int sum(int... nums) {
		// System.out.println("接收的参数个数=" + nums.length);
		int res = 0;
		for (int i = 0; i < nums.length; i++) {
			res += nums[i];
		}
		return res;
	}
}

4.3可变参数注意事项

五、构造器

public class Constructor01 {
	// 编写一个 main 方法
	public static void main(String[] args) {
		// 当我们 new 一个对象时，直接通过构造器指定名字和年龄
		Person p1 = new Person("smith", 80);
		System.out.println("p1 的信息如下");
		System.out.println("p1 对象 name=" + p1.name);// smith
		System.out.println("p1 对象 age=" + p1.age);// 80
	}
}

// 在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
	String name;
	int age;

	// 构造器
	// 老韩解读
	// 1. 构造器没有返回值, 也不能写 void
	// 2. 构造器的名称和类 Person 一样
	// 3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
	public Person(String pName, int pAge) {
		System.out.println("构造器被调用~~ 完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

六、 this关键字

1) this 关键字可以用来访问本类的属性、方法、构造器
2) this 用于区分当前类的属性和局部变量
3) 访问成员方法的语法：this.方法名(参数列表);
4) 访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器，必须放在第一条语句)
5) this 不能在类定义的外部使用，只能在类定义的方法中使用。

注意第一点： this 关键字可以用来访问本类的属性。

	public static void main(String[] args) {
			PersonName per = new PersonName();
			per.Per1();
		}
	}
		
class  PersonName {
	String name = "属性";
	
	public void Per1() {
		String name = "就近";
		System.out.println("name = "+ name);              // 就近
		System.out.println("this.name = "+ this.name);	  // 属性	
	}
}

第四点：

class Person {
	public Person() {
		this("jack" , 100);      //语法：从一个构造器访问另一个构造器。且必须放在第一行！！！
		System.out.println("Person() 构造器...");
	}
	
	public Person( String name, int age) {
		System.out.println("Person( String name, int age) 构造器...");
	}
}

---

定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，
用于判断是否和另一个人相等，提供测试类 TestPerson 用于测试, 名字和年龄完全一样，就返回 true, 否则返回 false

		public static void main(String[] args) {
			PersonL per1 = new PersonL("路飞",25);
			PersonL per2 = new PersonL("索隆",25);
			per1.campeTo(per2);
	}
}
		
	class PersonL {
		String name;
		int age;

		public PersonL(String name, int age) {
			this.name = name;
			this.age = age;
		}

		public void campeTo(PersonL p) {
			if (this.name.equals(p.name) && this.age == p.age) {
				System.out.println("对");
			} else {
				System.out.println("不对");
		}
	}
}