精华内容
下载资源
问答
  • 2021-03-05 17:35:15

    1.clone方法

    保护方法,实现对象的浅复制,只有实现了Cloneable接口才可以调用该方法,否则抛出CloneNotSupportedException异常。

    主要是JAVA里除了8种基本类型传参数是值传递,其他的类对象传参数都是引用传递,我们有时候不希望在方法里讲参数改变,这是就需要在类中复写clone方法。

    2.getClass方法

    final方法,获得运行时类型。

    3.toString方法

    该方法用得比较多,一般子类都有覆盖。

    4.finalize方法

    该方法用于释放资源。因为无法确定该方法什么时候被调用,很少使用。

    5.equals方法

    该方法是非常重要的一个方法。一般equals和==是不一样的,但是在Object中两者是一样的。子类一般都要重写这个方法。

    6.hashCode方法

    该方法用于哈希查找,可以减少在查找中使用equals的次数,重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

    一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode(),但是hashCode相等不一定就满足equals。不过为了提高效率,应该尽量使上面两个条件接近等价。

    如果不重写hashcode(),在HashSet中添加两个equals的对象,会将两个对象都加入进去。

    7.wait方法

    wait方法就是使当前线程等待该对象的锁,当前线程必须是该对象的拥有者,也就是具有该对象的锁。wait()方法一直等待,直到获得锁或者被中断。wait(long timeout)设定一个超时间隔,如果在规定时间内没有获得锁就返回。

    调用该方法后当前线程进入睡眠状态,直到以下事件发生。

    (1)其他线程调用了该对象的notify方法。

    (2)其他线程调用了该对象的notifyAll方法。

    (3)其他线程调用了interrupt中断该线程。

    (4)时间间隔到了。

    此时该线程就可以被调度了,如果是被中断的话就抛出一个InterruptedException异常。

    8.notify方法

    该方法唤醒在该对象上等待的某个线程。

    9.notifyAll方法

    该方法唤醒在该对象上等待的所有线程。

    发表于 2020-03-11 10:16:59

    回复(0)

    更多相关内容
  • Object类的clone方法

    千次阅读 2019-06-30 11:28:22
    Object类的clone方法 Object是所有类的基类,当你没有显示extends一个父类时,编译期会自动为你加上一个Object类。 这是一个native方法,说明这个方法的实现不是在java中,而是由C/C++实现,并编译成.dll文件,由...

    Object类的clone方法

    Object是所有类的基类,当你没有显示extends一个父类时,编译期会自动为你加上一个Object类。
    在这里插入图片描述

    1. 这是一个native方法,说明这个方法的实现不是在java中,而是由C/C++实现,并编译成.dll文件,由java调用。registerNatives主要是将C/C++的方法映射到java中的native方法,实现方法命名的解耦。了解即可,知道是注册,细节暂时不研究。
    private static native void registerNatives();
        static {
            registerNatives();
        }
    
    
    1. 第二点来关注 clone方法。
      protected native Object clone() throws CloneNotSupportedException;
      通过源代码可以发现几点:
      clone方法是native方法,native方法的效率远高于非native方法,因此还是使用clone方法去做对象的拷贝而不是使用new的方法,copy。
      此方法被protected修饰。这就意味着想要使用,必须继承它(废话,默认都是继承的)。然后重载它,如果想要使得其他类能使用这个类,需要设置成public。
      返回值是一个Object对象,所以要强制转换才行。
    public class TestReen{
    	
    	public static void main(String[] args) throws Exception{
    		
    		TestReen tReen = new TestReen();
    		
    		TestReen copy = (TestReen)tReen.clone();
    	}
    	
    }
    
    

    但是运行时,发现抛异常了。

    Exception in thread "main" java.lang.CloneNotSupportedException: com.test.count.TestReen
    	at java.lang.Object.clone(Native Method)
    	at com.test.count.TestReen.main(TestReen.java:11)
    
    

    进入clone方法,看注释发现如下信息:表明此类不支持Cloneable接口的话就会报错。

    @exception  CloneNotSupportedException  if the object's class does not
         *               support the {@code Cloneable} interface. Subclasses
         *               that override the {@code clone} method can also
         *               throw this exception to indicate that an instance cannot
         *               be cloned.
    
    

    去看看Cloneable接口,空的,

    public interface Cloneable {
    }
    
    

    总结其注释的话,差不多三点:
    (1)此类实现了Cloneable接口,以指示Object的clone()方法可以合法地对该类实例进行按字段复制;
    (2)如果在没有实现Cloneable接口的实例上调用Object的clone()方法,则会导致抛出CloneNotSupporteddException;
    (3)按照惯例,实现此接口的类应该使用公共方法重写Object的clone()方法,Object的clone()方法是一个受保护的方法;
    因此想实现clone的话,除了继承Object类外,还需要实现Cloneable接口;
    创建并返回此对象的一个副本。对于任何对象x,表达式:
    (1)x.clone() != x为true
    (2)x.clone().getClass() == x.getClass()为true
    (3)x.clone().equals(x)一般情况下为true,但这并不是必须要满足的要求

    public class TestReen implements Cloneable{
    	
    	private int id;
    	
    	private static int i = 1;
    	
    	public TestReen() {
    		System.out.println("i = " + i);
    		System.out.println("执行了构造函数"+i);
    		i++;
    	}
     
    	public int getId() {
    		return id;
    	}
     
    	public void setId(int id) {
    		this.id = id;
    	}
     
    	public static void main(String[] args) throws Exception{
    		
    		TestReen t1 = new TestReen();
    		t1.setId(1);
    		
    		TestReen t2 = (TestReen)t1.clone();
    		
    		TestReen t3 = new TestReen();
    		
    		System.out.println("t1 id: "+ t1.getId());
    		System.out.println("t2 id: "+ t2.getId());
    		System.out.println("t1 == t2 ? " + (t1 == t2));
    		System.out.println("t1Class == t2Class ? " + (t1.getClass() == t2.getClass()));
    		System.out.println("t1.equals(t2) ? " + t1.equals(t2));
    		
    	}
    }
    
    

    结果如下,有几个发现:

    1. 构造函数除了new执行以外,clone并没有调用到构造函数,也就是clone方法是不走构造方法的。

    2. t1 和 t2 是不等的,说明指向了不同的堆地址空间,是两个对象。

    3. getClass是相同的,getClass是什么?是获取这个实例的类型类,有点拗口,其实就是TestReen类型,可见clone出来的类型还是一样的。

    i = 1
    执行了构造函数1
    i = 2
    执行了构造函数2
    t1 id: 1
    t2 id: 1
    t1 == t2 ? false
    t1Class == t2Class ? true
    t1.equals(t2) ? false
    
    

    国际惯例所有博客都会去关注的一点,浅克隆(shallow clone)和 深克隆(deep clone)。
    浅克隆:Object的clone提供的就是浅克隆,由下面的例子可以看见,只克隆了自身对象和对象内实例变量的地址引用,它内部的实例变量还是指向原先的堆内存区域。

    深克隆:克隆所有的对象,包括自身以及自身内部对象。
    浅克隆测试代码:
    TestReen中有一个实例变量SonReen。

    public class TestReen implements Cloneable{
    	private int id;
    	private String name;
    	private SonReen sonReen;
    	public TestReen(int id, String name, SonReen sonReen) {
    		this.id = id;
    		this.name = name;
    		this.sonReen = sonReen;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public SonReen getSonReen() {
    		return sonReen;
    	}
    	public void setSonReen(SonReen sonReen) {
    		this.sonReen = sonReen;
    	}
    	public static void main(String[] args) throws Exception{
    		
    		SonReen sonReen = new SonReen(1, "张三");
    		TestReen t1 = new TestReen(1, "李四", sonReen);
    		TestReen t3 = new TestReen(2, "李四1", sonReen);
    		TestReen t4 = new TestReen(3, "李四", sonReen);
    		TestReen t2 = (TestReen)t1.clone(); 
    		System.out.println("t1 ? "+ (t1 == t2));
    		System.out.println("sonReen: ? "+ (t1.getSonReen() == t2.getSonReen()));
    		System.out.println("t1.name == t3.name: ? " + (t1.getName() == t3.getName()));
    		System.out.println("t1.name == t4.name: ? " + (t1.getName() == t4.getName()));
    		System.out.println("T name: ? " + (t1.getName() == t2.getName()));
    		System.out.println("S name: ? " + (t1.getSonReen().getSonName() == t2.getSonReen().getSonName()));
    	}
    }
    class SonReen{
    	private int sonId;
    	private String sonName;
    	public SonReen(int sonId, String sonName) {
    		super();
    		this.sonId = sonId;
    		this.sonName = sonName;
    	}
    	public int getSonId() {
    		return sonId;
    	}
    	public void setSonId(int sonId) {
    		this.sonId = sonId;
    	}
    	public String getSonName() {
    		return sonName;
    	}
    	public void setSonName(String sonName) {
    		this.sonName = sonName;
    	}
    }
    
    

    得到的结果如下:可以发现几点:

    首先TestReen 不是同一个对象,但是它内部的实例变量sonReen 确实同一个对象。内部的String变量的行为和new出来的t1和t4行为一致,也是相等的。

    t1 ? false
    sonReen: ? true
    t1.name == t3.name: ? false
    t1.name == t4.name: ? true
    T name: ? true
    S name: ? true
    
    

    深克隆:方法有两种:
    1.先对对象进行序列化操作,然后立马反序列化出。

    2.先调用super.clone()方法克隆出一个新对象来,然后在子类的clone()方法中手动给克隆出来的非基本数据类型(引用类型)赋值。(这个是网上别人的观点,稍后会去研究各个集合内的克隆原理,也是一个知识点)

    序列化例子:

    public class TestReen implements Cloneable,Serializable{
    	private int id;
    	private String name;
    	private SonReen sonReen;
    	public TestReen(int id, String name, SonReen sonReen) {
    		this.id = id;
    		this.name = name;
    		this.sonReen = sonReen;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public SonReen getSonReen() {
    		return sonReen;
    	}
    	public void setSonReen(SonReen sonReen) {
    		this.sonReen = sonReen;
    	}
    	public Object deepClone() throws Exception{
    		
    		ByteArrayOutputStream bo = new ByteArrayOutputStream();
    		ObjectOutputStream out = new ObjectOutputStream(bo);
    		out.writeObject(this);
    		
    		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
    		ObjectInputStream oi = new ObjectInputStream(bi);
    		return oi.readObject();
    		
    	}
    	public static void main(String[] args) throws Exception{
    		
    		SonReen sonReen = new SonReen(1, "张三");
    		TestReen t1 = new TestReen(1, "李四", sonReen);
    		TestReen t2 = (TestReen)t1.deepClone(); 
    		System.out.println("t1 ? "+ (t1 == t2));
    		System.out.println("sonReen: ? "+ (t1.getSonReen() == t2.getSonReen()));
    		System.out.println("T name: ? " + (t1.getName() == t2.getName()));
    		System.out.println("S name: ? " + (t1.getSonReen().getSonName() == t2.getSonReen().getSonName()));
    		
    		SonReen sonReen1 = new SonReen(1, "王五");
    		t2.setSonReen(sonReen1);
    		System.out.println("son : "+ t1.getSonReen().getSonName());
    		System.out.println("son1 : "+ t2.getSonReen().getSonName());
    		System.out.println("son == son1 : ? "+ (t1.getSonReen() ==  t2.getSonReen()));
    		
    	}
    }
    class SonReen implements Serializable{
    	private int sonId;
    	private String sonName;
    	public SonReen(int sonId, String sonName) {
    		super();
    		this.sonId = sonId;
    		this.sonName = sonName;
    	}
    	public int getSonId() {
    		return sonId;
    	}
    	public void setSonId(int sonId) {
    		this.sonId = sonId;
    	}
    	public String getSonName() {
    		return sonName;
    	}
    	public void setSonName(String sonName) {
    		this.sonName = sonName;
    	}
    }
    
    

    如下结果: 发现t1 和 t2 内的sonReen比较时 已经是false了,说明克隆的同时将对象内部的实例对象也跟着一起复制了,并且下面对 t2 内部son 的名字改变也没有影响 t1的值。

    t1 ? false
    sonReen: ? false
    T name: ? false
    S name: ? false
    son : 张三
    son1 : 王五
    son == son1 : ? false
    
    

    》》》博主长期更新学习心得,推荐点赞关注!!!
    》》》若有错误之处,请在评论区留言,谢谢!!!

    展开全文
  • Java Object类方法

    万次阅读 2018-10-22 11:28:56
     (1)Object类位于java.lang包中,java.lang包包含着Java最基础和核心的类,在编译时会自动导入;  (2)Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个类的方法。可以...

    基本描述:

      (1)Object类位于java.lang包中,java.lang包包含着Java最基础和核心的类,在编译时会自动导入;

      (2)Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个类的方法。可以使用类型为Object的变量指向任意类型的对象

    Object的主要方法介绍:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    package java.lang;    

    public class Object {    

           

       /* 一个本地方法,具体是用C(C++)在DLL中实现的,然后通过JNI调用。*/     

        private static native void registerNatives();    

      /* 对象初始化时自动调用此方法*/   

        static {    

            registerNatives();    

        }    

       /* 返回此 Object 的运行时类。*/   

        public final native Class<?> getClass();

     

        public native int hashCode();

    hashCode()方法:

    hash值:Java中的hashCode方法就是根据一定的规则将与对象相关的信息(比如对象的存储地址,对象的字段等)映射成一个数值,这个数值称作为散列值。

    情景:考虑一种情况,当向集合中插入对象时,如何判别在集合中是否已经存在该对象了?(注意:集合中不允许重复的元素存在)。

    大多数人都会想到调用equals方法来逐个进行比较,这个方法确实可行。但是如果集合中已经存在一万条数据或者更多的数据,如果采用equals方法去逐一比较,效率必然是一个问题。此时hashCode方法的作用就体现出来了,当集合要添加新的对象时,先调用这个对象的hashCode方法,得到对应的hashcode值。实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值,如果table中没有该hashcode值,它就可以直接存进去,不用再进行任何比较了;如果存在该hashcode值, 就调用它的equals方法与新元素进行比较,相同的话就不存了,不相同就散列其它的地址。

    重写hashCode()方法的基本规则:

    · 在程序运行过程中,同一个对象多次调用hashCode()方法应该返回相同的值。

    · 当两个对象通过equals()方法比较返回true时,则两个对象的hashCode()方法返回相等的值。

    · 对象用作equals()方法比较标准的Field,都应该用来计算hashCode值。

    Object本地实现的hashCode()方法计算的值是底层代码的实现,采用多种计算参数,返回的并不一定是对象的(虚拟)内存地址,具体取决于运行时库和JVM的具体实现。

    1

    2

    3

    public boolean equals(Object obj) {

           return (this == obj);

    } 

    equals()方法:比较两个对象是否相等

    我们知道所有的对象都拥有标识(内存地址)和状态(数据),同时“==”比较两个对象的的内存地址,所以说使用Object的equals()方法是比较两个对象的内存地址是否相等,即若object1.equals(object2)为true,则表示equals1和equals2实际上是引用同一个对象。虽然有时候Object的equals()方法可以满足我们一些基本的要求,但是我们必须要清楚我们很大部分时间都是进行两个对象的比较,这个时候Object的equals()方法就不可以了,实际上JDK中,String、Math等封装类都对equals()方法进行了重写。

    1

    protected native Object clone() throws CloneNotSupportedException;

     clone()方法:快速创建一个已有对象的副本

    第一:Object类的clone()方法是一个native方法,native方法的效率一般来说都是远高于Java中的非native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类,然后把原始对象中的信息复制到新对象中,虽然这也实现了clone功能。

    第二:Object类中的 clone()方法被protected修饰符修饰。这也意味着如果要应用 clone()方 法,必须继承Object类。

    第三:Object.clone()方法返回一个Object对象。我们必须进行强制类型转换才能得到我们需要的类型。

    克隆的步骤:1:创建一个对象;   2:将原有对象的数据导入到新创建的数据中。

    clone方法首先会判对象是否实现了Cloneable接口,若无则抛出CloneNotSupportedException, 最后会调用internalClone. intervalClone是一个native方法,一般来说native方法的执行效率高于非native方法。

    复制对象 or 复制引用

    1

    2

    3

    4

    5

    6

    7

    8

    Person p = new Person(23"zhang"); 

    Person p1 = p; 

       

    System.out.println(p); 

    System.out.println(p1); 

    打印出来:

    com.pansoft.zhangjg.testclone.Person@2f9ee1ac

    com.pansoft.zhangjg.testclone.Person@2f9ee1ac

     

    可已看出,打印的地址值是相同的,既然地址都是相同的,那么肯定是同一个对象。p和p1只是引用而已,他们都指向了一个相同的对象Person(23, "zhang") 。 可以把这种现象叫做引用的复制。

    1

    2

    3

    4

    5

    6

    7

    8

    Person p = new Person(23"zhang"); 

    Person p1 = (Person) p.clone(); 

       

    System.out.println(p); 

    System.out.println(p1); 

    打印出:

    com.pansoft.zhangjg.testclone.Person@2f9ee1ac

    com.pansoft.zhangjg.testclone.Person@67f1fba0

      

    从打印结果可以看出,两个对象的地址是不同的,也就是说创建了新的对象, 而不是把原对象的地址赋给了一个新的引用变量:

    深拷贝 or 浅拷贝

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    public class Person implements Cloneable{ 

           

        private int age ; 

        private String name; 

           

        public Person(int age, String name) { 

            this.age = age; 

            this.name = name; 

        

           

        public Person() {} 

       

        public int getAge() { 

            return age; 

        

       

        public String getName() { 

            return name; 

        

           

        @Override 

        protected Object clone() throws CloneNotSupportedException { 

            return (Person)super.clone(); 

        

    }

    Person中有两个成员变量,分别是name和age, name是String类型, age是int类型 

    由于age是基本数据类型, 那么对它的拷贝没有什么疑议,直接将一个4字节的整数值拷贝过来就行。但是name是String类型的, 它只是一个引用, 指向一个真正的String对象,那么对它的拷贝有两种方式: 直接将源对象中的name的引用值拷贝给新对象的name字段, 或者是根据原Person对象中的name指向的字符串对象创建一个新的相同的字符串对象,将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。这两种拷贝方式分别叫做浅拷贝和深拷贝。

    通过下面代码进行验证。如果两个Person对象的name的地址值相同, 说明两个对象的name都指向同一个String对象, 也就是浅拷贝, 而如果两个对象的name的地址值不同, 那么就说明指向不同的String对象, 也就是在拷贝Person对象的时候, 同时拷贝了name引用的String对象, 也就是深拷贝。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    Person p = new Person(23"zhang"); 

    Person p1 = (Person) p.clone(); 

       

    String result = p.getName() == p1.getName()  

            "clone是浅拷贝的" "clone是深拷贝的"

       

    System.out.println(result);

    打印出:

        clone是浅拷贝的

    对于对象的浅拷贝和深拷贝还有更深的细节,可以参考:详解Java中的clone方法 -- 原型模式

    1

    2

    3

    public String toString() {

        return getClass().getName() + "@" + Integer.toHexString(hashCode());

    }

    toString()方法:toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

     Object 类的 toString 方法返回一个字符串,该字符串由类名(对象是该类的一个实例)、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    /*唤醒在此对象监视器上等待的单个线程。*/

    public final native void notify();

     

    /*唤醒在此对象监视器上等待的所有线程。*/

    public final native void notifyAll();

     

    /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。*/  

    public final native void wait(long timeout) throws InterruptedException;

     

     /* 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量前,导致当前线程等待。*/

    public final void wait(long timeout, int nanos) throws InterruptedException {

            if (timeout < 0) {

                throw new IllegalArgumentException("timeout value is negative");

            }

     

            if (nanos < 0 || nanos > 999999) {

                throw new IllegalArgumentException(

                                    "nanosecond timeout value out of range");

            }

     

            if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {

                timeout++;

            }

     

            wait(timeout);

        }

     

    /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待。换句话说,此方法的行为就好像它仅执行 wait(0) 调用一样。   

    当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待,直到其他线程通过调用 notify 方法,或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。*/

    public final void wait() throws InterruptedException {

            wait(0);

        }

     

    1

    protected void finalize() throws Throwable { }

    finalize()方法:垃圾回收器准备释放内存的时候,会先调用finalize()。

      (1).  对象不一定会被回收。

           (2).垃圾回收不是析构函数。

           (3).垃圾回收只与内存有关。

           (4).垃圾回收和finalize()都是靠不住的,只要JVM还没有快到耗尽内存的地步,它是不会浪费时间进行垃圾回收的。

    转自 https://www.cnblogs.com/myseries/p/7435395.html

    展开全文
  • Object类九大方法之equals方法

    千次阅读 2019-08-02 07:29:37
    Object类九大方法之equals方法 所有类都从Object类中继承了equals方法,Object类中的equals方法的源代码如下: public boolean equals(Object obj){ return this=obj; } Object中的equals方法是判断this和obj本省的...

    Object类九大方法之equals方法

    所有类都从Object类中继承了equals方法,Object类中的equals方法的源代码如下:

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

    Object中的equals方法是判断this和obj本省的值是否相等,即用来判断调用equals的对象和形参obj所引用的对象是否为同一个对象,所谓的同一个对象就是指内存中同一块储存的单元(地址值)如果this和obj指向的是同一块内存对象,则返回ture,如果this和obj指向的不是同一块内存,则返回false.

    需要注意的是:即便是内容方完全相同的两块不同的内存对象,也返回false.因为比较的是地址值.

    那么equals()方法与之前的’=="有什么区别呢?

    首先了解一下java内存的只要划分
    在这里插入图片描述
    堆:存放的是New出来的对象,此对象由垃圾收集器收集,垃圾集器针对的就是堆区.

    栈:每调用一个方法,会创建一个栈帧,存放局部变量.

    方法区:类的所有信息,包括所有的方法,静态变量,常量.

    通过下面的代码我们加深一下equals和=的区别:

    public class Equals{
        public static void main(String[]args){
            String s1="apple";
            String s2="apple";
            System.out.print(s1==s2)//true,比较的是对象的地址值,因为两个对象都存在常量池中所以为true
            System.out.print(s1.equals(s2))//true,因为此Equals是Object的方法比较的是内容所以为true
            String s3=new String("apple");
            String s4=new String("apple");
            System.out.print(s3==s4);//false,地址值不一样
            System.out.print(s3.equals(s4));//true,因为此Equals是Object的方法比较的是内容所以为true
        }
    }
    
    结论:
    "== "比较的是变量(栈)内存中存放的对象的内存地址,用来判断两个对象的地址是否相同,即是否是指相同一个对象
    “equals”:不能做基本类型的比较,引用类型如果不重写比较的是地址值,重写之后比较的是内容.

    从内存的划分我们来理解这个区别

    String s1=new String("apple");
    String s2=new String("apple"); 
    System.out.println(s1==s2);  //false 
    System.out.println(s1.equals(s2));  //true  
    

    在这里插入图片描述
    因为“”比较的是两个引用的对象是否相等,从上图很容易看出来不等,所以System.out.println(s1s2),结果为False;而equals()方法比较的是两个对象的实际内容,从图中可以看出s1和s2都指向apple,内容是相同的,所以System.out.println(s1.equals(s2)),结果为True。

    String s1="apple";
    String s2="apple";
    System.out.println(s1==s2);//true
    System.out.println(s1.equals(s2));//true
    

    在这里插入图片描述

    展开全文
  • Java Object类中toString方法的重写

    千次阅读 2021-01-02 16:17:00
    Object类中的tostring方法的: 当我们输出一个对象时,实际是输出的是这个类中的tostring方法,是一个地址值,而不是类中的属性。 一:子类没有重写Object类中的toStrinng方法时的输出 public class ToStringUse { ...
  • 关于Object类

    千次阅读 2018-06-01 21:35:11
    题目 以下不是Object类方法是() A.hashCode() B.finalize() C.notify() D.hashNext() ...
  • Object类是Java类层次结构中的根类,每个类都继承了Object类,当然每一个对象也都可以调用Object类中的方法,其中equals方法是一个非常重要的方法,顾进行详细介绍: 一、equals方法 1、在Object类中,equals方法...
  • Object类九大方法之wait方法

    千次阅读 2019-08-13 13:22:46
    Object类九大方法之wait方法 wait、notify和notifyAll方法Object类的final native方法。所以这些方法不能被子类重写,Object类是所有类的超类,因此在程序中有以下三种形式调用wait等方法。 wait();//方式1: ...
  • java面试题27 java中下面哪些是Object类方法() A notify() B notifyAll() C sleep() D wait() 蒙蔽树上蒙蔽果,蒙蔽树下你和我。遇到这种题,我默默的打开了编译工具 Object类方法: protected ...
  • Object类九大方法之getClass方法

    千次阅读 2019-08-12 11:50:35
    Object类九大方法之getClass方法 https://www.cnblogs.com/wsw-bk/p/8026266.html 获取此Object的运行时类. 什么是运行时类? 在创建对象前先要有class文件,这是字节码文件,首先要加载class(字节码)文件,后面才能接着...
  • Java中的Object类

    万次阅读 多人点赞 2019-05-11 14:54:16
    Object作为所有类的父类,是面向对象学习中最重要的一个类。Object类是java默认的提供的一个类,Object类是所有类的父类,也就是说任何一个类的定义的时候如果没有明确的继承一个父类的话,那么它就是Object的子类
  • Java中Object类之clone()方法详解

    千次阅读 2017-10-16 08:40:40
    一、clone()方法 clone意思是克隆、复制。...clone()方法在根类Object中定义如下。 /** * Class Object is the root of the class hierarchy. Every class has Object as a superclass. * Al...
  • java基础扫盲-Object类的常用方法

    千次阅读 2019-12-31 10:12:40
    Object类是所有类的父类。常用的方法如下: 1、toString方法 当你打印一个对象的时候它会去直接调用这个对象的toString方法,当打印这个对象的时候,是得到一个类的名称+@把一个hashcode的值转成16进制的数字,如果...
  • 1.wait和notify不仅仅是普通方法或同步工具,更重要的是它们是Java中两个线程之间的通信机制 。对语言设计者而言,如果不能通过Java关键字(例如synchronized)实现此通信机制,同时又要确保这个机...
  • 为什么wait,notify,notifyAll声明在类Object中而不是在Thread中这个问题是一个非常有名的java核心面试题,在各种级别的Java开发者面试中都会出现
  • java中Object类中有哪些常用方法以及作用java中Object类中有哪些常用方法以及作用?java中Object类中有哪些常用方法有哪些?object类中的常用方法的用处: java中Object类中有哪些常用方法以及作用? java中Object类...
  • Object类中的hashCode方法

    千次阅读 2018-01-03 17:33:56
     Java语言中,Object对象有个特殊的方法:hashcode(), hashcode()表示的是JVM虚拟机为这个Object对象分配的一个int类型的数值,JVM会使用对象的hashcode值来提高对HashMap、Hashtable哈希表存取对象的使用效率。...
  • Object wait方法

    千次阅读 2017-02-04 14:54:22
    Object的wait方法 synchronized (obj) { while (condition does not ok){ obj. wait (); } } 如果想让线程A处于等待状态,可以调用当前对象 wait 方法。wait方法一旦被调用,也就意味着: ...
  • 1、wait 和 notify 不是线程对象的方法,而是Java中任何一个对象都有的方法。 2、wait 和 notify 方法的作用: wait:让正在活动在该对象上的线程进入等待状态,无限期等待,直到被唤醒为止 notify:让正在该...
  • 6.类快速重写Object类 equals()方法,使其比较的是内容,而不是地址。 1.java中什么是Object类? Object是所有java类的根父类 如果在类的声明中没有使用extends关键字指明父类,则为默认继承父类Object类 ...
  • Java Object 常用方法总结

    千次阅读 2018-08-20 17:31:21
    getClass() //返回此 Object 运行时的 public native int hashCode() //返回对象的哈希码 public boolean equals(Object obj) //判断其他对象与此对象是否“相等” protected native Object c...
  • Object 解析

    千次阅读 2019-07-09 22:42:00
    Java Object 类方法解析。使用场景分析。
  • 覆盖/重写Object类中equals方法

    千次阅读 2018-07-22 19:53:43
    我们在写程序时,往往有时Java类库中的equals方法不能满足我们的需求。这时,就需要我们自己来定义...很简单的一个方法,因为是Object方法,所以对所有对象都适用。 public boolean equals(Object obj) { ...
  • Object是所有类的父类(国外成为超类superclass),Object类方法是相当少的(理解为教室人越多,他们的共同点越少)。 Object的toString()方法帮助我们返回一个字符串,这个字符串的格式是固定的:类名@hashcode...
  • 【JAVA】Object类方法简谈

    万次阅读 2018-08-08 00:56:43
    Object类方法简谈 Java中所有的类都继承自Object类,那我们今天来探讨一下Object类中的方法 PS:Object源码中,作者那一栏中,出现了这个 package java.lang; /** * Class {@code Object} is the root of the...
  • Object类中的wait()方法和notify()方法

    千次阅读 2017-06-04 10:54:31
    Object类中的wait()方法和notify()方法】 wait(): public final void wait(long timeout) throws InterruptedException 参数:等待的时间,可选,不填则默认为0。 说明: 1>使线程主动释放对象锁,...
  • Object类的equals()方法入门详解

    千次阅读 2018-04-26 14:17:52
    equals(Object o)定义:比较是否相等,Object中的equals()方法与==相同(如下源码),都是比较两个对象的内存地址。子类一般情况下需要重写equals方法。 public boolean equals(Object obj) { return (this == ...
  • Java 重写Object类的常见方法

    千次阅读 2013-09-19 23:18:23
    当我们写一个类的时候,都会对Java.lang.Object类的一些重要方法进行重写,这些方法包含:hashCode(),toString(),equals(),finalize(),clone(),wait(),notify()/notifyAll() 这八个方法。 一 Equals()方法: 1....
  • 本文对java的Class类和Object类的概念和原理做了详尽的介绍,并且详细介绍了Object的各种方法,以及这两个类之间的关系。 Class类和Object类是Java中最根本最重要的两个类,理解它们是理解Java面向对象技术的基础,...
  • Object类和String类equals方法的区别

    千次阅读 2016-05-15 15:20:45
    String的equals方法和“==” 相信很多学习过Java的同学都知道,在比较两个String对象的内容是否相同时是使用equals方法的 如:String str1=new String(“A”);  String str2=new String(“B”);  String str...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,057,268
精华内容 422,907
关键字:

哪个不是object类的方法