复数相加+equels、hashcode、clone<二>

package com.jdk7.chapter1;

public class ComplexNumber  implements Cloneable{
    
    private double realPart;
    private double imagePart;
    
    public double getRealPart() {
        return realPart;
    }

    public void setRealPart(double realPart) {
        this.realPart = realPart;
    }

    public double getImagePart() {
        return imagePart;
    }

    public void setImagePart(double imagePart) {
        this.imagePart = imagePart;
    }

    @Override
    public String toString() {
        return "realPart=" + realPart + ", imagePart=" + imagePart + "i";
    }

    /**
     * 默认构造函数
     */
    public ComplexNumber(){
        this.realPart = 0.0;
        this.imagePart = 0.0;
    }
    
    /**
     * 自定义带参构造函数
     * @param a
     * @param b
     */
    public ComplexNumber(double a,double b){
        this.realPart = a;
        this.imagePart = b;
    }
    
    /**
     * 复数相加
     * 返回复数类型
     * @return
     */
    public ComplexNumber add(ComplexNumber comn){
        if(comn==null){
            System.err.println("对象不能为null");
            return new ComplexNumber();
        }else{
            return new ComplexNumber(this.realPart+comn.realPart,this.imagePart+comn.imagePart);
        }
    }
    
    /**
     * 实现Cloneable接口，将equal()重写
     * 分为以下3中情况:
     *         1.比较对象为空；
     *         2.比较对象为被比较或者子类
     *             2.1复数相等
     *             2.2复数不等
     *         3.比较对象不为被比较或者子类
     */
    public boolean equals(Object obj){
        if(obj==null){
            System.out.println("对象不能为空");
            return false;
        }else if(obj instanceof ComplexNumber){
            ComplexNumber c = (ComplexNumber)obj;
            if(this.realPart==c.realPart && this.imagePart==c.imagePart){
                return true;
            }else{
                System.out.println("复数不相同");
                return false;
                }
        }else{
            System.out.println("对象不属于复数类型");
            return false;
            }
    }
    
    /**
     * 如果两个对象的值是相同的->调用toString()方法转换为字符串也相同->再将字符串转换为hashcode则一定是相同的
     */
    public int hashCode(){
        return this.toString().hashCode();
    }
    
    /**
     * 一定要继承接口中的clone()方法，克隆一个自定义类型，并将被克隆对象的值赋给克隆对象
     */
    public ComplexNumber clone(){
        try{
            ComplexNumber d = (ComplexNumber)super.clone();        //继承接口的clone()方法,将Object类型强制转换为要克隆的类型
            d.setRealPart(this.realPart);
            d.setImagePart(this.imagePart);
            return new ComplexNumber(d.realPart,d.imagePart);
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
            return null;
        }
    }
    
    public static void main(String[] args) {
        ComplexNumber a = new ComplexNumber(1,2);
//        ComplexNumber a = new ComplexNumber();
//        ComplexNumber a = null;
        ComplexNumber b = new ComplexNumber(1,2);
//        ComplexNumber b = new ComplexNumber(2,4);
//        ComplexNumber b = new ComplexNumber();
//        ComplexNumber b = null;
//        ComplexNumber1 b = new ComplexNumber1();
        // 被加数不能为null
//        System.out.println("(a+b) = "+a.add(b).toString());
        
        //a和b的值虽然相同，但是在声明为类类型变量时为不同的内存地址，object提供的equels方法比较的是内存地址
        System.out.println("(a==b) : "+a.equals(b));    
        //对象实例内存地址不同，hashcode以对象实例在内存的地址生成hashcode也不相同
        System.out.println("hashcode of a: "+a.hashCode());
        System.out.println("hashcode of b: "+b.hashCode());
        System.out.println("(a.hashCode==b.hashCode) = "+(a.hashCode()==b.hashCode()));
        System.out.println("clone a: "+a.clone());
        
    }

}


运行结果：
(a==b) : true
hashcode of a: 1012487935
hashcode of b: 1012487935
(a.hashCode==b.hashCode) = true
clone a: realPart=1.0, imagePart=2.0i