斗牌德州扑克游戏平台 当前位置:首页>斗牌德州扑克游戏平台>正文

斗牌德州扑克游戏平台

发布时间:2018-11-16

原标题:JDK1.8源码(一)——java.lang.Object类

JDK1.8源码(一)——java.lang.Object类


  本系列博客将对JDK1.8版本的相关类从源码层次进行介绍,JDK8的下载地址。

  首先介绍JDK中所有类的基类——java.lang.Object。

  Object 类属于 java.lang 包,此包下的所有类在使用时无需手动导入,系统会在程序编译期间自动导入。Object 类是所有类的基类,当一个类没有直接继承某个类时,默认继承Object类,也就是说任何类都直接或间接继承此类,Object 类中能访问的方法在所有类中都可以调用,下面我们会分别介绍Object 类中的所有方法。

1、Object 类的结构图

   

  Object.class类

 1 /*
 2  * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
 3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 4  *
 5  */
 6 
 7 package java.lang;
 8 
 9 /**
10  * Class {@code Object} is the root of the class hierarchy.
11  * Every class has {@code Object} as a superclass. All objects,
12  * including arrays, implement the methods of this class.
13  *
14  * @author  unascribed
15  * @see     java.lang.Class
16  * @since   JDK1.0
17  */
18 public class Object {
19 
20     private static native void registerNatives();
21     static {
22         registerNatives();
23     }
24 
25     public final native Class<?> getClass();
26 
27     public native int hashCode();
28 
29     public boolean equals(Object obj) {
30         return (this == obj);
31     }
32 
33     protected native Object clone() throws CloneNotSupportedException;
34     
35     public String toString() {
36         return getClass().getName() + "@" + Integer.toHexString(hashCode());
37     }
38 
39     public final native void notify();
40     
41     public final native void notifyAll();
42     
43     public final native void wait(long timeout) throws InterruptedException;
44     
45     public final void wait(long timeout, int nanos) throws InterruptedException {
46         if (timeout < 0) {
47             throw new IllegalArgumentException("timeout value is negative");
48         }
49         if (nanos < 0 || nanos > 999999) {
50             throw new IllegalArgumentException(
51                     "nanosecond timeout value out of range");
52         }
53         if (nanos > 0) {
54             timeout++;
55         }
56         wait(timeout);
57     }
58     
59     public final void wait() throws InterruptedException {
60         wait(0);
61     }
62     
63     protected void finalize() throws Throwable { }
64 }
View Code

2、 为什么java.lang包下的类不需要手动导入?

  不知道大家注意到没,我们在使用诸如Date类时,需要手动导入import java.util.Date,再比如使用File类时,也需要手动导入import java.io.File。但是我们在使用Object类,String 类,Integer类等不需要手动导入,而能直接使用,这是为什么呢?

  这里先告诉大家一个结论:使用 java.lang 包下的所有类,都不需要手动导入。

  另外我们介绍一下Java中的两种导包形式,导包有两种方法:

  ①、单类型导入(single-type-import),例如import java.util.Date

  ②、按需类型导入(type-import-on-demand),例如import java.util.*

  单类型导入比较好理解,我们编程所使用的各种工具默认都是按照单类型导包的,需要什么类便导入什么类,这种方式是导入指定的public类或者接口;

  按需类型导入,比如 import java.util.*,可能看到后面的 *,大家会以为是导入java.util包下的所有类,其实并不是这样,我们根据名字按需导入要知道他是按照需求导入,并不是导入整个包下的所有类。

  Java编译器会从启动目录(bootstrap),扩展目录(extension)和用户类路径下去定位需要导入的类,而这些目录进仅仅是给出了类的顶层目录,编译器的类文件定位方法大致可以理解为如下公式: 

顶层路径名  包名  文件名.class = 绝对路径

  单类型导入我们知道包名和文件名,所以编译器可以一次性查找定位到所要的类文件。按需类型导入则比较复杂,编译器会把包名和文件名进行排列组合,然后对所有的可能性进行类文件查找定位。例如:  

