Java - 所有类的父类Object类
 
Java中所有的方法都是object类提供的。
 在object类中有三个方法比较重要，分别是：toString(); equals(); hasdCode();
 
1）toString()方法
 
toString(）方法在Java中的原码为：
 
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 
原码中可见当对象调用toString方法时，后面输出的是hashCode值。
 
2）equals()方法
 
equals() 方法在Java中的原码：
 
public boolean equals(Object obj) {
        return (this == obj);
 }
 
之后在创建类时，对象之间调用equals方法进行比较时，如果不重写则调用的是Object类中的方法，比较的是地址。但是如果要比较的是内容，则必须重写equals方法。
 当创建String类型的对象，并且两个对象进行比较时，用String类型的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;
    }
 
在String类中Java本身对equals方法已经进行了重写，所以当使用String创建对象并进行对象的内容比较时，直接使用的是Java对String中的equals方法已经重写的方法，直接调用就行。而当自己创建的类对象进行比较内容时，必须自己重写equals方法。当然在后期中，Java框架就对equals方法进行了重写，就不必自己亲自写。
 
3）hashCode()方法
 
hashCode() 方法在Java中的原码
 
public native int hashCode();
 
hashCode() 看不懂，对，就是。Java不想让咱们看。
 
我们对hashCode() 方法的理解：
 hash算法是一种不可逆的过程，将数字按照某种特定的过程（自己定义或已有的算法），将数字排列成某种代替它不可逆的值。在equals方法中判断hashCode值，是因为当hashCode值不相等时，类的对象肯定不同，后面的代码则不需判断。而值相等时，有可能存在按照某种算法，使得不同的对象hashCode值相等，则需判断后面的代码。hashCode值是对象特征值的编码。hashCode值也是做判断的过程。
 
4）equals方法与hashCode方法的使用
 
class ObservObject {

	 private int age;
	 private String name;

	 public ObservObject() {}
	 public ObservObject(int age, String name) {
    	 this.age = age;
    	 this.name = name;
	 }

	 public boolean equals(Object o) {
     	if(this == o) {
       	 	 return true;
    	 }
     	if(o instanceof ObservObject) {
        	 ObservObject that = (ObservObject)o;
         	if(o == null || this.hashCode() != that.hashCode()) {
             	return false;
        	 }
        	 if(this.age != that.age) {
            	 return false;
         	 }
        	 if(!this.name.equals(that.name)) {
            	 return false;
        	 }
        	 return true;
    	 } else {
	       	  return false;
    	 }
	 }

 //随便写，写的过程符合两个特点：代替，不可逆
	 public int hashCode() {
	   	 int code = 0;
    	 code = code + this.age*31 + 31;
    	 return code;
	 }
}

public class instanceofDemo {
	 public static void main(String[] args) {
    	 ObservObject oo1 = new ObservObject(23,"李四");
    	 ObservObject oo2 = new ObservObject(23,"李四");
    	 System.out.println(oo1.equals(oo2));
 	}
}
 
"C:\Program Files\Java\jdk1.8.0_172\bin\java.exe" ...
true

Process finished with exit code 0
 
在Object中，就只有这三个方法才会被使用到。也就只有这三个方法重要！
 

 欢迎大家评论，留言。谢谢

Java中所有类的父类——非常重要的Object类。
 
​ 在Java中，所有的基类都有一个默认的父类，那就是Object类。Object类有下面几种方法
 
boolean equals(Object obj);//判断某个对象与此对象是否相等
final Class<?> getClass()；//返回此Object的运行时类
int hashCode();//返回该对象的哈希码值
String toString();//返回该对象的字符串表示
void finalize();//垃圾回收器调用此方法来清理没有被任何引用变量所引用的资源
Object clone();//返回该对象的克隆
 
​ 在Object类中，这些函数需要我们重写才能达到相应的功能。下面以重载toString函数为例：
 
 
 
我们发现可以直接用System.out.println()输出自己的字符串表示。
 
 
package test;
class A {
	int a;
	A(){};
	public String toString() {
		return "This class A of toString function";
	}
}

public class Kit {
	public static void main(String[] arg) {
		A aa = new A();
		System.out.println(aa);//输出 This class A of toString function
	}
}
 
另外Object的equals函数是判断两个对象是否引用的同一个对象，更确切的说是变量引用的对象内存地址是否为相等，而不是比较他们的内容是否一样 。
 
但是我们可以对equals函数进行重载，来达到我们的目的(判断对象的内容是否一样)。
 
 
 
这里需要注意的是’=='也是判断两个对象变量引用的对象是否相同，而不是比较他们的内容（或者你可以理解为对象变量里面存的都是引用对应的地址）
 

 
 
 
  
2019独角兽企业重金招聘Python工程师标准>>>  
 
 
 
 
Java中Object是所有类的父类，所有类的对象都是Class类的实例。贴上java doc中的说明
 
  
 
为什么我们需要Object类
 
 
这个问题找到了一个外国哥们的回答，http://stackoverflow.com/questions/2490875/object-class-as-super-class-in-java  感觉挺好
 
 
 
 
他说好处（1）可以使不同对象之间可以统一、互转。我觉得其中还包括 toString(),wait()...等公共方法的
 
 
                        统一定义
 
 
              （2）对父类的逻辑处理统一，不需要根据有没有父类分两种实现，
 
 
