Java~~类库

菜鸡也会飞

已于 2022-05-07 16:01:18 修改

阅读量303

点赞数

分类专栏： java 文章标签： java

于 2022-04-17 22:46:10 首次发布

本文链接：https://blog.csdn.net/weixin_57858263/article/details/124150666

版权

java 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

2、JDK类库的根类: Object
2.1、这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。
任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。

2.2、object类当中有哪些常用的方法?

        我们去哪里找这些方法呢?
        第一种方法:去源代码当中。(但是这种方式比较麻烦，源代码也比较难)
        第二种方法:去查阅java的类库的帮助文档。
*什么是API?
— 应用程序编程接口。(Application Program Interface )
— 整个JDK的类库就是一- 个javase的API.
— 每一个API都会配置一套API帮助文档。
        SUN公司提前写好的这套类库就是API。(一般每一份API都对应一份API帮助文档。)

2.3、目前为止我们只需要知道这几个方法即可:

        protected Object clone()         // 负责对象克隆的。
        int hashCode()         // 获取对象哈希值的一个方法。
        boolean equals (Object obj)         // 判断两个对象是否相等
        String toString()          //将对象转换成字符串形式
        protected void finalize()         // 垃圾回收器负责调用的方法

2.4、关于object类中的tostring方法

1、源代码长什么样?
public String toString(){
  return this.getClass().getName()+"@"+Integer.toHexString(hashCode());
}
源代码上toString() 方法的默认实现是:
类名@对象的内存地址转换为十六进制的形式

2、SUN公司设计toString()方法的目的是什么?

toString()方法的作用是什么?
toString()方法的设计目的是:通过调用这个方法可以将一个"java对象"转换成"字符串"的形式

3、其实SUN公司开发java语言的时候，建议所有的子类都去重写 toString()。
toString()应该是一个简洁的、详实的、易阅读的.

public class Test2 {
    public static void main(String[] args){
        MyTime t1=new MyTime(1970,1,1);
        String s1=t1.toString();
        //未修改Object的toString输出结果
        System.out.println(s1);
        System.out.println(t1.toString());//这两种方法都可以
    }
}
class MyTime extends Object{
    int year;
    int month;
    int day;
    public MyTime(){
        // super();
    }
    public MyTime(int year,int month,int day)
    {
        //super();
        this.year=year;
        this.month=month;
        this.day=day;
    }

}

通过修改toString方法之后：

public class Test2 {
    public static void main(String[] args){
        MyTime t1=new MyTime(1970,1,1);
        String s1=t1.toString();
        //修改Object的toString输出结果:
        //一个日期的对象转换成字符串形式的话，我可能还是希望能看到具体的日期信息
        System.out.println(s1);
        System.out.println(t1.toString());//这两种方法都可以
    }
}
class MyTime extends Object{
    int year;
    int month;
    int day;
    public MyTime(){
        // super();
    }
    public MyTime(int year,int month,int day)
    {
        //super();
        this.year=year;
        this.month=month;
        this.day=day;
    }
    public String toString() {
        return this.year+"年"+this.month+"月"+this.day+"日";
    }
}

/*
2.5、关于object类中的equals方法
1、equals方法的源代码

public boolean equals (object obj) {
           
         return (this = obj) ;

}

以上这个方法是object类的默认实现。
2、SUN公司设计equals方法的目的是什么?

以后编程的过程当中，都要通过equals方法来判断两个对象是否相等。
equals方法是判断两个对象是否相等的。

3、我们需要研究一下object类给的这个默认的equals方法够不够用!!!!

在object类中的equals方法当中，默认采用的是"=="判断两个java对象
        是否相等。而"=="判断的是两个java对象的内存地址，我们应该判断
        两个java对象的内容是否相等。所以老祖宗的equals方法不够用,
        需要子类重写equals.

4、判断两个java对象是否相等，不能使用“==", 因为"=="比较的是两个
对象的内存地址。
*/

public class Test02 {
    public static void main(String[] args){
        //判断两个基本数据类型的数据是否相等直接使用“==”就行。
        int a=100;
        int b=100;
        //这个“==”是判断a中保存的100和b中保存的100是否相等。
        System.out.println(a==b);//ture(相等)   false(不相等)

        //判断两个java对象是否相等，我们怎么办？能直接使用“==”吗？
        //创建了一个日期对象是：2008年8月8日。
        MyTime t1=new MyTime(2008,8,8);
        System.out.println(t1.toString());
        //又创建了一个日期对象是：2008年8月8日。
        MyTime t2=new MyTime(2008,8,8);
        System.out.println(t2.toString());
        //测试以下，比较两个对象是否相等，能不能使用“==”？？？
        //这里的“==”判断的是:t1中保存的对象内存的地址和t2中保存的对象内存的地址是否相等。
        //未重写equals方法之前
        System.out.println(t1.equals(t2));
        //重写之后

    }
}
class MyTime extends Object{
    int year;
    int month;
    int day;
    public MyTime(){
        // super();
    }
    public MyTime(int year,int month,int day)
    {
        //super();
        this.year=year;
        this.month=month;
        this.day=day;
    }

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

    }



}