package com;

import java.io.*;

import java.util.*;

  如果我们文件中使用到了 File 类,那么编译器会根据如下几个步骤来进行查找 File 类:

  ①、File       // File类属于无名包,就是说File类没有package语句,编译器会首先搜索无名包

  ②、com.File     // File类属于当前包,就是我们当前编译类的包路径

  ③、java.lang.File   //由于编译器会自动导入java.lang包,所以也会从该包下查找

  ④、java.io.File

  ⑤、java.util.File

  ......

  需要注意的地方就是,编译器找到java.io.File类之后并不会停止下一步的寻找,而要把所有的可能性都查找完以确定是否有类导入冲突。假设此时的顶层路径有三个,那么编译器就会进行3*5=15次查找。

  如果在查找完成后,编译器发现了两个同名的类,那么就会报错。要删除你不用的那个类,然后再编译。

  所以我们可以得出这样的结论:按需类型导入是绝对不会降低Java代码的执行效率的,但会影响到Java代码的编译速度。所以我们在编码时最好是使用单类型导入,这样不仅能提高编译速度,也能避免命名冲突。

  讲清楚Java的两种导包类型了,我们在回到为什么可以直接使用 Object 类,看到上面查找类文件的第③步,编译器会自动导入 java.lang 包,那么当然我们能直接使用了。至于原因,因为用的多,提前加载了,省资源。

3、类构造器

  我们知道类构造器是创建Java对象的途径之一,通过new 关键字调用构造器完成对象的实例化,还能通过构造器对对象进行相应的初始化。一个类必须要有一个构造器的存在,如果没有显示声明,那么系统会默认创造一个无参构造器,在JDK的Object类源码中,是看不到构造器的,系统会自动添加一个无参构造器。我们可以通过:

   Object obj = new Object();构造一个Object类的对象。

4、equals 方法

  通常很多面试题都会问 equals() 方法和 == 运算符的区别,== 运算符用于比较基本类型的值是否相同,或者比较两个对象的引用是否相等,而 equals 用于比较两个对象是否相等,这样说可能比较宽泛,两个对象如何才是相等的呢?这个标尺该如何定?

  我们可以看看 Object 类中的equals 方法:

    public boolean equals(Object obj) {
        return (this == obj);
    }
View Code

  可以看到,在 Object 类中,== 运算符和 equals 方法是等价的,都是比较两个对象的引用是否相等,从另一方面来讲,如果两个对象的引用相等,那么这两个对象一定是相等的。对于我们自定义的一个对象,如果不重写 equals 方法,那么在比较对象的时候就是调用 Object 类的 equals 方法,也就是用 == 运算符比较两个对象。我们可以看看 String 类中的重写的 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 v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
