Analisis contoh penggunaan antara muka Java

Antaramuka

Satu aliran gambar

Konsep antara muka dan ringkasan beberapa titik pengetahuan

Antaramuka (Bahasa Inggeris: Antaramuka), dalam bahasa pengaturcaraan JAVA, ialah jenis abstrak dan koleksi kaedah abstrak . Antara muka biasanya Isytiharkan dengan antara muka. Kelas mewarisi kaedah abstrak antara muka dengan mewarisi antara muka.
Antara muka bukan kelas Cara menulis antara muka sangat serupa dengan kelas, tetapi ia tergolong dalam konsep yang berbeza. Kelas menerangkan sifat dan kaedah objek . Antara muka mengandungi kaedah untuk dilaksanakan oleh kelas .
Melainkan kelas yang melaksanakan antara muka ialah kelas abstrak, jika tidak, kelas mesti mentakrifkan semua kaedah dalam antara muka.
Antara muka tidak boleh digunakan segera, tetapi ia boleh dilaksanakan. Kelas yang melaksanakan antara muka mesti melaksanakan semua kaedah yang diterangkan dalam antara muka, jika tidak, ia mesti diisytiharkan sebagai kelas abstrak . Selain itu, dalam Java, jenis antara muka boleh digunakan untuk mengisytiharkan pembolehubah, ia boleh menjadi penunjuk nol , atau terikat pada objek yang dilaksanakan oleh antara muka ini.

Persamaan antara antara muka dan kelas

• Antara muka boleh mempunyai berbilang

• antara muka Fail disimpan dalam fail yang berakhir dengan .Java Nama fail menggunakan nama antara muka

• Fail kod bait antara muka disimpan dalam fail yang berakhir dengan .class

• Fail bytecode yang sepadan dengan antara muka mestilah dalam struktur direktori yang sepadan dengan nama pakej

Perbezaan antara antara muka dan kelas

• Antara muka tidak boleh digunakan untuk membuat seketika objek

• Antara muka tidak mempunyai kaedah pembina

• Semua kaedah dalam antara muka mestilah Kaedah abstrak Dalam antara muka selepas Java 8, anda boleh menggunakan kaedah bukan abstrak yang diubah suai dengan kata kunci lalai

• Antara muka tidak boleh mengandungi pembolehubah ahli, kecuali pembolehubah statik dan akhir

• Konsep bahawa antara muka diwarisi oleh kelas adalah tidak tepat, ia harus dilaksanakan oleh kelas

• Antara muka boleh dicapai. apa yang kita panggil warisan berbilang

Sesetengah ciri antara muka

• Setiap kaedah dalam antara muka juga abstrak secara tersirat, jadi kaedah dalam antara muka akan secara tersirat ditetapkan sebagai abstrak awam (Ia hanya boleh menjadi abstrak awam, pengubah suai lain akan melaporkan ralat)

• Antara muka mengandungi pembolehubah, tetapi pembolehubah dalam antara muka akan secara tersirat ditetapkan sebagai pembolehubah akhir statik awam (dan hanya boleh Ia adalah awam, mengubah suainya dengan peribadi akan melaporkan ralat penyusunan)

• Kaedah dalam antara muka tidak boleh dilaksanakan dalam antara muka , dan hanya boleh dilaksanakan oleh kelas yang melaksanakan antara muka

Perbezaan antara kelas abstrak dan antara muka

Sebelum JDK1.8, mereka mempunyai perkara berikut perbezaan

