Java实例 Part5:面向对象入门

目录

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