一、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;
}
}
四、深浅拷贝(了解,不用)
浅拷贝:克隆的对象和原对象是两个独立的对象,对象内部若包含了其他类的引用,克隆后的对象包含其他类的引用没有产生新对象,等于两个对象内部的其他对象是指向同一个对象的。
深拷贝:克隆对象的内部的其他类也是一个新的对象。两个对象从里到外都是新的。