Java入门——JDK常用接口

一、JAVA万物之母——Object类

  1. object类时Java中所有类的默认父类,无需使用extends来定义。class声明的类都有一个父类,Object类。
题目1:为什么JAVA中会有Obiect类,有什么好处?
答:因为偶Object类是所有类的父类,使用Object引用来接收所有类型,参数最高统一化。
Java中所有类型都可以发生向上转型变为Object类型
比如:Object obj1 = new person();
void fun(Object obj){} //obj可以接收任意类型的对象

  1. 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方法
  1. 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;
    }
}

四、深浅拷贝(了解,不用)

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

深拷贝:克隆对象的内部的其他类也是一个新的对象。两个对象从里到外都是新的。
在这里插入图片描述

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值