• Kaedah dalam kelas abstrak boleh mempunyai pernyataan boleh laku tertentu, iaitu badan kaedah, yang boleh merealisasikan fungsi khusus kaedah, tetapi kaedah dalam antara muka tidak boleh (contohnya :

  System.out.println(“Saya jagung super !!");)

• Pembolehubah ahli dalam kelas abstrak boleh terdiri daripada

  pelbagai jenis , manakala pembolehubah ahli dalam antara muka hanya boleh akhir statik awam taip

• antara muka tidak boleh mengandungi blok kod statik dan penggunaan kaedah statik (kaedah diubah suai dengan statik), manakala kelas abstrak boleh mempunyai blok kod statik dan kaedah statik

• Sebuah kelas hanya boleh mewarisi satu kelas abstrak, tetapi kelas boleh melaksanakan berbilang antara muka

Jadi di sini Perlu diingat bahawa:

Selepas JDK1.8, antara muka dibenarkan untuk mengandungi kaedah statik dan badan kaedah, dan dibenarkan untuk mengandungi kaedah pelaksanaan khusus Kami memanggil kaedah ini "kaedah lalai". Kaedah ini menggunakan Kata kunci lalai untuk mengubah suai
Selepas JDK1.9, kaedah dibenarkan untuk ditakrifkan sebagai peribadi, supaya kod yang digunakan semula tertentu tidak akan mendedahkan kaedah
Kelas abstrak wujud Maksudnya adalah untuk membenarkan pengkompil untuk mengesahkan dengan lebih baik Secara umumnya, kita tidak akan menggunakan kelas abstrak secara langsung, tetapi menggunakan subkelasnya Jika kita secara tidak sengaja mencipta objek melalui kelas abstrak, pengkompil akan mengingatkan kita dalam masa.

Nota: Semak imbas kandungan di atas secara kasar sekali Tidak mengapa jika anda tidak memahaminya saya akan menerangkannya satu persatu di bawah maka anda akan mempunyai pemahaman yang jelas tentang titik pengetahuan ini apabila anda melihat ke belakang Perasaan bangun dari mimpi besar

---

Jadi dalam kehidupan sebenar, apakah itu antara muka? Ia boleh menjadi port USB pada komputer riba, soket kuasa, dsb.

Kemudian antara muka ini juga berbeza dari segi pelaksanaan dan piawaian penggunaan

• Port USB komputer boleh dipalamkan ke: cakera U, tetikus, papan kekunci...semua peranti yang mematuhi protokol USB

• Bicu salur keluar kuasa boleh disambungkan ke: komputer, TV, periuk nasi...semua peralatan yang memenuhi peraturan

Melalui contoh di atas kita Dapat dilihat bahawa: Antaramuka ialah standard tingkah laku awam Apabila semua orang melaksanakannya, selagi ia memenuhi piawaian, ia boleh digunakan secara universal. Dalam Java, antara muka boleh dilihat sebagai: spesifikasi biasa untuk berbilang kelas, iaitu jenis data rujukan

Peraturan tatabahasa

Format definisi antara muka dan kelas definisi The format pada asasnya adalah sama Gantikan kata kunci kelas dengan kata kunci antara muka untuk menentukan antara muka.

public interface 接口名称{
    //抽象方法
    public abstract void method1();
    //public abstract是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();
    
    //注意：在接口中上述的写法都是抽象方法，所以method4这样写代码更整洁}

Petua:

1. Apabila mencipta antara muka, nama antara muka biasanya bermula dengan huruf besar I (disebut ai)

2. Penamaan antara muka secara amnya menggunakan perkataan dengan bahagian kata adjektif pertuturan

3. Adalah dipersetujui dalam piawaian pengekodan Alibaba bahawa tiada pengubah perlu ditambah pada kaedah dan atribut dalam antara muka untuk memastikan kod bersih

Penggunaan antara muka

Antara muka tidak boleh digunakan secara langsung dan digunakan kelas untuk melaksanakannya dan melaksanakan semua kaedah abstrak dalam antara muka

public class 类名称 implements 接口名称{
    //...}

Nota: Hubungan warisan antara subkelas dan kelas induk dilanjutkan, dan hubungan pelaksanaan antara kelas dan antara muka ialah melaksanakan.

Kelas dan antara muka tetikus USB dan papan kekunci USB digunakan dalam komputer riba untuk melaksanakan fungsi

1. Antara muka USB: termasuk fungsi membuka dan menutup peranti

2. Jenis komputer riba: termasuk fungsi hidup/mati kuasa dan fungsi peranti USB

3. Jenis tetikus: melaksanakan antara muka USB dan mempunyai fungsi klik

4. Kelas papan kekunci: melaksanakan antara muka USB dan mempunyai fungsi input

//USB接口public interface USB{
    void openDevice();
    void closeDevice();}//鼠标类，实现USB接口public class Mouse implements USB{
    @Override
    public void openDevice(){
        System.out.println("打开鼠标");
    }
    
    @Override
    public void closeDevice(){
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("鼠标点击");
    }}//键盘类，实现USB接口public class KeyBoard implements USB {
    @Override
    public void openDevice(){
        System.out.println("打开键盘");
    }
    
    @Override
    public void closeDevice(){
        System.out.println("关闭键盘");
    }
    
    public void inPut(){
        System.out.println("键盘输入");
    }}//笔记本类：使用USB设备public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
    
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }
    public void useDevice(USB usb){
        usb.openDevice();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse)usb;
            mouse.click();
        }else if(usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }}//测试类：public class TestUSB{
    public static void main(String[] args){
        Computer computer = new Computer();
        computer.powerOn();
   
    //使用鼠标设备
    computer.useDevice(new Mouse());
    
    //使用键盘设备
    computer.useDevice(new KeyBoard());
    
    computer.powerOff();
    }}