View Code

  String 是引用类型,比较时不能比较引用是否相等,重点是字符串的内容是否相等。所以 String 类定义两个对象相等的标准是字符串内容都相同

  在Java规范中,对 equals 方法的使用必须遵循以下几个原则:

  ①、自反性:对于任何非空引用值 x,x.equals(x) 都应返回 true。

  ②、对称性:对于任何非空引用值 x 和 y,当且仅当 y.equals(x) 返回 true 时,x.equals(y) 才应返回 true。 

  ③、传递性:对于任何非空引用值 x、y 和 z,如果 x.equals(y) 返回 true,并且 y.equals(z) 返回 true,那么 x.equals(z) 应返回 true。

  ④、一致性:对于任何非空引用值 x 和 y,多次调用 x.equals(y) 始终返回 true 或始终返回 false,前提是对象上 equals 比较中所用的信息没有被修改

  ⑤、对于任何非空引用值 x,x.equals(null) 都应返回 false。

  下面我们自定义一个 Person 类,然后重写其equals 方法,比较两个 Person 对象:

 1 package com.ys.bean;
 2 /**
 3  * Create by vae
 4  */
 5 public class Person {
 6     private String pname;
 7     private int page;
 8 
 9     public Person(){}
10 
11     public Person(String pname,int page){
12         this.pname = pname;
13         this.page = page;
14     }
15     public int getPage() {
16         return page;
17     }
18 
19     public void setPage(int page) {
20         this.page = page;
21     }
22 
23     public String getPname() {
24         return pname;
25     }
26 
27     public void setPname(String pname) {
28         this.pname = pname;
29     }
30     @Override
31     public boolean equals(Object obj) {
32         if(this == obj){//引用相等那么两个对象当然相等
33             return true;
34         }
35         if(obj == null || !(obj instanceof  Person)){//对象为空或者不是Person类的实例
36             return false;
37         }
38         Person otherPerson = (Person)obj;
39         if(otherPerson.getPname().equals(this.getPname()) && otherPerson.getPage()==this.getPage()){
40             return true;
41         }
42         return false;
43     }
44 
45     public static void main(String[] args) {
46         Person p1 = new Person("Tom",21);
47         Person p2 = new Person("Marry",20);
48         System.out.println(p1==p2);//false
49         System.out.println(p1.equals(p2));//false
50 
51         Person p3 = new Person("Tom",21);
52         System.out.println(p1.equals(p3));//true
53     }
54 
55 }
View Code

  通过重写 equals 方法,我们自定义两个对象相等的标尺为Person对象的两个属性都相等,则对象相等,否则不相等。如果不重写 equals 方法,那么始终是调用 Object 类的equals 方法,也就是用 == 比较两个对象在栈内存中的引用地址是否相等。

   这时候有个Person 类的子类 Man,也重写了 equals 方法:

 1 package com.ys.bean;
 2 /**
 3  * Create by vae
 4  */
 5 public class Man extends Person{
 6     private String sex;
 7 
 8     public Man(String pname,int page,String sex){
 9         super(pname,page);
10         this.sex = sex;
11     }
12     @Override
13     public boolean equals(Object obj) {
14         if(!super.equals(obj)){
15             return false;
16         }
17         if(obj == null || !(obj instanceof  Man)){//对象为空或者不是Person类的实例
18             return false;
19         }
20         Man man = (Man) obj;
21         return sex.equals(man.sex);
22     }
23 
24     public static void main(String[] args) {
25         Person p = new Person("Tom",22);
26         Man m = new Man("Tom",22,"男");
27 
28         System.out.println(p.equals(m));//true
29         System.out.println(m.equals(p));//false
30     }
31 }
View Code

  通过打印结果我们发现 person.equals(man)得到的结果是 true,而man.equals(person)得到的结果却是false,这显然是不正确的。

  问题出现在 instanceof 关键字上,关于 instanceof 关键字的用法,可以参考我的这篇文章:http://www.cnblogs.com/ysocean/p/8486500.html

  Man 是 Person 的子类,person instanceof Man 结果当然是false。这违反了我们上面说的对称性。

  实际上用 instanceof 关键字是做不到对称性的要求的。这里推荐做法是用 getClass()方法取代 instanceof 运算符。getClass() 关键字也是 Object 类中的一个方法,作用是返回一个对象的运行时类,下面我们会详细讲解。

  那么 Person 类中的 equals 方法为:

    public boolean equals(Object obj) {
        if(this == obj){//引用相等那么两个对象当然相等
            return true;
        }
        if(obj == null || (getClass() != obj.getClass())){//对象为空或者不是Person类的实例
            return false;
        }
        Person otherPerson = (Person)obj;
        if(otherPerson.getPname().equals(this.getPname()) && otherPerson.getPage()==this.getPage()){
            return true;
        }
        return false;
    }
