目录
Part5：面向对象入门
@
***
Example01：成员变量的初始化值
运行结果：
代码实现：
public class Example01 {
//声明变量
private byte b;
private int i;
private short s;
private long l;
private char ch;
private float f;
private double d;
private boolean bool;
private String str;
public static void main(String[] args) {
Example01 example = new Example01();
System.out.println("byte类型的初始值："+example.b);
System.out.println("int类型的初始值："+example.i);
System.out.println("short类型的初始值："+example.s);
System.out.println("long类型的初始值："+example.l);
System.out.println("char类型的初始值："+example.ch);
System.out.println("float类型的初始值："+example.f);
System.out.println("double类型的初始值："+example.d);
System.out.println("boolean类型的初始值："+example.bool);
System.out.println("String类型的初始值："+example.str);
}
}- 要点：对于引用类型的变量，在使用之前需要进行初始化，否则会抛出NullPointerException。
***
Example02：单例模式的应用
-----懒汉式
运行结果：
实现代码：
class Single {
private static Single s = null;
private Single(){}
public static Single getInstance(){
if (s == null){
s = new Single();
System.out.println("---我是懒汉！");
}
return s;
}
}- 懒汉式在方法中创建这个类的对象，调用效率不高，但能延时加载。
-----饿汉式
运行结果：
代码实现：
class Single {
private static Single s = new Single();
private Single(){}
public static Single getInstance(){
System.out.println("---我是饿汉！");
return s;
}
}- 饿汉式在全局变量范围内创建这个类的对象，调用效率高，但不能延时加载。
== 测试代码：==
public class Example02 {
public static void main(String[] args) {
System.out.println("---你又是谁？");
Single.getInstance();
}
}要点：单例模式的特点在于仅能获得一个对象。为了防止其他用户创建对象，需要将构造函数设置成private的，然后提供一个静态方法，该方法返回这个类的对象。
***
Example03：汉诺塔问题的求解
- 汉诺塔问题描述：有A、B、C 3根柱子，在A上从下往上按照从小到大的顺序放着3个圆盘，以B为中介，把盘子全部移动到C上。移动过程中，要求任意盘子的下面要么没有盘子，要么只能有比它大的盘子。
运行结果：
代码实现：
public class Example3 {
public static void main(String[] args) {
int nDisks = 3; //设置汉诺塔为3阶
moveDish(nDisks,'A','B','C');
}
public static void moveDish(int level,char from,char inner,char to){
if (level == 1){ //如果只有一个盘子
System.out.println("从"+from+"移动盘子1号到"+to);
}else { //如果有大于一个盘子就迭代
moveDish(level-1,from,to,inner);
System.out.println("从"+from+"移动盘子"+level+"号到"+to);
moveDish(level-1,inner,from,to);
}
}
}- 要点：为了将N个盘子从A移动到C，需要先将N个盘子上面的N-1个盘子移动的B上，这样才能将第N个盘子移动到C上，同理，为了将第N-1个盘子从B移动到C上，通过递归可以实现汉诺塔问题。（上面的程序是3阶汉诺塔问题，有需要可以改写成自己需要计算的输入程序的n阶汉诺塔问题）
Example04：两只完全相同的宠物并得出对象的哈希码
- 要求：重写equals()和toString()以及hashCode()方法来比较两个对象是否相同。
运行结果：
代码实现：
import java.awt.*;
import java.util.Objects;
public class Cat {
private String name;
private int age;
private double weight;
private Color color;
public Cat(String name, int age, double weight, Color color) {
this.name = name;
this.age = age;
this.weight = weight;
this.color = color;
}
@Override
public boolean equals(Object o) { //利用属性来判断猫咪是否相同
if (this == o) { //如果两个猫咪是同一个对象则相同
return true;
}
if (o == null ) { //如果两个猫咪有一个为null则不同
return false;
}
if (getClass() != o.getClass()) { //如果两个猫咪的类型不同则不同
return false;
}
Cat cat = (Cat) o;
//比较猫咪的属性
return age == cat.age && Double.compare(cat.weight, weight) == 0 && Objects.equals(name, cat.name) && Objects.equals(color, cat.color);
}
@Override
public String toString() { //重写toString()方法
return "Cat{" +
"名字='" + name + '\'' +
", 年龄=" + age +
", 重量=" + weight +
", 颜色=" + color +
'}';
}
@Override
public int hashCode() {
return Objects.hash(name, age, weight, color);
}
public static void main(String[] args) {
Cat c1 = new Cat("hyn",3,10,Color.PINK);
Cat c2 = new Cat("azw",4,15,Color.YELLOW);
Cat c3 = new Cat("hyn",3,10,Color.PINK);
System.out.println("猫咪1号："+c1);
System.out.println("猫咪2号："+c2);
System.out.println("猫咪3号："+c3);
System.out.println("猫咪1号的哈希码："+c1.hashCode());
System.out.println("猫咪2号的哈希码："+c2.hashCode());
System.out.println("猫咪3号的哈希码："+c3.hashCode());
System.out.println("猫咪1号是否与2号相同："+c1.equals(c2));
System.out.println("猫咪1号是否与3号相同："+c1.equals(c3));
}
}要点：Java中创建的对象是保存在堆中的，为了提高查找的速度而使用了散列查找。散列查找的基本思想是定义一个键来映射对象所在的内存地址。当需要查找对象时，直接查找键即可，这样就不用遍历整个堆来查找对象了。
***提高：对toString()方法里面的内容进行改进，通过使用字符串输出对象。
运行结果：
代码实现：
@Override
public String toString() { //重写toString()方法
StringBuilder sb = new StringBuilder();
sb.append("名字："+name+"\n");
sb.append("年龄："+age+"\n");
sb.append("重量："+weight+"\n");
sb.append("颜色："+color+"\n");
return sb.toString();
}