Java继承（toString,equal）

package second;
abstract class Animal{
    //定义抽象的公共方法
    public abstract void eat();
    //抽象类里的方法前必须定义关键词  否则报错
    public abstract String getSex();
    public abstract String getName();
    public abstract int getAge();
    public abstract int getId();
}

class Dog extends Animal{
    //属性封装
    private String name="none";
    private String sex="female";
    private int age=0;
    private int id=0;//类实力化存储身份序列
    //构造函数
    public Dog(int id,String name,String sex,int age){
        this.id = id;
        this.name=name;
        this.sex = sex;
        this.age = age;
    }
    //访问私有属性外部方法
    public int getId(){
        return id;
    }
    public String getName(){
        return name;
    }
    public String getSex(){
        return sex;
    }
    public int getAge(){
        return age;
    }
    //重写eat方法
    public void eat(){
        System.out.println("-----狗吃饭----");
    }
    //构造toString方法
    public String toString(){
        return "Dog[身份标识："+id+"||姓名："+name+"||性别："+sex+"||年龄："+age+"]";  //自定义返回内容
        /*
         *直接print(对象)就是调用 object的toString方法
         *程序自定义返回  字符串 ：类名@哈希值
         *""+对象
         *
         */
    }
    /*
     * ==和equals：
     * Object默认方法是比较对象的地址是否相同和==的作用是一样的，对象值相等是一个没有标准，实际上要使equals有意义，必须重写。
     * 具体：
     * 1.==：
     * ①比较的基本数值类型： 不论属性类型 只要值相等就返回 True
     * ②比较引用数值类型： 比较两个对象的地址值  相等返回 True//与equal方法作用一致
     * 2.equal:
     * 判断对象值是否相等 基本属性 以及是否是一个类 （A.class == t.getClass()）
     * String方法已经重写内容 只要对象的内容的值相等 就返回True
     * 3.A instanceof B （A对象是B类的实例，判断时其子类或者子类的子类 都符合条件 不满足==的内容）
     * 
     *  String A0 = "a";
     *  String A1 = "a";
     *  String a0 = new String("a");
     *  String a1 = new String("a");
     *  System.out.println(A0==A1);//true 
     *  System.out.println(a0=a1);//false  
     *  System.out.println(a0.equal(a1));//true   2.
     *  String 和   new String("")不同 ：
     *  直接"" 是存储在常量池中的，编译时期直接确定下来  避免相同字符串产生多个副本
     *  new是先把字符串保存在 常量池中 再在堆内存中创建对象  实际创建了两个字符串对象
     */

    /*
     * hashCode是用于散列数据的快速存取，如利用HashSet/HashMap/HashTable类来存储数据时，都是根据存储对象的hashCode值来进行判断是否相同的。
     * hashCode和equals关系是：
     * 共同判断对象是否相同 ， 一个hashCode代表一个 对象 
     * 如果一个对象的equals相同 则 hashCode必须相同
     * 据此 如果重写equals 则必须重写hashCode
     */
    //重写hashCode
    public int hashCode(){
        return getId(); 
    }

    //重写equals方法：
    public boolean equals(Object obj){
        //判断标准 1.对象是否相等 2.对象是继承同一个类 ，基本属性值相等
        if(this == obj){//1.当前对象的地址是否和传入的对象的地址一致
            return true;
        }
        if(obj != null&&obj.getClass()==Dog.class){//2.判断传入对象的类是否和当前的一致
            Animal dogObj = (Dog)obj;//必须强制转化才能调用内部的方法  实参传入Object是形参  Object a = person a 多态发生   向上强转 父类不可见子类非重写的方法  调用子类方法就需要强转
            if(this.getName()==dogObj.getName()&&this.getSex().equals(dogObj.getSex())&&this.getAge()==dogObj.getAge()){
                //强转之后的父类 只能调用父类特有方法 以及子类重写方法 不能向下调用为重写的子类方法
                return true;
            }
        }
        return false;   
    }

}
public class ExtendsHome {
    public static void main(String args[]){
        //定义并初始化都对象
        Dog mini = new Dog(110,"豆豆","male",10);
        //打印输出该实例对象的id
        System.out.println(mini);
        System.out.println(mini.toString());
        //创建新的对象
        Dog lala = new Dog(120,"咪咪","female",1);
        System.out.println(lala);
        //判断两个对象是否相同
        System.out.println("lala是否与mini相等"+lala.equals(mini));
        //id不同的但对象内容相等判断
        Dog baby = new Dog(123,"豆豆","male",10);
        System.out.println("baby的id"+baby.getId());
        System.out.println("baby是否与mini相等"+baby.equals(mini));
        //相同对象判断
        System.out.println("mini的id"+mini.getId());
        System.out.println("mini是否与mini相等"+mini.equals(mini));

    }

}
/*
 * 结果：
 *  Dog[身份标识：110||姓名：豆豆||性别：male||年龄：10]
    Dog[身份标识：110||姓名：豆豆||性别：male||年龄：10]
    Dog[身份标识：120||姓名：咪咪||性别：female||年龄：1]
    lala是否与mini相等false
    baby的id123
    baby是否与mini相等true
    mini的id110
    mini是否与mini相等true       
*/