Object类概述

是所有类中的父类，最大的超类，所有的类都继承他。

equals方法

比较2个对象是否相同，其实他是在比较两个对象的地址是否相同，在equals方法中我们用==来判断

但是比较2个地址相同实在没有什么意义，实际开发中我们可能会比较2个对象的属性是否一样，所以我们会在类中重写equals方法再调用

注意：在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。

比较2个人的年龄是否相同：

  1.  1 package com.orcale.demo01;
  2.  2 
  3.  3 public class Person {
  4.  4     private String name;  //首先定义人的属性年龄和名字
  5.  5     private int age;
  6.  6     public String getName() {
  7.  7         return name;
  8.  8     }
  9.  9     public void setName(String name) {
  10. 10         this.name = name;
  11. 11     }
  12. 12     public int getAge() {
  13. 13         return age;
  14. 14     }
  15. 15     public void setAge(int age) {
  16. 16         this.age = age;
  17. 17     }
  18. 18     //判断是否是同龄人
  19. 19     public boolean equals(Object obj) {    //重写equals方法，形参传object类，父类的类型多态的 obj是传进来的一个地址，p2的地址。
  20. 20         if(obj==this){             　　　　　　判断一下传进来的地址是不是一样，如果是传一个p1，那就是p1==p1，不用再判断了就是ture
  21. 21             return true;
  22. 22         }
  23. 23         if(obj instanceof Person){           //先判断一下是不是传进来的obj是不是Person类，如果不是直接返回false，如果是就进方法体。
  24. 24             //向下转型　　　　　　　　　　　　　　//因为是父类，但是我们要判断Person年龄属性，我们要把父类转换到子类，强转子类，然后判断
  25. 25             Person p =(Person)obj;
  26. 26             return this.age == p.age;
  27. 27         }
  28. 28         return false;
  29. 29     }33    } 
  30. 34 }
  1.  1     Person p1 =new Person();
  2.  2         p1.setAge(28);
  3.  3         Person p2 =new Person();
  4.  4         p2.setAge(30);
  5.  5         //调用equals（）方法,
  6.  6         //如果Person没有重写object子类，那就是调用objeck中的方法
  7.  7         //比较的是两个对象的内存地址，没有意思。Person类如果要比较年龄是否相同
  8.  8         //就要重写父类的equals方法
  9.  9         boolean b = p1.equals(p2);    //调用equals方法赋值给b
  10. 10         System.out.println(b);

判断一下汽车的颜色是否一样

  1.  1 package com.orcale.demo01;
  2.  2 
  3.  3 public class car {
  4.  4     private String color;
  5.  5     private int lunzi;
  6.  6     public String getColor() {
  7.  7         return color;
  8.  8     }
  9.  9     public void setColor(String color) {
  10. 10         this.color = color;
  11. 11     }
  12. 12     public int getLunzi() {
  13. 13         return lunzi;
  14. 14     }
  15. 15     public void setLunzi(int lunzi) {
  16. 16         this.lunzi = lunzi;
  17. 17     }
  18. 18     public boolean equals(Object a){
  19. 19         if(this==a){
  20. 20             return true;
  21. 21         }
  22. 22         if(a instanceof car){
  23. 23         car c =(car)a;
  24. 24         return this.color==c.color;
  25. 25         }
  26. 26         return false;
  27. 27     
  28. 28     }
  29. 29 }
  1.     car c1 =new car();
  2.         c1.setColor("红色");
  3.         car c2 =new car();
  4.         c2.setColor("绿色");
  5.         boolean b =c1.equals(c2);
  6.         System.out.println(b);

toString方法

 

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

 

  1. package com.orcale.demo01;
  3. public class dog {
  4.      private String name;
  5.      private String color;
  6.     public String getName() {
  7.         return name;
  8.     }
  9.     public void setName(String name) {
  10.         this.name = name;
  11.     }
  12.     public String getColor() {
  13.         return color;
  14.     }
  15.     public void setColor(String color) {
  16.         this.color = color;
  17.     }
  18.     public String toString(){   重写toString方法，返回名字+颜色
  19.         
  20.         return name+"\t"+color;        
  21.     } 
  22. }
  1. 1         dog d1 = new dog();   
  2. 2         d1.setColor("白色");
  3. 3         dog d2 =new dog();
  4. 4         d2.setColor("黑色");
  5. 5         String d =d1.toString();
  6. 6         System.out.println(d1);
  7. 7         System.out.println(d2);

 

 

版权声明：本文为wangrongchen原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wangrongchen/p/9076267.html