Output:

instanceof

Dalam contoh kod di atas, instanceof disebutkan Beberapa rakan mungkin tidak memahaminya saya telah memperkenalkannya dalam blog saya sebelum ini . Kata kunci terpelihara, dengan objek di sebelah kiri dan kelas di sebelah kanan, dan jenis pulangan ialah Boolean.
Fungsi khususnya adalah untuk menguji sama ada objek di sebelah kiri ialah objek instantiated yang dicipta oleh kelas kanan atau subkelas kelas kanan
Jika ya, ia akan mengembalikan benar, jika tidak ia mengembalikan palsu

[Nota tentang penggunaan instanceof Matters] Hubungan warisan sedia ada dan penggunaan instanceof (termasuk pelaksanaan antara muka)

[instanceof application scenario] Paksaan objek perlu digunakan Apabila penukaran jenis, anda perlu menggunakan instanceof untuk menilai

Ciri-ciri antara muka

1. Jenis antara muka ialah jenis rujukan, tetapi anda tidak boleh terus memperbaharui objek antara muka

public class TestUSB {
    public static void main(String[] args){
        USB usb = new USB();
    }}//编译会出错：USB是抽象的，无法实例化

2. Setiap kaedah dalam antara muka ialah kaedah abstrak awam , iaitu kaedah dalam antara muka akan secara tersirat ditetapkan sebagai abstrak awam (hanya boleh menjadi abstrak awam, pengubah suai lain akan melaporkan ralat)

public interface USB {
    //编译出错：此处不允许使用修饰符private
    //或者是java: 缺少方法主体, 或声明抽象
    private void openDevice();
    void closeDevice();
    //不同JDK版本编译器的标准是不一样的，报错也是不一样的}

3. Kaedah dalam antara muka tidak boleh dilaksanakan dalam antara muka dan hanya boleh dilaksanakan oleh Kelas yang melaksanakan antara muka melaksanakan

public interface USB {
    void openDevice();
    
    //编译失败：因为接口中的方法默认为抽象方法
    //Error：接口抽象方法不能带有主体}

Tetapi jika kita menambah lalai di sini, maka badan kaedah boleh dilaksanakan.

4. Apabila menulis semula kaedah dalam antara muka, lalai tidak boleh digunakan sebagai pengubahsuaian kebenaran akses

public interface USB {void openDevice();//默认为publicvoid closeDevice();//默认为public}public class Mouse implements USB {
    @Override
    void openDevice(){
        System.out.println("打开鼠标");
    }
    