View Code

  打印结果 person.equals(man)得到的结果是 false,man.equals(person)得到的结果也是false,满足对称性。

  注意:使用 getClass 不是绝对的,要根据情况而定,毕竟定义对象是否相等的标准是由程序员自己定义的。而且使用 getClass 不符合多态的定义,比如 AbstractSet 抽象类,它有两个子类 TreeSet 和 HashSet,他们分别使用不同的算法实现查找集合的操作,但无论集合采用哪种方式实现,都需要拥有对两个集合进行比较的功能,如果使用 getClass 实现equals方法的重写,那么就不能在两个不同子类的对象进行相等的比较。而且集合类比较特殊,其子类是不需要自定义相等的概念的。

  所以什么时候使用 instanceof 运算符,什么时候使用 getClass() 有如下建议:

  ①、如果子类能够拥有自己的相等概念,则对称性需求将强制采用 getClass 进行检测。

  ②、如果有超类决定相等的概念,那么就可以使用 instanceof 进行检测,这样可以在不同的子类的对象之间进行相等的比较。

  下面给出一个完美的 equals 方法的建议:

  1、显示参数命名为 otherObject,稍后会将它转换成另一个叫做 other 的变量。

  2、判断比较的两个对象引用是否相等,如果引用相等那么表示是同一个对象,那么当然相等

  3、如果 otherObject 为 null,直接返回false,表示不相等

  4、比较 this 和 otherObject 是否是同一个类:如果 equals 的语义在每个子类中有所改变,就使用 getClass 检测;如果所有的子类都有统一的定义,那么使用 instanceof 检测

  5、将 otherObject 转换成对应的类类型变量

  6、最后对对象的属性进行比较。使用 == 比较基本类型,使用 equals 比较对象。如果都相等则返回true,否则返回false。注意如果是在子类中定义equals,则要包含 super.equals(other)

  下面我们给出 Person 类中完整的 equals 方法的书写:

 1     @Override
 2     public boolean equals(Object otherObject) {
 3         //1、判断比较的两个对象引用是否相等,如果引用相等那么表示是同一个对象,那么当然相等
 4         if(this == otherObject){
 5             return true;
 6         }
 7         //2、如果 otherObject 为 null,直接返回false,表示不相等
 8         if(otherObject == null ){//对象为空或者不是Person类的实例
 9             return false;
10         }
11         //3、比较 this 和 otherObject 是否是同一个类(注意下面两个只能使用一种)
12         //3.1:如果 equals 的语义在每个子类中所有改变,就使用 getClass 检测
13         if(this.getClass() != otherObject.getClass()){
14             return false;
15         }
16         //3.2:如果所有的子类都有统一的定义,那么使用 instanceof 检测
17         if(!(otherObject instanceof Person)){
18             return false;
19         }
20 
21         //4、将 otherObject 转换成对应的类类型变量
22         Person other = (Person) otherObject;
23 
24         //5、最后对对象的属性进行比较。使用 == 比较基本类型,使用 equals 比较对象。如果都相等则返回true,否则返回false
25         //   使用 Objects 工具类的 equals 方法防止比较的两个对象有一个为 null而报错,因为 null.equals() 是会抛异常的
26         return Objects.equals(this.pname,other.pname) && this.page == other.page;
27 
28         //6、注意如果是在子类中定义equals,则要包含 super.equals(other)
29         //return super.equals(other) && Objects.equals(this.pname,other.pname) && this.page == other.page;
30 
31     }
View Code

  请注意,无论何时重写此方法,通常都必须重写hashCode方法,以维护hashCode方法的一般约定,该方法声明相等对象必须具有相同的哈希代码。hashCode 也是 Object 类中的方法,后面会详细讲解。

5、getClass 方法 

  上面我们在介绍 equals 方法时,介绍如果 equals 的语义在每个子类中有所改变,那么使用 getClass 检测,为什么这样说呢?

  getClass()在 Object 类中如下,作用是返回对象的运行时类。

