当前位置：首页 > news >正文

阳泉网站建设网站推广简短吸引人的话

news 2025/9/17 8:51:59

阳泉网站建设网站,推广简短吸引人的话,排版设计模板免费,做前端常用的网站及软件目录一、接口（补） 1.1. 数组对象排序 1.2. 克隆接口 1.3. 浅拷贝和深拷贝 1.4. 抽象类和接口的区别一、接口（补） 1.1. 数组对象排序我们在讲一维数组的时候，使用到冒泡排序来对数组里的元素进行从小到大或从大…

一、接口（补）

1.1. 数组对象排序

1.2. 克隆接口

1.3. 浅拷贝和深拷贝

1.4. 抽象类和接口的区别

一、接口（补）

1.1. 数组对象排序

我们在讲一维数组的时候，使用到冒泡排序来对数组里的元素进行从小到大或从大到小的排序。上一期里面我们通过Comparable接口来比较Student对象里面的成员变量，如果Student对象实例化一个数组，并且数组里面有多个元素，我们也是可以通过冒泡排序来实现。

//定义Student类public class Student implements Comparable<Student>{public int age;public Student(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"age=" + age +'}';}@Overridepublic int compareTo(Student o) {return o.age - this.age;}
}

import java.util.Arrays;
import java.util.Comparator;public class Main {public static void BubbleSort(Comparable[] compare){for (int i = 0; i < compare.length-1; i++) {//表示比较的趟数for (int j = 0; j < compare.length-1-i; j++) {if(compare[j].compareTo(compare[j+1]) > 0){Comparable temp = compare[j];compare[j] = compare[j+1];compare[j+1] = temp;}}}}public static void main(String[] args) {Student[] stu = new Student[3];stu[0] = new Student(10);stu[1] = new Student(8);stu[2] = new Student(11);BubbleSort(stu);System.out.println(Arrays.toString(stu));}
}

以上代码可以参考博主之前的博客，这里就不做过多讲解了。以下为运行结果：

1.2. 克隆接口

public class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}、public class Main {public static void main(String[] args) {Person one = new Person("Paul",17);Person two = one.clone();//报错：'clone()' has protected access in 'java.lang.Object'}
}

我们如果想把one这个对象克隆到two这个对象，就可以使用clone这个方法，但是会报错，我们可以查看一下源码。双击shift，勾选“include non-project items”，在搜素框里面输入Object，点击Object java.lang，就可以看源码了。可以看到被protected关键字修饰Main类与clone方法不在同一个包路径下，所以在Main类里面无法通过Person类来访问。

package java.lang;import jdk.internal.vm.annotation.IntrinsicCandidate;@IntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;

既然不能直接访问，那我们只能进行间接访问。此时我们还需要再重写一个方法，重写之后依然会报错。我们来看一下Object里面的源码，把“throws CloneNotSupportedException”复制粘贴到main方法后面，可以看到等号左边是子类Person，右面却是父类Object，此时就需要向下转型并强转来对父类进行赋值。

但光有这些还是不够的，我们还差最后一步，实现克隆接口。Cloneable接口里面没有任何实现，所以就是一个空接口。

public class Person implements Cloneable//Cloneable的源码
public interface Cloneable {
}

以下是完整代码和运行结果：

public class Person implements Cloneable{public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class Main {public static void main(String[] args) throws CloneNotSupportedException{Person one = new Person("Paul",17);Person two = (Person) one.clone();System.out.println(two);}
}

下面我们来画图讲一下克隆是如何在栈和堆上工作的： one对象先在栈上开辟一块内存空间，指向堆上的地址，调用clone方法之后，直接又在堆上创建出一块，而two对象也指向了新克隆的空间。

1.3. 浅拷贝和深拷贝

（1）浅拷贝

看下面一段代码，我们在上面的代码基础上新增了一个Money类，在Main，我们先访问并打印两个对象的成员变量Money，然后修改two对象中的money的值，然后再打印，可以看到我明明只修改了two对象的成员变量，但one对象也被修改了。

class Money{public double money = 93.5;
}public class Person implements Cloneable{public String name;public int age;public Money m;public Person(String name, int age) {this.name = name;this.age = age;this.m = new Money();}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class Main {public static void main(String[] args) throws CloneNotSupportedException{Person one = new Person("Paul",19);Person two = (Person) one.clone();System.out.println(one.m.money);System.out.println(two.m.money);System.out.println("===============");two.m.money = 86.4;System.out.println(one.m.money);System.out.println(two.m.money);}
}

相信老铁们看到这个图之后，就一目了然了。虽然说one所指向的对象被拷贝克隆了一份，但m所指向的money对象却没有被克隆，one和two所指向的是同一个money对象，这就会导致我们修改了money对象的值，两个变量都会被修改。这就是浅拷贝。那么老铁们想一下如何实现深拷贝呢？

（2）深拷贝

我们给Money这个类后面也来上接口Cloneable，也需要对Money类里面进行方法重写，与上面的浅拷贝不同的是，我们对Person类里面的克隆重写进行了改动。

class Money implements Cloneable{public double money = 93.5;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class Person implements Cloneable{public String name;public int age;public Money m;public Person(String name, int age) {this.name = name;this.age = age;this.m = new Money();}@Overrideprotected Object clone() throws CloneNotSupportedException {Person tmp = (Person)super.clone();tmp.m = (Money) this.m.clone();return tmp;}
}public class Main {public static void main(String[] args) throws CloneNotSupportedException{Person one = new Person("Paul",19);Person two = (Person) one.clone();System.out.println(one.m.money);System.out.println(two.m.money);System.out.println("===============");two.m.money = 86.4;System.out.println(one.m.money);System.out.println(two.m.money);}
}