Java基础十四（object类）

最新推荐文章于 2023-02-14 20:05:24 发布

原创最新推荐文章于 2023-02-14 20:05:24 发布 · 298 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java 专栏收录该内容

34 篇文章

订阅专栏

本文深入探讨 Java 中 Object 类的功能及重要性，包括其默认继承特性、提供的通用方法（如 equals 和 toString），以及如何正确地重写 equals 方法来比较对象内容。

java.lang.Object类

1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能（属性、方法）就具有通用性
属性：无
方法：equals（）/toString（）/getClass（）/hashCode()/Clone()/finalize()
4.object类中只声明了一个空参的构造器

public class ObjectTest {
    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.getClass().getSuperclass());
        //class java.lang.Object
    }
}

class Order{

}

== 和 equals()区别

一、使用：
：运算符
1.可以使用在基本数据类型变量的引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体

二、equals（）方法的使用
equals():方法
1.只能适用于引用数据类型
2.object类中equals（）的定义：
public boolean equals(Object obj) {
return (this == obj);
}
说明：object类中定义的equals（）和==作用是相同的：
3.像String、Date、file、包装类等都重写了object类中的equals方法，重写以后比较的不是两个引用的地址是否相同，二十比较两个对象的实体内容是否相同。

4.通常情况下，自定义类如果使用equals（），也通常是比较两个对象的实体内容是否相同。
需要对object类中的equals（）方法进行重写。
重写原则：比较两个对象的实体内容是否相同(即：name和age是否相同)

public class EqualsTest {
    public static void main(String[] args) {
        //基本数据类型
        int i = 10;
        int j = 10;
        double d = 10.0;
        System.out.println(i == j);//true
        System.out.println(i == d);//true

        boolean b = true;
//        System.out.println(i == b);

        char c = 10;
        System.out.println(i == c);//true

        char c1 = 'A';
        char c2 = 65;
        System.out.println(c1 == c2);

        //引用类型
        Customer cust1 = new Customer("Tom", 21);
        Customer cust2 = new Customer("Tom", 21);
        System.out.println(cust1 == cust2);//false
        //比较两个对象地址值是否一样

        String str1 = new String("asdfhg");
        String str2 = new String("asdfhg");
        System.out.println(str1 == str2);//false

        System.out.println("*****************************************************");

        //object中的equals
        System.out.println(cust1.equals(cust2));//false-->true(重写equals方法后变成true)
        //String中的equals
        System.out.println(str1.equals(str2));//true

        Date dat1 = new Date(454545454L);
        Date dat2 = new Date(454545454L);
        System.out.println(dat1.equals(dat2));//true

    }
}

public class Customer {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Customer() {
    }

    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //重写原则：比较两个对象的实体内容是否相同(即：name和age是否相同)
    //手动实现
//    public boolean equals(Object obj){
//
//        System.out.println("customer中重写的方法");
//        if (this == obj){//当前对象和形参引用地址一样
//            return true;
//        }
//
//        if(obj instanceof Customer){
//            Customer cust = (Customer)obj;
//            //比较两个对象的每个属性是否都相同
//            //name  string属于引用类型
//            if(this.age == cust.age && this.name.equals(name)){
//                return true;
//            }else{
//                return false;
//            }
////            //或者
////            return this.age == cust.age && this.name.equals(name);
//        }
//
//        return false;
//    }

    //自动生成
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Customer customer = (Customer) o;
        return age == customer.age &&
                Objects.equals(name, customer.name);
    }


}

练习

编写Order类，有int型的orderId，String型的orderName
相应的getter（）和setter（）方法，两个参数的构造器
重写父类的equals（）方法：public Boolean equals（object obj）
并判断测试类中创建的两个对象是否相等

public class OrderTest {
    public static void main(String[] args) {
        Order order1 = new Order(1001, "AA");
        Order order2 = new Order(1001, "BB");

        System.out.println(order1.equals(order2));//false

        Order order3 = new Order(1001, "BB");
        System.out.println(order2.equals(order3));//true

        Order order4 = new Order(1001, new String("BB"));
        System.out.println(order4.equals(order3));//true

        String s1 = "BB";
        String s2 = "BB";
        System.out.println(s1 == s2);//true
    }
}

class Order{
    private int orderId;
    private String orderName;

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Order(int orderId, String orderName) {
        this.orderId = orderId;
        this.orderName = orderName;
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }

        if (obj instanceof Order){
            Order order = (Order)obj;
            return this.orderId == order.orderId && this.orderName.equals(order.orderName);

//            return this.orderId == order.orderId && this.orderName == orderName;

        }
        return false;
    }


}

练习

写一个测试类，创建两个Circle对象，判断其颜色是否相等
利用equals方法判断其半径是否相等，利用toString（）方法输出其半径

public class CircleTest {
    public static void main(String[] args) {

        Circle circle1 = new Circle(2.3);
        Circle circle2 = new Circle(3.3, "white", 2.0);

        System.out.println("颜色是否相等：" + circle1.getColor().equals(circle2.getColor()));//true

        System.out.println("半径是否相等：" + circle1.equals(circle2));//false

        System.out.println(circle1);//Circle{radius=2.3}

    }
}

public class Circle extends GeometricObject{

    private double radius;

    public Circle() {
        super();
        radius = 1.0;
//        color = "white";
//        weight = 1.0;
    }

    public Circle(double radius) {
        super();
        this.radius = radius;
    }

    public Circle(double radius, String color, double weight) {
        super(color, weight);
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    //求圆的面积
    public double findArea(){
        return radius * radius;
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if(obj instanceof Circle){
            Circle c = (Circle)obj;
            return this.radius == c.radius;
        }
        return false;
    }

    @Override
    public String toString() {
        return "Circle{" + "radius=" + radius + '}';
    }
}

public class GeometricObject {

    protected String color;
    protected double weight;

    public GeometricObject() {
        super();
        this.color = "white";
        this.weight = 1.0;
    }

    public GeometricObject(String color, double weight) {
        this.color = color;
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}