public final native Class<?> getClass();

  这是一个用 native 关键字修饰的方法,关于 native 关键字的详细介绍如下:http://www.cnblogs.com/ysocean/p/8476933.html

  这里我们要知道用 native 修饰的方法我们不用考虑,由操作系统帮我们实现,该方法的作用是返回一个对象的运行时类,通过这个类对象我们可以获取该运行时类的相关属性和方法。也就是Java中的反射,各种通用的框架都是利用反射来实现的,这里我们不做详细的描述。

  这里详细的介绍 getClass 方法返回的是一个对象的运行时类对象,这该怎么理解呢?Java中还有一种这样的用法,通过 类名.class 获取这个类的类对象 ,这两种用法有什么区别呢?

  父类:Parent.class

public class Parent {}

  子类:Son.class

public class Son extends Parent{}

  测试:

@Test
public void testClass(){
    Parent p = new Son();
    System.out.println(p.getClass());
    System.out.println(Parent.class);
}
View Code

  打印结果:

  

  结论:class 是一个类的属性,能获取该类编译时的类对象,而 getClass() 是一个类的方法,它是获取该类运行时的类对象。

  还有一个需要大家注意的是,虽然Object类中getClass() 方法声明是:public final native Class<?> getClass();返回的是一个 Class<?>,但是如下是能通过编译的:

Class<? extends String> c = "".getClass();

  也就是说类型为T的变量getClass方法的返回值类型其实是Class<? extends T>而非getClass方法声明中的Class<?>。

  这在官方文档中也有说明:https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#getClass--

6、hashCode 方法

  hashCode 在 Object 类中定义如下:

public native int hashCode();

  这也是一个用 native 声明的本地方法,作用是返回对象的散列码,是 int 类型的数值。

  那么这个方法存在的意义是什么呢?

  我们知道在Java 中有几种集合类,比如 List,Set,还有 Map,List集合一般是存放的元素是有序可重复的,Set 存放的元素则是无序不可重复的,而 Map 集合存放的是键值对。

  前面我们说过判断一个元素是否相等可以通过 equals 方法,没增加一个元素,那么我们就通过 equals 方法判断集合中的每一个元素是否重复,但是如果集合中有10000个元素了,但我们新加入一个元素时,那就需要进行10000次equals方法的调用,这显然效率很低。

  于是,Java 的集合设计者就采用了 哈希表 来实现。关于哈希表的数据结构我有过介绍。哈希算法也称为散列算法,是将数据依特定算法产生的结果直接指定到一个地址上。这个结果就是由 hashCode 方法产生。这样一来,当集合要添加新的元素时,先调用这个元素的 hashCode 方法,就一下子能定位到它应该放置的物理位置上。

  ①、如果这个位置上没有元素,它就可以直接存储在这个位置上,不用再进行任何比较了;

  ②、如果这个位置上已经有元素了,就调用它的equals方法与新元素进行比较,相同的话就不存了;

  ③、不相同的话,也就是发生了Hash key相同导致冲突的情况,那么就在这个Hash key的地方产生一个链表,将所有产生相同HashCode的对象放到这个单链表上去,串在一起(很少出现)。这样一来实际调用equals方法的次数就大大降低了,几乎只需要一两次。

  

  这里有 A,B,C,D四个对象,分别通过 hashCode 方法产生了三个值,注意 A 和 B 对象调用 hashCode 产生的值是相同的,即 A.hashCode() = B.hashCode() = 0x001,发生了哈希冲突,这时候由于最先是插入了 A,在插入的B的时候,我们发现 B 是要插入到 A 所在的位置,而 A 已经插入了,这时候就通过调用 equals 方法判断 A 和 B 是否相同,如果相同就不插入 B,如果不同则将 B 插入到 A 后面的位置。所以对于 equals 方法和 hashCode 方法有如下要求:

  一、hashCode 要求

  ①、在程序运行时期间,只要对象的(字段的)变化不会影响equals方法的决策结果,那么,在这个期间,无论调用多少次hashCode,都必须返回同一个散列码。

  ②、通过equals调用返回true 的2个对象的hashCode一定一样。

  ③、通过equasl返回false 的2个对象的散列码不需要不同,也就是他们的hashCode方法的返回值允许出现相同的情况。

  因此我们可以得到如下推论:

  两个对象相等,其 hashCode 一定相同;

  两个对象不相等,其 hashCode 有可能相同;

  hashCode 相同的两个对象,不一定相等;

  hashCode 不相同的两个对象,一定不相等;

   这四个推论通过上图可以更好的理解。

  可能会有人疑问,对于不能重复的集合,为什么不直接通过 hashCode 对于每个元素都产生唯一的值,如果重复就是相同的值,这样不就不需要调用 equals 方法来判断是否相同了吗?
  实际上对于元素不是很多的情况下,直接通过 hashCode 产生唯一的索引值,通过这个索引值能直接找到元素,而且还能判断是否相同。比如数据库存储的数据,ID 是有序排列的,我们能通过 ID 直接找到某个元素,如果新插入的元素 ID 已经有了,那就表示是重复数据,这是很完美的办法。但现实是存储的元素很难有这样的 ID 关键字,也就很难这种实现 hashCode 的唯一算法,再者就算能实现,但是产生的 hashCode 码是非常大的,这会大的超过 Java 所能表示的范围,很占内存空间,所以也是不予考虑的。

  二、hashCode 编写指导:

  ①、不同对象的hash码应该尽量不同,避免hash冲突,也就是算法获得的元素要尽量均匀分布。

  ②、hash 值是一个 int 类型,在Java中占用 4 个字节,也就是 232 次方,要避免溢出。

  在 JDK 的 Integer类,Float 类,String 类等都重写了 hashCode 方法,我们自定义对象也可以参考这些类来写。

  下面是 JDK String 类的hashCode 源码:

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }
View Code

  再次提醒大家,对于 Map 集合,我们可以选取Java中的基本类型,还有引用类型 String 作为 key,因为它们都按照规范重写了 equals 方法和 hashCode 方法。但是如果你用自定义对象作为 key,那么一定要覆写 equals 方法和 hashCode 方法,不然会有意想不到的错误产生。

