Object类入门这一篇就够了！

时间  2019-12-08
标签 object 入门 一篇 够了 繁體版
原文   原文链接

第三阶段 JAVA常见对象的学习

第一章 常见对象——Object类

引言：

在讲解Object类以前，咱们不得不简单的提一下什么是API，先贴一组百度百科的解释：java

API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工做机制的细节。编程

简单的说：就是 Java 中有好多现成的类库，其中封装了许多函数，只提供函数名和参数，但隐藏了函数的具体实现，这些可见的部分做为与外界联系的桥梁，也就是咱们所称的 API ，不过因为Java是开源的，因此这些隐藏的实现咱们也是能够看到的。框架

(一) Object 类的概述

(1) Object是类层次结构的根类，全部的类都隐式的（不用写extends）继承自Object类。ide

(2) Java 全部的对象都拥有Object默认方法函数

(3) Object类的构造方法有一个，而且是无参构造学习

这就对应了前面学习中的一句话，子类构造方法默认访问父类的构造是无参构造测试

咱们须要了解的方法又有哪些呢？this

A: hashCode() B: getClass() C: finalize() D: cloneidea

E: notify() F: notifyAll()线程

咱们须要掌握的方法又有哪些呢？

A: toString() B: equals()

(1) hashCode

返回对象的哈希值（散列码），不是实际地址值，不过能够理解为地址值。

它实际上返回一个int型整数，用于肯定该对象在哈希表中的索引位置

暂时了解便可，学习集合框架内容后将会专篇深刻学习

//Student类

public class Student extends Object {
}
//StudentDemo类

public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.hashCode());

        Student s2 = new Student();
        System.out.println(s2.hashCode());

        Student s3 = s1;
        System.out.println(s3.hashCode());
    }
}

//运行结果：
460141958
1163157884
460141958

(2) getClass

返回对象的字节码文件对象，在反射篇章详细解释, 暂作简单了解。

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        Class c = s.getClass();
        String str = c.getName();
        System.out.println(str);

        //链式编程
        String str2 = s.getClass().getName();
        System.out.println(str2);
    }
}

//运行结果
cn.bwh_02_getClass.Student
cn.bwh_02_getClass.Student

(3) finalize()

在对象将被垃圾回收器清除前调用，但不肯定时间，而且对象的finalize()方法只会被调用一次，调用后也不必定立刻清除该对象。

(4) clone()

以实现对象的克隆，包括成员变量的数据复制，可是它和两个引用指向同一个对象是有区别的。

咱们先来解释一下后半句话

若是咱们想要复制一个变量，能够这样作 Eg：

int a = 20;
int b = a;

那么咱们想要复制一个对象，是否是也能够这样作呢？

//Student

public class Student {
    int age;

    public int getAge() {
        return age;
    }

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

public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(20);
        Student s2 = s1;//将引用赋值
        System.out.println("学生1年龄：" + s1.getAge());
        System.out.println("学生2年龄：" + s2.getAge());
        System.out.println("------------------------------");

        s2.setAge(25);
        System.out.println("学生1年龄：" + s1.getAge());
        System.out.println("学生2年龄：" + s2.getAge());
    }
}

//运行结果
学生1年龄：20
学生2年龄：20
---------------------------
学生1年龄：25
学生2年龄：25

很明显，即便将对象s1赋值给对象s2，可是经过set传值的时候，二者仍然会同时变化，并无起到克隆（独立）的做用，这是由于赋值时只是将存储在栈中，对对象的引用赋值，所以它们两个的引用指向同一个对象（堆中），因此不管如何赋值，只要堆中的对象属性发生了变化，经过引用显示属性的时候，均是相同的。

用法：
  1. 实现Cloneable接口
  2. 重写clone方法
分类：

浅拷贝: 仅拷贝对象,不拷贝成员变量,仅复制了变量的引用,拷贝先后变量使用同一块内存,内存销毁后,必须从新定义(二者同生共死)

深拷贝: 不只拷贝对象,也拷贝成员变量(真正意义上的复制, 二者独立无关)

//浅拷贝

public class Person implements Cloneable{
    private int age = 20;
	
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
//深拷贝

public class Person implements Cloneable {
    public int age = 20;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //拷贝对象
        Person person = (Person) super.clone();
        //拷贝成员变量
        person.age = (int) age.clone();
        //返回拷贝对象
        return person;
    }
}