改进后：比较两个对象的内容

代码如下：

public class Test02 {
    public static void main(String[] args){
        //判断两个基本数据类型的数据是否相等直接使用“==”就行。
        int a=100;
        int b=100;
        //这个“==”是判断a中保存的100和b中保存的100是否相等。
        System.out.println(a==b);//ture(相等)   false(不相等)

        //判断两个java对象是否相等，我们怎么办？能直接使用“==”吗？
        //创建了一个日期对象是：2008年8月8日。
        MyTime t1=new MyTime(2008,8,8);
        System.out.println(t1.toString());
        //又创建了一个日期对象是：2008年8月8日。
        MyTime t2=new MyTime(2008,8,8);
        System.out.println(t2.toString());
        //测试以下，比较两个对象是否相等，能不能使用“==”？？？
        //这里的“==”判断的是:t1中保存的对象内存的地址和t2中保存的对象内存的地址是否相等。
        //重写之后
        System.out.println(t1.equals(t2));
        

    }
}
class MyTime extends Object{
    int year;
    int month;
    int day;
    public MyTime(){
        // super();
    }
    public MyTime(int year,int month,int day)
    {
        //super();
        this.year=year;
        this.month=month;
        this.day=day;
    }
    //重写方法之后（比较的是内容）
    public boolean equals (Object obj) {
        //如果obj是空，直接返回false
        if (obj == null) {
            return false;
        }
        //如果obj不是一个MyTime,没有必要比较了，直接返回false
        if (!(obj instanceof MyTime)) {
            return false;
        }
        //如果this 和obj保存的内存地址相同，没必要比较了，直接返回true.
        //内存地址相同的时候指向的堆内存的对象肯定是同一个。
        if (this == obj) {
            return true;
        }
        //程序能够执行到此处说明说明？
        //说明了obj不是null，obj是MyTime类型。
        MyTime t = (MyTime) obj;//强制类型转换
        if (this.year == t.year && this.month == t.month && this.day == t.day) {
            return true;
        }
        return false;

    }

}

/*
java语言当中的字符串String有没有重写toString方法，有没有重写equals方法。
 */
public class Test03 {
    public static void main(String[] args){

        String s1="hello";
        String s2="abc";
        //实际上String也是一个类，不属于基本数据类型。
        //既然String是一个类，那么一定存在构造方法。
        String s3=new String("Test1");
        String s4=new String ("Test1");
        //new两次，两个对象内存地址，s3保存的内存地址和s4保存的内存地址不同。
        //==判断的是内存地址。不是内容。
        System.out.println(s3==s4);//false
        //比较两个字符串能不能使用双等号？
        //不能，必须调用equals方法。
        System.out.println(s3.equals(s4));//true

        //那么String流泪有没有重写toString方法，
        //如果没有，一个输出：java.lang.String@十六进制的地址
        //经过测试：String类已经重写了toString（）方法。
        String x=new String("动力节点");
        System.out.println(x.toString());//动力节点
        System.out.println(x);//动力节点
    }
}

进一步理解：

class Student{
    //学号；
    int no;
    //所在学校
    String school;
    public Student(){}
    public Student(int no,String school){
        this.no=no;
        this.school=school;
    }
    //重写toStringff
    public String toString(){
        return "学号"+no+",所在学校"+school;
    }
    //重写equals方法(当一个学生的学号相等，并且学校相同时，表示同一个学生)
    public boolean equals(Object obj){
        if(obj==null||!(obj instanceof Student))
            return false;
         if(this==obj)   return true;
         Student s=(Student)obj;//强制类型转换
         return (this.no==s.no&&this.school.equals(s.school)) ;
    }
}
public class Test04 {
    public static void main(String[] args){
        Student s1=new Student(111,"北京大学");
        Student s2=new Student(111,"北京大学");
        System.out.println(s1==s2);//false
        System.out.println(s1.equals(s2));//true
        Student s3=new Student(111,new String("北京大学"));
        Student s4=new Student(111,new String("北京大学"));
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//true
    }
}