至于为什么是Object类是所有的父类，而不是class类可以移步
 
 
https://www.quora.com/Why-is-the-Object-class-super-class-of-all-classes-and-not-the-Class-class
 
 
但是问题来了，在JDK源码中很多类并没有父类，当然我们知道他们的默认父类就是Object,那是怎么保证的呢？
 
  
 
如何保证Object是默认父类
 
 
答：编译器编译的时候自动进去的。
 
 
一般对于这种靠虚拟机运行的语言（如Java、C#等）会有两种方法处理默认继承问题。
 
 
1、在编译源代码时，当遇到没有父类的类时，编译器会将其指定一个默认的父类（一般为Object），而虚拟机在处理到这个类时，由于这个类已经有一个默认的父类了，因此，VM仍然会按着常规的方法来处理每一个类。对于这种情况，从编译后的二进制角度来看，所有的类都会有一个父类。
 
 
2、编译器仍然按着实际代码进行编译，并不会做额外的处理。如果一个类没有显式地继承于其他的类，编译后的代码仍然没有父类。然后由虚拟机运行二进制代码时，当遇到没有父类的类时，就会自动将这个类看成是Object类的子类（一般这类语言的默认父类都是Object）。
 
 
从上面两种情况可以看出，第1种情况是在编译器上做的文章，也就是说，当没有父类时，由编译器在编译时自动为其指定一个父类。第2种情况是在虚拟机上做文章，也就是这个默认的父类是由虚拟机来添加的，
 
 
其实Java就属于第一种。
 
 
具体验证
 
 
（1）编写一个类
 
 
public class Test{
 public Test();
 public static void main(java.lang.String[]){};
 }
 
 
（2）进行编译成.class，再反编译成txt
 
 
（3）反编译结果 
 
 
public class Test extends java.lang.Object{
 public Test();
 public static void main(java.lang.String[]){};
 }
 
 
 
  
 
    
  
 
 
 
 
转载于:https://my.oschina.net/zlb1992/blog/863455

1、思考
 
无论是ssm框架，还是springboot，只要使用mybatis都会使用到对象关系映射；
实际项目中，往往除了表对象的基础属性，还需要加很多其他的属性；除了表的基础属性，不同的接口，添加属性又不同，造成类无用的属性太多，影响美观；
这时候想到了继承，表对象做为父类，其他具体的业务类继承表对象，逻辑清晰，代码明了，复用性增加；
但是问题又来了，在java中父类不能强转成子类，表对象有时候10+的属性，或者更多，这时候无论是构造方法，还是set，写着都好累，而且很丑。
最开始查了很多网上的资料，父类是可以转子类，但是都不是太适合，我想的是更加通用，简单；
最后想到两种办法，一种是反射，一种是json。
反射原理比较简单，循环赋值。反射不止适用于父类转子类，只要具有相同属性的都可以转，都可以赋值。
 
2、工具类
 
先上代码，可直接食用
 
package com.utils.v2;

import com.alibaba.fastjson.JSONObject;

import java.lang.reflect.Field;

/**
 * @Description: 父类强转子类
 * @Author: zx
 * @Time: 2019-12-18 17:03
 **/
public class StrongParentSubclass {

    /**
     * @Author zx
     * @Description 反射循环赋值
     * @Date 2019/12/18 18:32
     * @Param [parent, subclass]
     **/
    public static Object parentSubclass(Object parent,Object subclass){
        Field[] parents = parent.getClass().getDeclaredFields();//获取所有属性
        Field[] children = subclass.getClass().getSuperclass().getDeclaredFields();//获取父类所有属性
        try {
        for (Field fieldParent : parents){
            fieldParent.setAccessible(true);
            String nameParent = fieldParent.getName(); //获取属性的名字
            Object valueParent = fieldParent.get(parent);//获取属性值
            for (Field fieldChild : children){
                fieldChild.setAccessible(true);
                String nameChild = fieldChild.getName(); //获取属性的名字
                Object valueChild= fieldChild.get(subclass);
                if (nameChild.equals(nameParent)){
                    fieldChild.set(subclass,valueParent);
                }

            }
        }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return subclass;
    }



    /**
     * @Author zx
     * @Description 通过json
     * @Date 2019/12/19 9:21
     * @Param [parent, subclass]
     **/
    public static Object jsonParentSubclass(Object parent,Object subclass){
        String op = JSONObject.toJSONString(parent);
        return JSONObject.parseObject(op,subclass.getClass());
    }

}


 
3、测试
 
		Document document = new Document();
        document.setDocumentCd("11111111");
        document.setDocumentTitle("title");
        System.out.println("1:"+new Date().getTime());
        DocumentView documentView = (DocumentView) StrongParentSubclass.parentSubclass(document,new DocumentView());
        System.out.println("2:"+new Date().getTime()+"--"+documentView.getDocumentCd()+"--"+documentView.getDocumentTitle());
        System.out.println("1:"+new Date().getTime());
        DocumentView documentView1 = (DocumentView) StrongParentSubclass.jsonParentSubclass(document,new DocumentView());
        System.out.println("3:"+new Date().getTime()+"--"+documentView1.getDocumentCd()+"--"+documentView.getDocumentTitle());
        System.out.println(documentView);
 
结果：
 
1:1576720028591
2:1576720028592--11111111--title
1:1576720028592
3:1576720028788--11111111--title
com.power.xsj13000x.dto.v2.DocumentView@5ba23b66
 
根据结果发现，反射循环赋值时间更快一点。