Java入门——JDK常用接口

- 一、JAVA万物之母——Object类
- 二、Comparable接口
- 三、克隆接口
- 四、深浅拷贝（了解，不用）

一、JAVA万物之母——Object类

object类时Java中所有类的默认父类，无需使用extends来定义。class声明的类都有一个父类，Object类。

题目1：为什么JAVA中会有Obiect类，有什么好处？
答：因为偶Object类是所有类的父类，使用Object引用来接收所有类型，参数最高统一化。
Java中所有类型都可以发生向上转型变为Object类型
比如：Object obj1 = new person();
void fun(Object obj){} //obj可以接收任意类型的对象

Object类中所有方法子类全都继承下来

所以System.out.println(任意引用类型)，默认调用该类型的toString方法。

所以想输出当前类的属性值，就覆写”toString“方法

public class ObjectTest {
    public static void main(String[] args) {
        Object obj = new Car();
        System.out.println(obj);
    }
}
class Car{}
输出：object_test.Car@1b6d3586

//上述代码的输出是个类似地址的东西，原因是object类里有toString方法。
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

若在子类里覆写的toString方法，结果会变成如下样子

public class ObjectTest {
    public static void main(String[] args) {
        Object obj = new Car();
        System.out.println(obj);
    }
}
class Car{
    @Override
    public String toString() {
        return "car的toString方法";
    }
}
输出：
car的toString方法

Java中引用数据类型之间属性比较相等使用equals方法,不能使用“==”，这个比较的是地址

Object类里有equals方法，但他不知道比较规则是什么，所以要比较自定义数据类型对象的属性值知否相等，需要覆写equals方法

下面object类中默认euqals方法
public boolean equals(Object obj) {
	//this是当前对象的引用，obj是要比较的对象
    return (this == obj);
}

public class ObjectTest {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",90);
        Student stu2 = new Student("李四",91);
        Student stu3 = new Student("李四",91);
        //由于这里比较的是地址，返回都是false
        System.out.println(stu1 == stu2);
        System.out.println(stu2 == stu3);
        //比较两个对象的属性值相等，需要用euqals方法
        System.out.println(stu2.equals(stu3));
    }
}
class Student{
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    @Override
    public boolean equals(Object obj){
        //当前对象就是obj，自己和自己比，一定是true
        if (this == obj){
            return true;
        }
        //当前对象和obj指向的对象不是一个地址
        //若obj指向的对象这个类的对象，等于和Student无关，返回false
        //instanceof判断引用指向的对象是否是Student类的对象
        if (obj instanceof Student){
            //obj指向的对象是Student类的对象，并且不是同一个对象
            //Object obj = new Student()
            //向下转型，取出比较对象的值
            Student stu = (Student) obj;
            return this.score == stu.score && this.name.equals(stu.name); //String类型的比较JDK已经覆写好了
        }
        return false;
    }
}
输出
false
false
true

向下转型的使用场景

当一个父类引用实际上指向了一个子类实例，我们需要用到子类独有的属性或方法时，需要用到向下转型

Object类可以接收所有引用数据类型的对象（接口，数组，类），若一个方法参数或者返回值是Object类型，说明该参数或者返回值可以是任意引用数据类型。

除了8大基本类型不能接收，其他类型Object都能接受——包装类的由来。

二、Comparable接口

java.lang.Comparable:当一个类实现了Comparable接口，说明该类具备可比较的能力。

首先看一个代码

public class ComparableTest {
    public static void main(String[] args) {
        int[] data = new int[]{3,2,1};
        //升序排序
        Arrays.sort(data);
        System.out.println(Arrays.toString(data));
    }
}
输出：
[1, 2, 3]

上面代码整型数组排序，数值之间的关系了然。

当我们自定义了一个类型，创建了几个对象，编译器不知道这几个对象如何比较大小，所以我们要覆写CompareTo()方法，说明比较的规则，让这个类具备比较的能力。

CompareTo()默认方法

public int compareTo(T o);

int返回值含义

返回值 > 0 表示当前对象this > 传入对象o ，交换

返回值 = 0 表示当前对象this = 传入对象o ，不交换

返回值 < 0 表示当前对象this < 传入对象o ，不交换

public class ComparableTest {
    public static void main(String[] args) {
        //创建person类型数组，并实例化
        Person[] people = new Person[]{
                new Person("张三",20),
                new Person("李四",18),
                new Person("王五",15)
        };
        //排序
        Arrays.sort(people);
        System.out.println(Arrays.toString(people));
    }
}
class Person implements Comparable{
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        //当o指向的对象就是this
        if (this == o){
            return 0;
        }
        //o指向的对象不是自己并属于这个类，向下转型成Person类，取出年龄属性
        if (o instanceof Person){
            //按照年龄大小比较
            Person per = (Person) o;
            return this.age - per.age;
        }
        //不属于Person类，报错
        throw new IllegalArgumentException("不是Perosn类型，无法比较");
    }
}
输出：
[Person{name='王五', age=15}, Person{name='李四', age=18}, Person{name='张三', age=20}]

Arrays.sort()方法的内部是根据Compable接口的compareTo方法的返回值进行比较.不一定是数值上的大小，按照自己的规则规定

当arr[j].compareTo(arr[j+1]) > 0,认为前一个大于后一个。arr[j]就是this;arr[j+1]就是o

三、克隆接口

java.lang.Cloneable

新对象是由原对象“拷贝”来的，属性值与原对象一直，但是两个独立的对象。

让一个类实现可复制的能力，实现Cloneable接口，覆写clone方法

Cloneable接口的源码

public interface Cloneable {
}

1）内部没有任何方法，类似这种接口成为“标记”接口，这个接口本身内部没有任何抽象方法，只有打上这个标记的子类才具备克隆的能力。

2）JVM在运行时会检查所有实现了Cloneable接口的子类，赋予其克隆的能力。
clone方法是object提供的方法
Object对象有个clone()方法，实现了对象中各个属性的复制

3）使用克隆的前提:
1. 实现Cloneable接口，这是一个标记接口，自身没有方法。 
2. 覆盖clone()方法，可见性提升为public。

4）Java中产生新对象的方式：
1.通过构造方法产生对象
new 类() ,在堆上开辟该类相应属性的空间，给属性默认值。
2.当调用Clone方法产生的对象，JVN会开辟与原对象内存大小相同的空间，并将对象中的属性值从原对象中复制一份。不会调用原对象的构造方法。（不推荐）

public class CloneableTest {
    public static void main(String[] args) {
        Animal animal = new Animal("dog");
        Animal animal1 = animal.clone();
        //是两个独立的对象
        System.out.println(animal == animal1);
        System.out.println(animal1.name);
    }
}

class Animal implements Cloneable{
    String name;

    public Animal(String name) {
        this.name = name;
    }
    public Animal clone(){
        Animal newAnimal = null;
        try {
            //调用父类，object类的克隆方法
            newAnimal = (Animal) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        return newAnimal;
    }
}

四、深浅拷贝（了解，不用）

浅拷贝：克隆的对象和原对象是两个独立的对象，对象内部若包含了其他类的引用，克隆后的对象包含其他类的引用没有产生新对象，等于两个对象内部的其他对象是指向同一个对象的。

深拷贝：克隆对象的内部的其他类也是一个新的对象。两个对象从里到外都是新的。

Java入门——JDK常用接口

Java相关栏目本月热门文章