Java面向对象编程进阶（四）

本篇文章分享Java面向对象编程进阶（四），对你有帮助的话记得收藏一下，看Java资料网收获更多编程知识

---

一、equals()方法的使用

适用性：任何引用数据都可以使用。

自定义的类在没有重写Object中equals()方法的情况下，调用的就是Object类中声明的equals()，比较两个对象的引用地址是否相同。(或比较两个对象是否指向了堆空间中的同一个对象实体)。

开发中使用说明:

实际开发中，针对于自定义的类，常常会判断两个对象是否equals()，而此时主要是判断两个对象的属性值是否相等。所以:我们要重写Object类的equals()方法。

package exec.equals;

/**
 * package:exec.equals
 *
 * @Author jimmy-yan
 * @Create 2024/10/24 20:48
 */
public class UserTest {
    public static void main(String[] args) {
        User u1=new User("tom",12);
        User u2=new User("tom",12);

        System.out.println(u1.equals(u2));   //false  判断地址值是否相等
    }
}

class User {
    String name;
    int age;

    public User() {

    }

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

面试题：区分==和equals()的区别
==:运算符

使用范围：基本数据类型、引用数据类型
基本数据类型：判断数据值是否相等
引用数据类型：比较两个引用变量的地址值是否相等

equals()：方法

使用范围：引用数据类型
具体使用：对于类来说重写equals()和不写equals()的区别

package exec.equals;

import java.util.Objects;

/**
 * package:exec.equals
 *
 * @Author jimmy-yan
 * @Create 2024/10/24 20:48
 */
public class UserTest {
    public static void main(String[] args) {
        User u1=new User("tom",12);
        User u2=new User("tom",12);

        System.out.println(u1.equals(u2));   //true
    }
}

class User {
    String name;
    int age;

    public User() {

    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
	
	//重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }

}

二、toString()方法的使用

平时我们在调用System.out.println()打印对象引用变量时，其实就调用了对象的toString()

自定义的类，在没有重写Object类的toString()的情况下，默认返回的是当前对象的地址值。
像String、File、Date或包装类等Object的子类，它们都重写了Object类的toString()，在调用toString()时，返回当前对象的实体内容。

习惯上，开发中对于自定义的类在调用toString()时，也希望显示其对象的实体内容，而非地址值。这时候，就需要重写0bject类中的toString()

package toString;

/**
 * package:toString
 *
 * @Author jimmy-yan
 * @Create 2024/10/25 14:01
 */
public class toStringTest {
    public static void main(String[] args) {
        User u1 = new User("tom",12);
        System.out.println(u1.toString());     //todo toString.User@6a5fc7f7
        System.out.println(u1);               //todo toString.User@6a5fc7f7
    }

}

class User{
    String name;
    int age;

    public User() {
    }

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

重写toString()方法

package toString;

/**
 * package:toString
 *
 * @Author jimmy-yan
 * @Create 2024/10/25 14:01
 */
public class toStringTest {
    public static void main(String[] args) {
        User u1 = new User("tom", 12);
//        System.out.println(u1.toString());     //todo toString.User@6a5fc7f7
//        System.out.println(u1);               //todo toString.User@6a5fc7f7


        System.out.println(u1.toString());     //todo User{name='tom', age=12}
        System.out.println(u1);                //todo User{name='tom', age=12}
    }

}

class User {
    String name;
    int age;

    public User() {
    }


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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

案例：定义两个类，父类Geometric0bject代表几何形状，子类Circle代表圆形。
写一个测试类，创建两个Circle对象，判断其颜色是否相等;利用equals方法判断其半径是否相等；利用toString()方法输出其半径。

package toString;

/**
 * package:toString
 *
 * @Author jimmy-yan
 * @Create 2024/10/25 14:29
 */
public class GeometricObject {
    protected String color;
    protected double weight;

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

package toString;

/**
 * package:toString
 *
 * @Author jimmy-yan
 * @Create 2024/10/25 14:32
 */
public class Circle extends GeometricObject {
    private double radius;

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

    public Circle(double radius) {
//        color="white";
//        weight=1.0;
        this.radius = radius;
    }

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

    public double getRadius() {
        return radius;
    }

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

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

    //重写equals

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Circle circle = (Circle) o;
        return Double.compare(circle.radius, radius) == 0;
    }

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

package toString;

/**
 * package:toString
 *
 * @Author jimmy-yan
 * @Create 2024/10/25 14:42
 */
public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle(2.3);

        Circle c2 = new Circle("red",2.0,2.4);

        System.out.println(c1.getColor().equals(c2.getColor()));  //false

        System.out.println(c1.equals(c2));   //false


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


    }
}

三、复习

this关键字的使用

this可以调用属性、方法；构造器
this调用属性或者方法时，理解为当前对象或者正在创建的对象

public void setName(String name){ //当属性名和形参名相同时，必须使用this来区分
	this.name=name;
}

public Person(String name){
	this.name=name
}

this(形参列表)的方式，表示调用当前类中其他的重载的构造器。

继承性：
继承性的好处：

减少了代码的冗余，提高了复用性；
提高了拓展性

java中继承性的特点：

单继承性，一个类只能继承一个父类
支持多层继承

基础：class A extend B{}
理解：子类就获取了父类中声明的全部的属性和方法。可能受封装性的影响不能直接调用。

方法的重写（override和overwrite）
方法的重载和重写的区别

重载：两同一不同
重写：

前提：类的继承关系
子类对父类中同名参数方法的覆盖、覆写。

super的使用

super可以调用的结构：属性、方法、构造器
super：父类的
super调用属性和方法

a、如果子父类中出现了同名的属性，此时使用super.的方式，表明调用的是父类中声明的属性（有权限的情况）。
b、子类重写了父类的方法，如果子类的任何一个方法中需要调用父类被重写的方法时，需要使用super.

super调用构造器：

在子类的构造器中，首行要么使用了”this(形参列表)“，要么使用了”super(形参列表)“。

子类对象实例化过程（熟悉）
从结果说：体现为继承性
从过程说：子类调用构造器创建对象时，一定会直接或间接的调用父类的构造器
以及父类的父类的构造器…，直到调用到Object()的构造器。

文章来源:https://blog.csdn.net/YZL40514131/article/details/143235057
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！