    //...}//这里编译会报错，重写USB中的openDevice方法时，不能使用默认修饰符

Laksanakan antara muka ini dan julat pengubahsuai kelayakan akses bagi kaedah yang mengatasi antara muka ini adalah lebih besar daripada antara muka

5. Antara muka boleh mengandungi pembolehubah, tetapi pembolehubah dalam antara muka Akan ditentukan secara automatik dan tersirat oleh pengkompil sebagai

   akhir statik awampembolehubah

public interface USB {
    double brand = 3.0;//默认为：final public static修饰
    void openDevice();
    void closeDevice();}public class TestUSB {
    public static void main(String[] args){
        System.out.println(USB.brand);
        //可以直接通过接口名访问，说明变量时静态的
        
        //下面写法会报错 Java：无法为最终变量brand分配值
        USB.brand = 2.0;
        //说明brand具有final属性
    }}

6. antara muka Tidak boleh ada blok kod statik dan kaedah pembinaan dalam

public interface USB {
    public USB(){
    
    }//编译失败
    
    {
    
    }//编译失败
    
    void openDevice();
    void closeDevice();}

7. Walaupun antara muka bukan kelas, selepas antara muka disusun Format akhiran fail bytecode juga ialah .class

8. Jika kelas tidak melaksanakan semua kaedah abstrak dalam antara muka, kelas mesti ditetapkan kepada abstrak kelas

9. JDK8 menetapkan bahawa antara muka boleh mengandungi kaedah lalai yang disebutkan di atas

   
   

melaksanakan berbilang antara muka

Dalam Java, antara kelas Ia adalah warisan tunggal, dan kelas hanya boleh mempunyai satu kelas induk, iaitu,

Warisan berbilang tidak disokong dalam Java, tetapi sebuah kelas boleh melaksanakan berbilang antara muka. Kod berikut digunakan untuk menunjukkan

public class Animal {
    protected String name;
    
    public Animal(String name){
        this.name = name;
    }}

Kemudian kami menulis satu set antara muka untuk mewakili "benda yang boleh terbang", "benda yang boleh berlari" dan "benda yang boleh berenang".

public interface IFlying {
    void fly();}public interface IRunning {
    void run();}public interface ISwimming {
    void swim();}

那么接下来我们创建几个具体的动物类来接受并实现这些接口
比如，猫会跑

public class Cat extends Animal implements IRunning{
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        System.out.println("小猫"+this.name+"正在跑");
    }}

鱼会游泳

public class Fish extends Animal implements ISwimming{
    public Fish(String name){
     super(name);   
    }
    
    @Override
    public void swim() {
        System.out.println("小鱼"+this.name+"正在游泳");
    }}

而青蛙即会跑又会游泳

public class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name){
        super(name);
    }
    
    @Override
    public void run() {
        System.out.println("青蛙"+this.name+"正在跑");
    }

    @Override
    public void swim() {
        System.out.println("青蛙"+this.name+"正在游泳");
    }}

注意：一个类实现多个接口的时候，每个接口中的抽象方法都要去实现，除非类用abstract修饰，为抽象类

提示IDEA中使用ctrl + i 可以快速实现接口

还有一种动物水陆空三栖，它是大白鹅

public class Goose extends Animal implements IRunning,ISwimming,IFlying{
    public Goose(String name) {
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(this.name+"正在飞");
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"正在漂在水上");
    }}

这段代码展现了Java面向对象编程中最常见的用法：一个类继承了一个父类，然后同时实现多个接口
继承表达的含义是is-a,而接口表达的含义是具有xxx的特性

猫是一种动物，具有会跑的特性
青蛙是一种动物，即能跑也能有用
大白鹅也是一种动物，技能跑，也能游，还能飞

有了接口之后，类的使用者就不需要去关注具体的类的属性是否符合，而只需要关心某个类是否具有某个特性/功能，如果有，就可以实现对应的接口
那么我们现在实现一个走路的方法