咱们来利用浅拷贝解决刚开始那个问题

//Person类，写出get、set方法、重写clone方法

//PersonDemo类

public class PersonDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person();
        p1.setAge(20);
        Person p2 = (Person) p1.clone();
        System.out.println("第一我的的年龄："+ p1.getAge() );
        System.out.println("第二我的的年龄："+ p2.getAge() );
        System.out.println("--------------------------");

        p2.setAge(25);
        System.out.println("第一我的的年龄："+ p1.getAge() );
        System.out.println("第二我的的年龄："+ p2.getAge() );
    }
}

运行结果：
第一我的的年龄：20
第二我的的年龄：20
--------------------------
第一我的的年龄：20
第二我的的年龄：25

(5) wait、notify和notifyAll

三者属于线程通讯间的Api，此部分放在往后讲

(6) toString()——重要

public static toString()： 返回该对象的字符串表示

//Student类

public class Student {
    private String name;
    public 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;
    }
}
//StudentDemo类

package cn.bwh_04_toString;

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("admin");
        s.setAge(20);
        //直接输出s也会默认的调用toString方法
        System.out.println(s.toString());
    }
}

//经过set方法赋值后，直接调用toString()

运行结果：
cn.bwh_04_toString.Student@1b6d3586

很明显，给咱们返回这样的信息意义是不大的，因此咱们建议对全部子类重写该方法

//在Student类中重写 toString()

	@Override                                                          
	public String toString() {                                         
		return "Student[" + "name=" + name + ", " + "age=" + age + "]";

//运行结果：
Student[name=admin, age=20]

经过重写toString后，结果按照咱们所定的规则以字符串的形式输出

（重写后会优先使用类中的toString方法）

为何要用它呢？

主要目的仍是为了简化输出

  1. 在类中重写toString()后，输出类对象就变得有了意义（输出s 和 s.toString()是同样的 ，不写也会默认调用），变成了咱们实实在在的信息，而不是上面的cn.bwh_04_toString.Student@1b6d3586。

  2. 若是咱们想要屡次输出 类中的成员信息，就须要屡次书写get方法(每用一次就得写)

    System.out.println("Student[" + "name=" + s.getName() + ", " + "age=" + s.getAge() + "]");

    而调用toString()就简单多了

补充：
//二者等价
toString();
getClass().getName()+ '@' + Integer.toHexString(hashCode())
    
//输出结果
cn.bwh_04_toString.Student@1b6d3586。

(7) equals()——重要

比较两个对象是否相同

默认状况下，比较的是地址值是否相同。

而比较地址值是没有意义的，因此，通常子类也会重写该方法。

在诸多子类，如String、Integer、Date 等均重写了equals()方法

改进思路：

咱们能够将比较地址值转变为比较成员变量

  1. 由于name为String类型，而String类型为引用类型，因此不可以用==比较，应该用equal()

  2. String中默认重写过的equal()方法是用来比较字符串内容是否相同

  3. 咱们要使用的是学生类的成员变量，因此父类 Object不能调用子类Student的特有功能

因此使用向下转型

//重写v1.0
    public boolean equals(Object o) {
        Student s = (Student) o;
        if (this.name.equals(s.name) && this.age == s.age) {
            return true;
        } else {
            return false;
        }
    }
//重写v2.0 (可做为最终版)
    public boolean equals(Object o) {
        if (this.name == o) {
            return true;
        }
        //测试它左边的对象是不是它右边的类的实例，返回 boolean 的数据类型。
        if (!(o instanceof Student)) {
            return false;
        }
        Student s = (Student) o;
        return this.name.equals(s.name) && this.age == s.age;
    }
//idea自动生成版
	@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);
    }
equals() 和 == 的区别

 == 的做用： 　　

基本类型：比较值是否相同 　　

引用类型：比较的就是堆内存地址是否相同

equals 的做用:

引用类型：默认状况下，比较的是地址值。

注：通常选择重写方法，比较对象的成员变量值是否相同 ，不过通常重写都是自动生成。

结尾：

若是内容中有什么不足，或者错误的地方，欢迎你们给我留言提出意见, 蟹蟹你们 ！^_^

若是能帮到你的话，那就来关注我吧！（系列文章均会在公众号第一时间更新）

在这里的咱们素不相识，却都在为了本身的梦而努力 ❤

一个坚持推送原创Java技术的公众号：理想二旬不止

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程