/*

java语言当中的字符串String有没有重写toString方法，有没有重写equals方法。

总结:

1、String类已经重写了equals方法，比较两个字符串不能使用==,必须使用equals.
equals是通用的。
2、String类已经重写了toString方法。
大结论:
        java中什么类型的数据可以使用“=="判断
        java中基本数据类型比较是否相等，使用==

        java中什么类型的数据需要使用equals判断
        java中所有的引用数据类型统一使用equals方法来判断是否相等。
这是规矩。

class User{
    //用户名
    String name;
    //用户地址
    Address addr;
    public User(String name,Address addr){
        this.name=name;
        this.addr=addr;
    }
    //重写equals方法
    public boolean equals(Object obj){

        if(obj==null||!(obj instanceof User))
            return false;
        if(this==obj)   return true;
       User u=(User)obj;//强制类型转换
        if(this.name.equals(u.name)&&this.addr.equals(u.addr)){
            return true;
        }
        return false;
    }
}
class Address{
    String city;
    String street;
    String zipcode;
    public Address(){

    }
    public Address (String city,String street,String zipcode){
        this.city=city;
        this.street=street;
        this.zipcode=zipcode;
    }
    //注意：这里并没有重写equals方法。
    //这里的equals方法判断的是:Address对象和Address对象是否相等？
    public boolean equals(Object obj){

        if(obj==null||!(obj instanceof Address))
            return false;
        if(this==obj)   return true;
        Address a=(Address)obj;//强制类型转换
        if(this.city.equals(a.city)&&this.zipcode.equals(a.zipcode)&&this.street.equals(a.street)){
            return true;
        }
        return false;
    }
}
public class Test01 {
    public static void main(String[] args){
        User u1=new User("zhansan",new Address("北京","大兴区","1111"));
        User u2=new User("zhansan",new Address("北京","大兴区","1111"));
      System.out.println(u1.equals(u2));//true
    }
}

关于String类：

equals底层实现其实就是==,数据比较时分为两种情况,1:数据是基本类型,那么直接比较字面值即可,字面值相同就相等.2:数据是引用类型,那么就比较地址值.String是引用类型,在创建String时,两种方法,一种是直接赋值,这个时候,会把值存到常量池中,不会重新分配地址,所以不管是==还是equals都是true.第二种用new的方式,每次new都会分配一个新的地址,所以用==比较就是false,而String底层重写了equals和hashCode方法,只需要比较具体值是否相同,所以结果是true。---来自评论区友友的解释

public class Test09 {
    public static void main(String[] args ){
        String s1=new String("hello");
        String s2=new String("hello");
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
        System.out.println("============");
        String s3=new String("hello");
        String  s4="hello";
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));
        System.out.println("============");
        String  s5="hello";
        String  s6="hello";
        System.out.println(s5==s6);
        System.out.println(s5.equals(s6));
    }
}

关于“==”和equals之间的区分：

https://blog.csdn.net/why_youjjww/article/details/106352996

关于object类中的finalize()方法。

/*
关于object类中的finalize ()方法。
1、在object类中的源代码:
protected void finalize () throws Throwable { }
GC:负责调用finalize(方法。
2、finalize()方法只有一一个方法体，里面没有代码，而且这个方法是protected修饰的。
3、这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法。
不像equals_ toString, equals和toString ()方法是需要你写代码调用的。
finalize()只需要重写，重写完将来自动会有程序来调用。
4、finalize ()方法的执行时机:
当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用
finalize()方法。
5、 finalize() 方法实际上是SUN公司为java程序员准备的-一个时机，垃圾销毁时机。
如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize()方法当中。
6、静态代码块的作用是什么?
static {

}
静态代码块在类加载时刻执行，并且只执行一-次。
这是一个SUN准备的类加载时机。
finalize()方法同样也是SUN为程序员准备的-一个时机。
这个时机是垃圾回收时机。

7、提示： java中的垃圾回收器不是轻易启动的，垃圾太少，或者时间没到，种种条件下，有可能启动，也有可能不启动。

hashCode方法:

在object中的hashCode方法是怎样的?
public native int hashCode () ;
这个方法不是抽象方法，带有native关键字，底层调用C++程序。
hashCode()方法返回的是哈希码:
实际上就是一个java对象的内存地址，经过哈希算法，得出的一一个值。
所以hashCode()方法的执行结果可以等同看做一-个java对象的内存地址。

public class Test03{
    public static void main (String[] args) {
        Object b= new Object();
        int hashCodeValue = b. hashCode();
     //对象内存地址经过哈希算法转换的一个数字。可以等同看做内存地址。
            System.out.println (hashCodeValue) ; // 798154996
            MyClass1 mc = new MyClass1() ;
            int hashCodeValue2 = mc . hashCode () ;
            System.out. println (hashCodeValue2) ; //1392838282
        }
}
class MyClass1{
}

结果：

补充知识点：关于instanceof
instanceof是Java的一个保留关键字，左边是对象(引用数据类型)，右边是类或者是接口，返回类型是Boolean类型。它的作用是测试前面的对象是否是后面的类或者其子类、实现类创建的实例对象，如果是，则返回true，否则返回false。

instanceof使用注意事项
1.先有继承关系，再有instanceof的使用。
2.当该测试对象创建时右边的声明类型要么跟右边的类相同，要么与后面的类具有父子继承关系，否则编译器会报错。

作用：

可以运用于强制类型转换之前，首先判断前一个对象是否是后一个类的实例，是否可以成功转换，从而保证代码更加强壮！

菜鸡也会飞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java~~类库

2、JDK类库的根类: Object 2.1、这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。 2.2、object类当中有哪些常用的方法?我们去哪里找这些方法呢?第一种方法:去源代码当中。(但是这种方式比较麻烦，源代码也比较难)第二种方法:去查阅java的类库的帮助文档。 *什么是API? ...
复制链接

扫一扫