public class TestDemo1 {
    public static void walk(IRunning iRunning){
        System.out.println("我带着小伙伴去散步");
        iRunning.run();
    }

    public static void main(String[] args) {
        Cat cat = new Cat("小猫");
        walk(cat);
        
        Frog frog = new Frog("小青蛙");
        walk(frog);
    }}

输出结果

只要是会跑的，带有跑这个属性特征的，都可以接受相应的对象

public class Robot implements IRunning{
    private String name;
    public Robot(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name+"正在用轮子跑");
    }

    public static void main(String[] args) {
        Robot robot = new Robot("机器人");
        walk(robot);
    }}

故输出结果为

接口之间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。
即：用接口可以达到多继承的目的
接口可以继承一个接口，达到复用的效果。这里使用extends关键字

interface IRunning {
    void run();}interface ISwimming {
    void swim();}//两栖的动物，即能跑，也能游泳interface IAmphibious extends IRunning ISwimming {}class Frog implements IAmphibious {
    ...}

通过接口继承创建一个新的接口IAmphibious表示“两栖的”。
创建的Frog类就实现了这个两栖的接口

接口之间的继承就相当于把多个接口合并到了一起

接口使用的例子

我们在之前的数组中讲解过给数组排序，那么我们该如何给对象数组排序呢？
首先我们定义一个Student的类，然后重写一下String方法

public class Student {
    private String name;
    private int score;
    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }}

我们再给定一个学生对象数组，根据这个对象数组中的元素进行排序
这里我们按照分数降序排序

public class Student {
    private String name;
    private int score;
    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("A",95),
                new Student("B",96), 
                new Student("C",97),
                new Student("D",98),
        };
    }}

那么按照我们之前的理解，数组中有一个可以供我们使用的sort方法，我们能否直接使用呢？

Arrays.sort(students);System.out.println(students);//运行结果：Exception in thread "main" java.lang.ClassCastException: class ClassArray.Student cannot be cast to class java.lang.Comparable (ClassArray.Student is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')
	at java.base/java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
	at java.base/java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
	at java.base/java.util.Arrays.sort(Arrays.java:1041)
	at ClassArray.Student.main(Student.java:36)

我们可以看到这里程序报错了，这里的意思是Student并没有实现Comparable的接口
那么这里的sort是进行普通数字的比较，大小关系明确，而我们指定的是两个学生对象的引用变量，这样的大小关系的指定是错误的，我们需要额外去人为规定对象中的比较元素
那么怎么实现呢？

我们可以用Student类实现Comparable接口，并实现其中的compareTo方法

public class Student implements Comparable<Student>{
    private String name;
    private int score;

    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", score=" + score +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(Student o) {
        if (this.score>o.score){
            return -1;//      如果当前对象应排在参数对象之前，则返回小于0的数字
        } else if(this.score<o.score){
            return 1;//      如果当前对象应排在参数对象之后，则返回大于0的数字
        } else{
            return 0;//      如果当前对象和参数对象不分先后，则返回0      
        }
        
    }}

那么我们在这里重写了compareTo的方法，自己定义了比较的规则，我们就自己再去写一个sort的方法，去调用这个compareTo方法，真正意义上实现对 对象数组的排序
我们使用冒泡排序法

    public static void sort(Comparable[] array){//        这里要注意，虽然接口不能实例化对象，//        但是接口类型的引用变量可以指向它的实现类对象//        这里的实现类对象就是实现了这个接口的对象//        例如Comparable[] comparable = new Student[3];//        所以这里的参数就可以用Comparable[] array来接收
        for (int bound = 0;bound<array.length;bound++){
            for (int cur = array.length-1;cur>bound;cur--){
                if (array[cur-1].compareTo(array[cur])>0){
                    //这里就说明顺序不符合要求，交换两个变量的位置
                    Comparable tmp = array[cur-1];
                    array[cur-1] = array[cur];
                    array[cur] = tmp;
                }
            }
    }}

