Java实例 Part5：面向对象入门

时间：2018-11-04 01:52:51 阅读：134 评论：0 收藏：0 [点我收藏+]

标签：模式要求 util vat 输出初始化 shadow proc append

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

Java实例 Part5：面向对象入门

标签：模式要求 util vat 输出初始化 shadow proc append

原文地址：https://www.cnblogs.com/hynazwaa/p/9902642.html

踩

(0)