java一对一视频 实现 java类与对象视频

文章目录

• Object类

• equals（平等的；相等的）方法

• ==和equals的对比[面试题]
• 如何重写equals方法

• 应用实例

• 练习

• hashCode方法
• toString方法
• finalize方法

Object类

lang包是默认引入的，所以Object里面的方法可以直接使用

类Object是类层次结构的根类。每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法

equals（平等的；相等的）方法

==和equals的对比[面试题]

==是一个比较运算符，不是方法
1. ==：既可以判断基本类型，又可以判断引用类型
2. ==：如果判断基本类型，判断的是值是否相等。示例：int i = 10; double d = 10.0;
3. ==：如果判断引用类型，判断的是地址是否相等，及判定是不是同一个对象[案例说明]

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

        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);//true
        System.out.println(b == c);//true

        B bobject = a;
        System.out.println(bobject == c);//true
    }
}
class B{ }
class A extends B{ }

4. equals：是Object类中的方法，只能判断引用类型

"hello".equals("abc");

5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer，String[看看String和Integer的equals源代码]

**Object类的equals源码**
 public boolean equals(Object obj) {
        return (this == obj);比较对象的地址是否相同，也就是判断两个对象是不是同一个对象
    }

**String类的equals源码**
**把Object的equals方法重写，变成了比较两个字符串的值是否相同**
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;//向下转型
            int n = value.length;					//长度算出来
            if (n == anotherString.value.length) {	//如果长度相等
                char v1[] = value;					//转成char数组
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {				//循环
                    if (v1[i] != v2[i])			//一个一个的比较字符
                        return false;			//有一个不相同就返回false，说明字符串不相等
                    i++;
                }
                return true;		//如果两个字符串的所有字符都相等，返回true
            }
        }
        return false;	//如果比较的不是字符串，直接返回false
    }

**Integer类的equals源码**
public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

如何重写equals方法

应用实例

判断两个Person对象的内容是否相等，如果两个Person对象的各个属性值都一样，则返回true，反之false

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

        Person person1 = new Person("jack",18,'男');
        Person person2 = new Person("jack",18,'男');

        //System.out.println(person1.equals(person2));不重写equals方法返回false
        System.out.println(person1.equals(person2));//true

        Person person3 = new Person("tom",18,'男');
        System.out.println(person3.equals(person2));//false
    }
}
class Person{
    private String name;
    private int age;
    private char gender;

    //重写Object的equals方法
    public boolean equals(Object obj){
        //如果比较的两个对象是同一个对象，则直接返回true
        if(this == obj){
            return true;
        }
        if(obj instanceof Person) {
            //类型转换---向下转型
            Person p = (Person)obj;//因为需要得到obj的各个属性
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }

        return false;

    }
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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 char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}

练习

hashCode方法

1.提高具有哈希结构的容器的效率
2.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
3.两个引用，如果指向的是不同对象，则哈希值是不一样的
4.哈希值主要根据地址号来的，但不能完全将哈希值等价于地址
5.在集合中hashCode如果需要的话，会重写

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

        AA aa1 = new AA();
        AA aa2 = new AA();
        AA aa3 = aa2;
        System.out.println("aa1.hashCode() = " + aa1.hashCode());aa1.hashCode()=1163157884
        System.out.println("aa2.hashCode() = " + aa2.hashCode());aa2.hashCode()=1956725890
        System.out.println("aa3.hashCode() = " + aa3.hashCode());aa3.hashCode()=1956725890
    }
}
class AA{}

toString方法

基本介绍：
1.默认返回：全类名+@+哈希值的十六进制【查看Object的toString方法】

2.重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式

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

        Monster monster = new Monster("小妖怪","巡山的",1000);
        System.out.println(monster.toString() + " hashCode=" + monster.hashCode());
    }
}

class Monster{
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }
    //重写toString方法，输出对象的属性
    //使用快捷键即可 Alt+insert -> toString
    @Override
    public String toString() {  //重写后，一般是把对象的属性值输出，也可以自己设计
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }
}

Monster{name=‘小妖怪’, job=‘巡山的’, sal=1000.0} hashCode=1163157884

3.当直接输出一个对象时，toString方法会被默认的调用

finalize方法

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

        Car bmw = new Car("宝马");
        bmw = null;//这是Car对象没有任何引用变成垃圾，垃圾回收器会回收(销毁)对象
        //在销毁对象前，会调用该对象的finalize方法
        //程序员可以在finalize中，写自己的业务逻辑代码(比如释放资源：数据库连接，或者打开文件)
        //如果程序员不重写finalize，那么就会调用Object类的finalize方法，即默认处理

        System.gc();//主动调用垃圾回收器
        System.out.println("程序退出.....");
    }
}

class Car{
    private String name;

    public Car(String name) {
        this.name = name;
    }

    //重写finalize方法
    @Override
    protected void finalize() throws Throwable {
        System.out.println("销毁汽车 " + name);
        System.out.println("释放对象资源");
    }
}

程序退出…
销毁汽车 宝马
释放对象资源