• java编程基础总结——16.Object类

    一、Object类：

        Object类是java中所有类父类
        java.lang.Object

     
    native关键字
        被它修饰的方法，叫做本地方法
        都是没有实现体。
        JVM在底层使用C/C++实现。

    方法：

       1.  public final native Class getClass();    // 获取类的字节码文件
        
       

     

       2. public native int hashCode();            // 获取对象的hashcode（获取对象的内存地址的hashcode值）

            对象都是有内存地址的。如int a = 10，是把10存在一个内存地址。在java中，为了方便，把内存地址做了哈希算法，最终获取一个hashcode值，这个值也是native的，是底层实现的

     

      

        3. public boolean equals(Object obj)            // 比较对象，默认使用== ，比较的是内存地址

             字符串重写了该方法，因为字符串一般比较的是内容，而不是地址


        

     

     4. public String toString()            // 以字符串的形式展示对象信息，打印对象时调用

         返回的是 对象的类名称 + @ + 十六进制数字（内存地址的16进制值）


           getClass()                            拿到字节码文件。getName()获取类的名称

           getClass().getName()          获取类的名称。注意：是获取全路径，包名+类名

           Integer.toHexString()           将int值转换成十六进制的字符串

           hashCode()                          获取内存地址的hashcode值

    5. public final native void notify()                  //唤醒当前沉睡的线程
    6. public final native void notifyAll()              //唤醒当前所有沉睡的线程
    7. public final void wait()                              // 让当前线程进行等待。存在三个重载

    8. protected void finalize()                           // 该方法在GC（垃圾回收机制）触发前，会自动触发
                                                                       // 在当前对象被GC前，会自动触发
                                                                       // 适合于做一些垃圾回收前的各种工作、挽救工作

    先重写该方法 

    @Override
        protected void finalize() throws Throwable {
            System.out.println("我觉得还可以挽救");
        }

    再进行测试 

    1. package com.openlab.day15;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. public class TestObject {
    6. 	
    7. 	@Test
    8. 	void testFinalize() {
    9. 		User u = new User();
    10. 		u = null;
    11. 		//把u置空，对于gc而言，内存不一定已经变为空了
    12. 		//java的垃圾回收机制是自动在维护的，不是程序员维护。c立刻回收，java不是
    13. 		//标记为空相当于告诉垃圾回收机制，这个是垃圾，垃圾回收机制会过来回收，但是
    14. 		//过来回收的时间不确定，有时候会立刻过来回收，有时候会等一会过来回收
    15. 		System.gc();//手动调用gc，让立即回收
    16. 		try {
    17. 			Thread.sleep(3000);
    18. 		} catch (InterruptedException e) {
    19. 			e.printStackTrace();
    20. 		}
    21. 	}
    22. }

     

    面试题，这三种的区别和联系：
        final
        finally
        finalize()    在jdk9之后过时了

    final和finally是java的关键字，finalize()是Object类提供一个方法

    final关键字修饰变量、方法、类，...

    finally是用在try语法块中的，写在finally中的代码是必须要执行的

     

    9. protected native Object clone() throws CloneNotSupportedException       //对象拷贝

     

     

    二、引用传递和对象拷贝：

        引用传递：将栈引用进行复制，堆中的对象始终是一个

        对象拷贝：堆对象会进行复制。借助clone方法

        在java中，如果需要拷贝对象，一定要去该类实现Cloneable接口

    1.引用传递

    1. package com.openlab.day15;
    2.  
    3. public class User {
    4. 	private Integer id;
    5. 	private String username;
    6. 	private String password;
    7. 	private String nickname;
    8. 	private Integer age;
    9.  
    10. 	public Integer getId() {
    11. 		return id;
    12. 	}
    13.  
    14. 	public void setId(Integer id) {
    15. 		this.id = id;
    16. 	}
    17.  
    18. 	public String getUsername() {
    19. 		return username;
    20. 	}
    21.  
    22. 	public void setUsername(String username) {
    23. 		this.username = username;
    24. 	}
    25.  
    26. 	public String getPassword() {
    27. 		return password;
    28. 	}
    29.  
    30. 	public void setPassword(String password) {
    31. 		this.password = password;
    32. 	}
    33.  
    34. 	public String getNickname() {
    35. 		return nickname;
    36. 	}
    37.  
    38. 	public void setNickname(String nickname) {
    39. 		this.nickname = nickname;
    40. 	}
    41.  
    42. 	public Integer getAge() {
    43. 		return age;
    44. 	}
    45.  
    46. 	public void setAge(Integer age) {
    47. 		this.age = age;
    48. 	}
    49.  
    50. 	public User() {
    51. 		super();
    52. 	}
    53.  
    54. 	public User(Integer id, String username, String password, String nickname, Integer age) {
    55. 		super();
    56. 		this.id = id;
    57. 		this.username = username;
    58. 		this.password = password;
    59. 		this.nickname = nickname;
    60. 		this.age = age;
    61. 	}
    62.  
    63. 	@Override
    64. 	public String toString() {
    65. 		return "User [id=" + id + ", username=" + username + ", password=" + password + ", nickname=" + nickname
    66. 				+ ", age=" + age + "]";
    67. 	}
    68.  
    69. }
    1. package com.openlab.day15;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. public class TestObject {
    6. 	
    7. 	@Test
    8. 	void testObjectClone() {
    9. 		//创建一个对象
    10. 		User u1 = new User(1, "张三", "123456", "法外狂徒", 20);
    11. 		System.out.println(u1);
    12. 		//引用传递
    13. 		User u2 = u1;//u1存的是内存地址，把u1给u2就是把内存地址给u2
    14. 		System.out.println(u1 == u2);
    15. 	}
    16. 	
    17. }

     

     

    如果将u1置为空

    u1 = null;
    System.out.println(u2);

    u2还在，虽然一条线没有了，但是另一条还在。

     要是u1和u2都置空，内存就会被回收（在栈中已经没有引用指向堆了）。当没有人引用的时候，这块内存就会被认为是垃圾。java的GC是自动的，有自己的垃圾回收机制，根据特定的算法去回收。

    2. 对象拷贝

    可以重写clone()，也可以直接调用，习惯于重写该方法

    @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }

    在java中，如果需要拷贝对象（clone()），一定要去实现Cloneable接口，如果不实现，默认不能克隆。

    public class User implements Cloneable{

    }

    1. package com.openlab.day15;
    2.  
    3. //在java中，如果需要拷贝对象，一定要去实现Cloneable接口
    4. public class User implements Cloneable{
    5. 	private Integer id;
    6. 	private String username;
    7. 	private String password;
    8. 	private String nickname;
    9. 	private Integer age;
    10.  
    11. 	public Integer getId() {
    12. 		return id;
    13. 	}
    14.  
    15. 	public void setId(Integer id) {
    16. 		this.id = id;
    17. 	}
    18.  
    19. 	public String getUsername() {
    20. 		return username;
    21. 	}
    22.  
    23. 	public void setUsername(String username) {
    24. 		this.username = username;
    25. 	}
    26.  
    27. 	public String getPassword() {
    28. 		return password;
    29. 	}
    30.  
    31. 	public void setPassword(String password) {
    32. 		this.password = password;
    33. 	}
    34.  
    35. 	public String getNickname() {
    36. 		return nickname;
    37. 	}
    38.  
    39. 	public void setNickname(String nickname) {
    40. 		this.nickname = nickname;
    41. 	}
    42.  
    43. 	public Integer getAge() {
    44. 		return age;
    45. 	}
    46.  
    47. 	public void setAge(Integer age) {
    48. 		this.age = age;
    49. 	}
    50.  
    51. 	public User() {
    52. 		super();
    53. 	}
    54.  
    55. 	public User(Integer id, String username, String password, String nickname, Integer age) {
    56. 		super();
    57. 		this.id = id;
    58. 		this.username = username;
    59. 		this.password = password;
    60. 		this.nickname = nickname;
    61. 		this.age = age;
    62. 	}
    63.  
    64. 	@Override
    65. 	public String toString() {
    66. 		return "User [id=" + id + ", username=" + username + ", password=" + password + ", nickname=" + nickname
    67. 				+ ", age=" + age + "]";
    68. 	}
    69.  
    70. 	@Override
    71. 	protected Object clone() throws CloneNotSupportedException {
    72. 		return super.clone();
    73. 	}
    74.  
    75. }

     

    1. package com.openlab.day15;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. public class TestObject {
    6. 	
    7. 	@Test
    8. 	void testObjectClone() {
    9. 		//创建一个对象
    10. 		User u1 = new User(1, "张三", "123456", "法外狂徒", 20);
    11. 		System.out.println(u1);
    12. 		
    13. 		User u2 = u1;
    14. 		System.out.println(u1 == u2);
    15. 		
    16. 		//u1 = null;
    17. 		//System.out.println(u2);
    18. 		
    19. 		try {
    20. 			User u3 = (User) u1.clone();//要做强转（u1.clone()是Object）
    21. 			System.out.println(u1 == u3);
    22. 			System.out.println(u2 == u3);
    23. 			System.out.println(u3);
    24. 		} catch (CloneNotSupportedException e) {
    25. 			e.printStackTrace();
    26. 		}
    27. 	}
    28. 	
    29. }

     

     

     我们新克隆一个u3，发现u3和u1、u2都不想等，但是它们的值相等。这个拷贝相当于是把u1复制了一份对象放在堆内存，之后赋给u3的引用，叫对象拷贝。这种拷贝叫浅拷贝。

    以下介绍浅拷贝。

    我们再创建一个猫类，将猫的一个对象交给主人u1。执行这行代码，发现结果为true

    System.out.println(u1.getCat() == u3.getCat());

    1. package com.openlab.day15;
    2.  
    3. public class Cat {
    4. 	private int id;
    5. 	private String name;
    6.  
    7. 	public int getId() {
    8. 		return id;
    9. 	}
    10.  
    11. 	public void setId(int id) {
    12. 		this.id = id;
    13. 	}
    14.  
    15. 	public String getName() {
    16. 		return name;
    17. 	}
    18.  
    19. 	public void setName(String name) {
    20. 		this.name = name;
    21. 	}
    22.  
    23. 	public Cat() {
    24. 		super();
    25. 	}
    26.  
    27. 	public Cat(int id, String name) {
    28. 		super();
    29. 		this.id = id;
    30. 		this.name = name;
    31. 	}
    32.  
    33. 	@Override
    34. 	public String toString() {
    35. 		return "Cat [id=" + id + ", name=" + name + "]";
    36. 	}
    37.  
    38. }
    1. package com.openlab.day15;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. public class TestObject {
    6. 	
    7. 	@Test
    8. 	void testObjectClone() {
    9. 		//创建一个对象
    10. 		User u1 = new User(1, "张三", "123456", "法外狂徒", 20);
    11. 		Cat cat = new Cat(2022, "小贝");
    12. 		//将小贝交给了主人
    13. 		u1.setCat(cat);
    14. 		
    15. 		System.out.println(u1);
    16. 		
    17. 		User u2 = u1;
    18. 		System.out.println(u1 == u2);
    19. 		
    20. 		//u1 = null;
    21. 		//System.out.println(u2);
    22. 		
    23. 		try {
    24. 			User u3 = (User) u1.clone();//要做强转（u1.clone()是Object）
    25. 			System.out.println(u1 == u3);
    26. 			System.out.println(u2 == u3);
    27. 			System.out.println(u3);
    28. 			System.out.println(u1.getCat() == u3.getCat());
    29. 		} catch (CloneNotSupportedException e) {
    30. 			e.printStackTrace();
    31. 		}
    32. 	}
    33. 	
    34. }

     

     

            红色的表示猫对象，u1存了猫的地址，复制时把红色的地址复制了过来 ，所以u3的猫地址和u1相同。

    对象的深浅拷贝：

    1. 浅拷贝：将对象的第一层完成拷贝，使得两个对象完成了基本的分离
                      有可能还存在着藕断丝连，因为有可能有多层对象，多层对象不会做深层次的拷贝

        优点：内存占有较少
        缺点：如果存在底对象，则子对象没有拷贝，还是指向同一个。

    2. 深拷贝：
                将两个对象完成分离，彼此之间将无任何关系。
                递归拷贝

        java实现深拷贝有两种方法：
                1）、所有相关对象都实现浅拷贝。有几个实现几个，该方法用的不多

                2）、通过序列化对象实现深拷贝
                            对象 <==> 字节数据  
                            对象 <==> 字符串数据（如JSON）  

    1）、所有相关对象都实现浅拷贝

    案例中猫实现Cloneable接口，重写clone()方法，最后再添加

     

     

    //需要手动添加
    u3.setCat((Cat)(u1.getCat().clone()));


              
            
        

  • 相关阅读:
    Java 跨域解决
    java 调用 360 接口实现批量查询手机号码归属地
    【论文笔记】Content-based Unrestricted Adversarial Attack
    React中编写操作树形数据的自定义Hook
    MismatchedInlineShardingAlgorithmExpressionAndColumnException
    Scala运算符及流程控制
    okhttp
    React自定义Hook之useRequest
    计算机的硬件（计算机组成原理）
    第 45 届国际大学生程序设计竞赛（ICPC）亚洲区域赛（沈阳），签到题4题
  • 原文地址：https://blog.csdn.net/m0_58679504/article/details/126048580