JavaSE常用类之Object类

1. hashCode方法

代码：

package NeiBuLei;

public class hashCode {

    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        AA aa4 = aa2;
        System.out.println("aa.hashCode()="+ aa.hashCode());  //aa.hashCode()=2129789493
        System.out.println("aa2.hashCode()="+ aa2.hashCode());  //aa2.hashCode()=1313922862
        System.out.println("aa3.hashCode()="+ aa3.hashCode());  //aa3.hashCode()=2129789493
        System.out.println("aa4.hashCode()="+ aa4.hashCode());   //aa4.hashCode()=1313922862

    }
}
class AA{}

两个引用，如果指向的是同一个对象，则哈希值肯定一样

两个引用，如果指向的是不同对象，则哈希值是不一样的

哈希值主要根据地址号来！不能将哈希值完全等价于地址

2. toString方法

代码：

package NeiBuLei;
public class toString {
    public static void main(String[] args) {
        test test = new test(1,2,3);
        test.toString();
        System.out.println(test.toString());
    }
}
class test{
    public int name;
    public int age;
    public int score;
    @Override
    public String toString() {
        return "test{" + "name=" + name + ", age=" + age + ", score=" + score + '}';
    }

    public test() {
    }

    public test(int name,int age,int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
}

3.clone方法

代码：

package NeiBuLei;
//用于创建并返回一个对象的拷贝
// clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建。
public class clone {
    public static void main(String[] args) {
        Charen p = new Charen(23, "zhang");
        Charen p1 = p;
        System.out.println(p);   //NeiBuLei.Charen@7ef20235
        System.out.println(p1);   //NeiBuLei.Charen@7ef20235
//打印的地址值是相同的，既然地址都是相同的，那么肯定是同一个对象。p和p1只是引用而已，他们都指向了一个相同的对象
// 可以把这种现象叫做引用的复制
        Charen s = new Charen(23, "zhang");
        Charen s1 = null;
        try {                     //要捕获
            s1 = (Charen)s.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
//两个对象的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量
        System.out.println(s);   //NeiBuLei.Charen@27d6c5e0
        System.out.println(s1);   //NeiBuLei.Charen@4f3f5b24
    }
}
 class Charen implements Cloneable {
    int age;
    String name;

    public Charen() {
    }

    public Charen(int age,String name) {
        this.age = age;
        this.name = name;
    }
     @Override   //重写方法
     protected Object clone() throws CloneNotSupportedException {
         return (Charen)super.clone();
     }
 }

深拷贝:深复拷贝象所引用的对象都复制了一遍

浅拷贝:被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象

浅复制仅仅复制所考虑的对象，而不复制它所引用的对象

String name 中name是String 引用，所以浅拷贝指向同一个name，深拷贝又复制了一个新的name，指向新复制的name。

4.getClass方法

代码：

package NeiBuLei;
//当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象
//返回对象的类
public class getClass {
    public static void main(String[] args) {
        Object o1= new Object();
        System.out.println(o1.getClass());   //class java.lang.Object
        A a = new A();
        System.out.println(a.getClass()); //class NeiBuLei.A

    }
}
class A{}

用于返回对象的类

5.equals方法

==是一个比较运算符

1. ==： 既可以判断基本类型，又可以判断引用类型
2. ==： 如果判断的是基本类型，判断的是值是否相等

 //==： 如果判断的是基本类型，判断的是 值 是否相等
        int x1 = 10;
        int x2 = 10;
        double x3 = 10.0;
        System.out.println(x1 == x2);//true
        System.out.println(x1 == x3);//true

3. ==： 如果判断的是引用类型，判断的是地址是否相等，即判断是不是同一个对象

package denghao;
public class Test01 {
    public static void main(String[] args) {
        //==： 如果判断的是引用类型，判断的是地址是否相等，即判断是不是同一个对象
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a==c);// ? true
        System.out.println(b==c);// true

        B obj = a;
        System.out.println(obj==c);// true
    }
}
class B{}
class A extends B{}

eauals:

只能判断引用类型

代码：

package NeiBuLei;

public class ObjectLei {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "zyx";
        Person p2 = new Person();
        p2.name = "zyx";
        //flase  //对象不同
        System.out.println(p1 == p2);// 引用类型——判断是否为同一个对象（地址）
        //true  //字符串相同
        System.out.println(p1.name.equals(p2.name));// p.name是String类型，重写了equals()方法——判断内容是否一样
        //flase   //对象不同
        System.out.println(p1.equals(p2));//p1,p2属于Person类，该类并没有重写equals()方法（继承父类equals()方法，即判断地址）

        String s1 = new String("abc");
        String s2 = new String("abc");
        //true   //字符串相同
        System.out.println(s1.equals(s2));
        //false   //对象不同
        System.out.println(s1 == s2);
    }
}
class Person{
    public String name;
}

6.wait和notify方法

代码：

package NeiBuLei;

//run()和start()方法属于线程类Thread
public class wait{
    static Object locate=new Object();
    public static class T1 extends Thread{   //T1线程
        public void run(){
            synchronized (locate){   //同步锁
                System.out.println("T1 start");
                try {
                    System.out.println("T1等待locate对象");
                    locate.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("T1 end");
            }
        }

    }
    public static class T2 extends Thread{    //T2线程
        public void run(){
            synchronized (locate){   //同步锁
                System.out.println("T2 被唤起");
                locate.notify();
                System.out.println("T2 end");

                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread t1=new T1();
        Thread t2=new T2();
        t1.start();
        t2.start();
    }
}

运行结果：

T1 start
T1等待locate对象
T2 被唤起
T2 end
//过几秒
T1 end

(1)对象的wait()方法和notify方法

Object.wait() 线程等待，当调用wait()方法，线程就是停止执行当前任务，转为等待，直到被唤起

Object.notify() 线程唤起，将等待状态下的线程唤起，继续执行任务

(2)线程wait()和notify()的工作原理:

当对象Object调用了wait()方法后，线程进入到Object对象的等待队列，多个线程等待同一个对象

当对象Object调用了wait()方法后，就会从等待队列里面随机选取一个线程并将其唤起，完全随机

(3)注意事项:

notifyALL():唤起所有等待序列的线程

wait()和notify()都必须先获取目标对象的监视器，这样才能进行后续工作

wait方法不能随便使用，必须包含在synchronized中