sort方法写好了，我们写一个main函数来测试一下

    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("A",95),
                new Student("B",91),
                new Student("C",97),
                new Student("D",95),
        };
        System.out.println("sort前："+Arrays.toString(students));
        sort(students);
        System.out.println("sort后："+Arrays.toString(students));
    }

运行结果

E:\develop\Java\jdk-11\bin\java.exe "-javaagent:E:\IDEA\IntelliJ IDEA Community Edition 2021.3.2\lib\idea_rt.jar=65257:E:\IDEA\IntelliJ IDEA Community Edition 2021.3.2\bin" -Dfile.encoding=UTF-8 -classpath E:\JAVAcode\gyljava\Interface\out\production\Interface ClassArray.Studentsort前：[Student{name='A', score=95}, Student{name='B', score=91}, Student{name='C', score=97}, Student{name='D', score=95}]sort后：[Student{name='C', score=97}, Student{name='A', score=95}, Student{name='D', score=95}, Student{name='B', score=91}]

那么我们如果想要按照名字排序呢？也是可以的

import java.util.Arrays;import java.util.Comparator;/**
 * Created with IntelliJ IDEA.
 * Description: Hello,I would appreciate your comments~
 * User:Gremmie
 * Date: -04-13
 * Destination:利用Comparable的接口实现对 对象数组 选择性排序的功能
 */class Student implements Comparable<Student>{
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", age=" + age +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }}class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }}class NameComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }}public class TestDemo {

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",19);
        students[1] = new Student("lisi",8);
        students[2] = new Student("abc",78);
        AgeComparator ageComparator = new AgeComparator();
        NameComparator nameComparator = new NameComparator();
        
        
        //这里的方法sort是Array里面自带的，非常方便，
        //只需将我们写好的比较器传过去就好了
        System.out.println("排序前："+Arrays.toString(students));
        Arrays.sort(students,nameComparator);
        System.out.println("排序后："+Arrays.toString(students));
        Comparable<Student>[] studentComparable =students;
    }

    public static void main2(String[] args) {
        /*Student students1 = new Student("zhangsan",19);
        Student students2 = new Student("abc",78);
        if(students2.compareTo(students1) > 0) {
            System.out.println("fafaa");
        }*/


    }
    public static void main1(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",19);
        students[1] = new Student("lisi",8);
        students[2] = new Student("abc",78);
        System.out.println("排序前："+Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序后："+Arrays.toString(students));
    }}

Clonable接口以及深拷贝

其作用如其名，是用来进行克隆的，Clonable是个很有用的接口。
Object类中存在一个clone方法，调用这个方法可以创建出一个对象，实现“拷贝”。
但是我们想要合法调用clone方法，就要先实现Clonable接口，
否则就会抛出CloneNotSupportedException异常

/**
 * Created with IntelliJ IDEA.
 * Description: Hello,I would appreciate your comments~
 * User:Gremmie
 * Date: -04-13
 * Destination:利用Clonable的接口实现clone方法，克隆含对象的对象
 */class Money implements Cloneable{
    public double money = 19.9;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }}class Person implements Cloneable{
    public int id = 1234;
    public Money m = new Money();

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.m = (Money) this.m.clone();
        return tmp;
        //return super.clone();
    }}public class TestDemo {

    public static void main(String[] args) {
        Object o = new Person();

        Object o2 = new Money();


    }

    public static void main1(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person)person1.clone();
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        System.out.println("=========================");
        person2.m.money = 99.99;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
    }}

我们如果只是通过clone，那么就只是拷贝了Person的对象，但是Person中的money对象我们并没有拷贝下来，只是单纯拷贝下来一个地址，那么我们在这里就要进行深拷贝，讲Money类也接受Clonable接口，这样在调用clone方法的时候，money也会进行克隆

Atas ialah kandungan terperinci Analisis contoh penggunaan antara muka Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!