Day11JavaSE——常见对象之Object类

最新推荐文章于 2022-11-13 08:53:50 发布

冰奶茶没有热量

最新推荐文章于 2022-11-13 08:53:50 发布

阅读量193

点赞数

分类专栏： JavaSE 文章标签：字符串 java 编程语言 object

本文链接：https://blog.csdn.net/adAir_liu/article/details/105879708

版权

JavaSE 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Day11JavaSE——常见对象之Object类

文章目录

Day11JavaSE——常见对象之Object类

Object(类)
	public int hashCode()
	public final Class getClass()
	public String toString()
	public boolean equals(Object obj)

API(Application Programming Interface)

Java API
	就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
	我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

Object类

概述 & 构造方法

Object类概述
	类层次结构的根类
	所有类都直接或者间接的继承自该类
构造方法
	public Object()
	回想面向对象中为什么说：
	子类的构造方法默认访问的是父无参构造方法

Object类的hashCode()方法

public int hashCode()
		a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
		b:不同对象的，hashCode()一般来说不会相同。
	  	   但是，同一个对象的hashCode()值肯定相同。
		c:不是对象的实际地址值，可以理解为逻辑地址值。

public class Test {
    public static void main(String[] args) {
        /*API:Application Programming Interface
        * Object类：它是所有类的顶层父类，所有的类都是直接或间接的继承自它
        * 创建Object类的对象
        * java.lang包下的类，无需导包*/
        //new 对象 调方法
        Object obj=new Object();
        //Object类中的常用方法
        System.out.println(obj);
        //获取该对象的哈希码值
        //a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
        //不同对象的，hashCode()一般来说不会相同。
        //但是，同一个对象的hashCode()值肯定相同。
        //不是对象的实际地址值，可以理解为逻辑地址值
        System.out.println(obj.hashCode());
        Object o = new Object();
        System.out.println(o);
        int code=o.hashCode();
        System.out.println(code);
    }
}

Object类的getClass()方法

public class Test {
    public static void main(String[] args) {
        //Java 万物皆对象
        // Object.java-------->Object.class
        //字节码文件 加载进内存后。他会把Object.class这个文件也看做对象。
        //此时会为Object.class文件创建对象 这个对象的类型就是 Class 我们只是把这字节码文件对象调用
        Object o = new Object();
        Class aClass=o.getClass();
        //getClass()获取这个类的字节码文件对象
        System.out.println(o);
        System.out.println(aClass);
        //Object.class文件就一份，当你将字节码文件一加载进内存，就为这个字节码文件创建了一个对象
        //所以无论你用再怎么创建Object类的新对象，在获取字节码文件的对象时
        //都获取的是同一个字节码对象
        Object o1 = new Object();
        Class aClass1=o1.getClass();
        System.out.println(o==o1);//false
        //对象是两个对象，所以对象的地址值不同
        System.out.println(aClass == aClass1);//true
        //对象获取的字节码文件对象地址是一样的，因为只加载一次
        //我们后期学习反射机制的时候，就要用到这个字节码文件对象。
    }
}

Object类的toString()方法

public class Test {
    public static void main(String[] args) {
        Object o = new Object();
        //toString：返回该对象的字符串表现形式
        //按住CTRL点击方法就可以看见源码
        /*这是Java类库中给出的toString的代码实现
        * public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());}
        * 由此可以看出这输出不是内容，而是地址，所以对toString进行重写使其输出内容*/
        //重写在Student中重写了toString方法
        String s=o.toString();
        System.out.println(s);
        Object o1 = new Object();
        System.out.println(o1.toString());
        //toString可以省略不写
        System.out.println(o1);

        //其实有很多类，也重写了Object类的toString()方法
        Scanner scanner = new Scanner(System.in);
        System.out.println(scanner.toString());
        //当你以后，输出一个对象名调用toString方法
        //他输出的不是地址值，说明该类重写了Object类的toString()方法
    }
}

public class Text2 {
    public static void main(String[] args) {
        Student student = new Student();
        //Student.class------->字节码文件对象
        Class aClass=student.getClass();
        System.out.println(aClass);
        int i=student.hashCode();
        System.out.println(i);
        String s=student.toString();
        System.out.println(s);
        System.out.println(student);
        System.out.println(student.toString());
    }
}
public class Student extends Object {
    private String name;
    private int age;

    public Student() {
        System.out.println("Student的空参构造执行了");
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student的有参构造执行了");
    }

    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;
    }

    //对toString()方法进行重写，使其返回内容
    @Override
    public String toString() {
        return "姓名:" + this.name + "=========" + "年龄:" + this.age;
    }

    public String show() {
        return "姓名:" + this.name + "=========" + "年龄:" + this.age;
    }
}

public class test3 {
    public static void main(String[] args) {
        Student student = new Student("张三",23);
        //我们输出一个对象的名称时，默认调用父类的toString()方法，打印该对象的地址值，
        //我们觉得老是打印这个地址值，意义不是很大。
        //我们想要的是，在调用toString方法时
        //能够打印一些我们认为有用的东西。比如打印这个成员变量的值
        //子类对父类Object类的toString()方法的实现不满意了。
        //子类就可以重写。子类想要打印成员变量的值。
        System.out.println(student.toString());
        System.out.println(student);
        String show = student.show();
        System.out.println(show);
    }
}

Object类的equals()方法