7、toString 方法

  该方法在 JDK 的源码如下:

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

  getClass().getName()是返回对象的全类名(包含包名),Integer.toHexString(hashCode()) 是以16进制无符号整数形式返回此哈希码的字符串表示形式。

  打印某个对象时,默认是调用 toString 方法,比如 System.out.println(person),等价于 System.out.println(person.toString())

8、notify()/notifyAll()/wait()

  这是用于多线程之间的通信方法,在后面讲解多线程会详细描述,这里就不做讲解了。

9、finalize 方法

protected void finalize() throws Throwable { }

  该方法用于垃圾回收,一般由 JVM 自动调用,一般不需要程序员去手动调用该方法。后面再讲解 JVM 的时候会详细展开描述。

10、registerNatives 方法 

  该方法在 Object 类中定义如下:

private static native void registerNatives();

  这是一个本地方法,在 native 介绍 中我们知道一个类定义了本地方法后,想要调用操作系统的实现,必须还要装载本地库,但是我们发现在 Object.class 类中具有很多本地方法,但是却没有看到本地库的载入代码。而且这是用 private 关键字声明的,在类外面根本调用不了,我们接着往下看关于这个方法的类似源码:

    static {
        registerNatives();
    }

  看到上面的代码,这就明白了吧。静态代码块就是一个类在初始化过程中必定会执行的内容,所以在类加载的时候是会执行该方法的,通过该方法来注册本地方法。

  

  参考文档:https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html  

当前文章:http://www.radiokey.biz/list/9emmo.html

发布时间:2018-11-16 13:30:03

捕鱼电玩城平台 电脑单机翻牌机 电玩城射击游戏 街机水果机游戏下载 可提现提现棋牌游戏 棋牌娱乐赚钱 手机赌钱的游戏 双扣游戏大厅下载 四川皮皮麻将安卓下截 赚钱棋牌游戏下载注册送金

11153 94259 28865 99676 20732 7189912452 47417 86131

责任编辑:通公秉宗

随机推荐