==与equals的区别
        /*==是运算符，可以比较基本数据类型，也可以比较引用数据类型
        * ==比较基本数据类型，是比较两个值是否相同
        * ==比较引用数据类型，是比较地址值是否相同
        * equals是Object类中的一个方法，他只能比较引用数据类型
        * 默认比较的是两个对象的地址值是否相同
        * 但是我们自定义的类，或其他的一些类可能会重写equals方法。

public class Test {
    public static void main(String[] args) {
        Object o = new Object();
        Object o1 = new Object();
        //判断两个对象是否相同
        System.out.println(o == o1);
        //我们还可以用Object类中的equal方法来比较来年各个对象的地址值是否相同
        boolean b = o.equals(o1);
        System.out.println(b);
        System.out.println("==============================");
        //使用java提供好的equals（）比较两个对象的地址值是否相等意义不大
        /*这是Java提供的equals方法的源码，从源码可以看出，也是用==判定相等的
        * ==在判断引用类型数据时只能判定左右两边数据的地址是否相同
        * 但是当两个对象中的内容都一样，==就判断不出来了
        *
        * public boolean equals(Object obj) {
    					return (this == obj);
				}
        * */

        Student s1 = new Student("小刘", 23);
        Student s2 = new Student("小刘", 23);
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
        //此处输出都是false，所以我们需要对equals方法进行重写
    }
}

import java.util.Objects;

public class Student extends Object{
    private String name;
    private int age;

    public Student(){
        System.out.println("Student的空参构造访问了");
    }

    public Student(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("Student的有参构造访问了");
    }

    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;
    }

    @Override
    public boolean equals(Object obj) {
        //此处传入的是s2，s2是Student类型的
        //所以用父类类型的数据去接收子类的对象，这是多态
        //把obj向下转型，使其能够访问到age&name

        Student s3 = (Student) obj;

        //23==23  "李四"=="李四"
        //你要比较两个字符串字面上的内容是否相同，用==号比较不出来。
        //我们要比较两个字符串字面上的内容是否相同，要使用equals方法来比较。
        //因为obj是Object类型的，而s2是Student类型的，所以想要访问s2的成员变量，obj得向下转型
        return this.age == s3.age && this.name.equals(s3.name);
    }

   /*//快速重写toString()方法  alt+insert 弹框出来，选个toString() IDEA就会帮你自动重写toString()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);*/
}

Object类的equals()方法代码优化

public class Test2 {
    public static void main(String[] args) {
        System.out.println("================equals重写===============");
        //比较两个对象的成员变量的值是否一样，如果一样认为这两个对象相等。
        //子类对父类equals方法的默认比较方式不满意了。那子类可以按照他的比较方式去重写。
        //我们的子类想要比较两个对象的成员变量值是否一样，需要这么几步
        /*1、比较是否是同对象,比较对象地址值是否相等即可，同一对象地址值相等
        * 2、比较两个类型是否是同一个类，是同一类再执行下一步
        * 3、比较成员变量并返回
        * */
        Teacher t = new Teacher("liu", 23);
        Teacher t1 = new Teacher("liu", 233);
        System.out.println(t = t1);//false
        System.out.println(t.equals(t1));//true
    }
}

import java.util.Objects;

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

    public Teacher() {
        System.out.println("Student的空参构造访问了");
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student的有参构造访问了");
    }

    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;
    }

    /*快速重写equals()方法  alt+insert 弹框出来，选个equals() IDEA就会帮你自动重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() == o.getClass()) return true;
        Teacher teacher = (Teacher) o;
        return age == teacher.age &&
                Objects.equals(name, teacher.name);
    }*/

    @Override
    public boolean equals(Object obj) {
        //地址值相同，同一个对象直接返回true
        if(this==obj) return true;
        //判断是否是Student类型的对象，如果不是，直接报错
        else if(obj instanceof Student) return true;
        //向下转型访问子类的成员变量
        Teacher s3 = (Teacher) obj;
        return (this.age == s3.age) && (this.name.equals(s3.name));
    }
}

Object类的clone() 方法

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Dog dog = new Dog("旺财", 10);
        //克隆一个对象
        //CloneNotSupportedException 克隆不被支持
        //如果你要克隆一个对象，那么这个对象对应的类必须实现一个Cloneable这个接口，克隆才会被支持
        //对象的浅克隆也不会调用到构造方法
        Dog dog2 = (Dog) dog.clone();
        System.out.println(dog2.name);
        System.out.println(dog2.age);

        dog2.name = "黑子";
        dog2.age = 8;
        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog2.name);
        System.out.println(dog2.age);
    }
}

class Dog implements Cloneable {
    String name;
    int age;

    public Dog() {
        System.out.println("空参构造执行了");
    }


    public Dog(String name, int age) {
        System.out.println("有参构造执行了");
        this.age = age;
        this.name = name;
    }

    //我们重写一下Object类的clone()方法把权限修饰符改为public
    //但是重写逻辑还是要用父类的逻辑
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

me;
int age;

public Dog() {
    System.out.println("空参构造执行了");
}


public Dog(String name, int age) {
    System.out.println("有参构造执行了");
    this.age = age;
    this.name = name;
}

//我们重写一下Object类的clone()方法把权限修饰符改为public
//但是重写逻辑还是要用父类的逻辑
@Override
public Object clone() throws CloneNotSupportedException {
    return super.clone();
}

}


![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hZTAxLmFsaWNkbi5jb20va2YvSDAzYzAzMDhiNDZhNTQxZWE5ZWE5MjdjM2UwZTQ2ODU1WC5qcGc?x-oss-process=image/format,png)

冰奶茶没有热量

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day11JavaSE——常见对象之Object类

Day11JavaSE——常见对象之Object类文章目录Day11JavaSE——常见对象之Object类API(Application Programming Interface)Object类概述 & 构造方法Object类的hashCode()方法Object类的getClass()方法Object类的toString()方法Object类的equals()方法Object类的e...
复制链接

扫一扫