JavaSE第九节————抽象类和接口（上）

最新推荐文章于 2024-09-16 11:29:33 发布

莲雾flops

最新推荐文章于 2024-09-16 11:29:33 发布

阅读量621

点赞数 15

分类专栏： JAVASE学习文章标签：开发语言 java 学习

本文链接：https://blog.csdn.net/2301_79418684/article/details/132768606

版权

JAVASE学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

系列文章目录

JavaSE第九节————抽象类和接口（上）

抽象类和接口

抽象类
接口
Object类
内部类

一、抽象类

1.抽象类概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。比如：
在这里插入图片描述

在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstractmethod), 包含抽象方法的类我们称为抽象类(abstract class)

2.抽象类语法

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

// 抽象类：被abstract修饰的类
 abstract class Shape {
    // 抽象方法：被abstract修饰的方法，没有方法体
    abstract public void draw();
    abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
    }
    protected double area; // 面积
}

3.抽象类特性（ * * ）

抽象类不能直接实例化对象

Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

抽象方法不能是 private 的

abstract class Shape {
abstract private void draw();
} 
 
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
} 
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static

抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰

//园类
public class Circle extends Shape{
    private double r;
    final private static double PI = 3.14;
    public Circle(double r){
        this.r = r;
    }
    public void draw(){
    System.out.println("圆：r = "+r);
    }
        public void calcArea(){
        area = PI * r * r;
    }
}
 
// 矩形类
public class Rect extends Shape {
    private double length;
    private double width;
    Rect(double length, double width){
        this.length = length;
        this.width = width;
    }
    public void draw(){
        System.out.println("矩形: length= "+length+" width= " + width);
    }
    public void calcArea(){
    area = length * width;
    }
}
 
// 抽象类：被abstract修饰的类
public abstract class Shape {
    // 抽象方法：被abstract修饰的方法，没有方法体
    abstract public void draw();
    abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
    }
    protected double area; // 面积
}
 
public abstract class Triangle extends Shape {
    private double a;
    private double b;
    private double c;
    @Override
    public void draw() {
        System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
    }
 
 
//@Override
//double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类

抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

 abstract class Animal {
   public   String name;
   public int age;
     public Animal(String name,int age) {
         this.name = name;
         this.age = age;
     }


    abstract public void eat();
 }

 class Dog extends Animal {


     public Dog(String name, int age) {
         super(name,age);
     }

     public void eat() {
         System.out.println(name+"吃骨头");
     }
 }
public class Test {
     public static void eat(Animal animal){
         animal.eat();
     }
    public static void main(String[] args) {
        Animal animal = new Dog("kk",2);
        eat(animal);
    }
}

在这里插入图片描述

4.抽象类的作用

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.
普通的类也可以被继承和重写呀, 为什么非得用抽象类和抽象方法？
确实如此. 但是使用抽象类相当于多了一重编译器的校验.
使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.
很多语法存在的意义都是为了 “预防出错”, 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不
就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.
充分利用编译器的校验, 在实际开发中是非常有意义的.

二、接口

1.接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等
在这里插入图片描述

在这里插入图片描述
电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备
电源插座插孔上，可以插：电脑、电视机、电饭煲…所有符合规范的设备
通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.语法规则（ * * * ）

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

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

提示:

创建接口时, 接口的命名一般以大写字母 I 开头.
接口的命名一般使用 “形容词” 词性的单词.
阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

接口使用的注意事项:

接口是用interface关键字来修饰的
接口当中不能有被实现的方法，意味只能有抽象方法。但是两个方法除外：一个是被static修饰的方法一个是被default修饰的方法
接口中的抽象方法默认是public abstract修饰的
接口不能进行实例化
类和接口之间的关系，可以使用implements来关联
接口也是有对应的字节码文件的

3.接口使用（ * * ）

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

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

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系

实现笔记本电脑使用USB鼠标、USB键盘的例子

USB接口：包含打开设备、关闭设备功能
笔记本类：包含开机功能、关机功能、使用USB设备功能
鼠标类：实现USB接口，并具备点击功能
键盘类：实现USB接口，并具备输入功能

首先定义一个抽象类，里面包含打开和关闭的方法，也就是实现USB接口

// 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();
    }
}

这里又有一个关键字instanceof

instanceof是Java中的二元运算符，用于测试左边对象是否是右边类的实例，返回boolean的数据类型。

这里用于防止向下转型的不安全性

最后写一个测试类，实现整个流程

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();
    }

在这里插入图片描述

4.接口特性（ * * *）

接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
} // Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

在这里插入图片描述

接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)

public interface USB {
    // Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
}

在这里插入图片描述

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

public interface USB {
    void openDevice();
 
    // 编译失败：因为接口中的方式默认为抽象方法
    // Error:(5, 23) java: 接口抽象方法不能带有主体
    void closeDevice(){//用static或的default修饰可以
        System.out.println("关闭USB设备");
    }
}

在这里插入图片描述

重写接口中方法时，不能使用默认的访问权限

public interface USB {
    void openDevice(); // 默认是public的
    void closeDevice(); // 默认是public的
}
 
public class Mouse implements USB {
    @Override
    void openDevice() {
        System.out.println("打开鼠标");
    } 
 
// ...
 
} 
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public

在这里插入图片描述

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

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); // 可以直接通过接口名访问，说明是静态的
        // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
        USB.brand = 2.0; // 说明brand具有final属性
    }
}

在这里插入图片描述

接口中不能有静态或实例代码块和构造方法

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

接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
jdk8中：接口中还可以包含default方法

5.实现多个接口（ * * * ）

abstract class Animal{
    protected String name;
    protected int age;
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
    public abstract void eat();
}
//另外再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"
interface IFlying{
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
//接下来我们创建几个具体的动物
//猫, 是会跑的
class Cat extends Animal implements IRunning{
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "在吃猫粮");
    }

    @Override
    public void run() {
        System.out.println(this.name + "在用四只脚跑步");
    }
}
//鱼, 是会游的
class Fish extends Animal implements ISwimming{
    public Fish(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "在吃虾米");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "在水里游泳");
    }
}
//青蛙, 既能跑, 又能游(两栖动物)
class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "在吃虫子");
    }

    @Override
    public void run() {
        System.out.println(this.name + "在用双脚跳着跑步");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "在蹬腿游泳");
    }
}
//还有一种神奇的动物, 水陆空三栖, 叫做 "鸭子"
class Duck extends  Animal implements IRunning,ISwimming,IFlying{
    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(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 + "在飘在水上游泳");

    }
}
//不是动物
class Robot implements IRunning{

    @Override
    public void run() {
        System.out.println("机器人在跑步");
    }
}
public class Test {
        public static void func(Animal animal){
            animal.eat();
        }
        public static void running(IRunning iRunning){
            iRunning.run();
        }
        public static void swimming(ISwimming iSwimming){
            iSwimming.swim();
        }

        public static void flying(IFlying iFlying){
            iFlying.fly();
        }
    public static void main(String[] args) {
            //多态
       /* func(new Cat("猫",9));
        func(new Fish("鱼",9));
        func(new Frog("青蛙",9));
        func(new Duck("鸭子",9));*/

        //多接口的使用
        //在running方法内部,我们并不关注到底是哪种动物, 只要参数是会跑的
        running(new Duck("鸭子",3));
        running(new Cat("猫",3));
        running(new Frog("青蛙",3));
        //甚至参数可以不是 "动物", 只要会跑!
        running(new Robot());
        System.out.println("======分割线========");
        flying(new Duck("鸭子",3));
        //flying(new Cat("猫",3));//编译报错，因为Cat没有实现IFlying接口，所以不能引用Cat对象
        System.out.println("======分割线========");
        swimming(new Duck("鸭子",3));
        swimming(new Frog("青蛙",3));
        swimming(new Fish("鱼",3));
    }
}

在这里插入图片描述

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性

猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序⚪忘记类型.

6.接口间的继承

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

interface IRunning {
    void run();
}
interface ISwimming extends IRunning {//ISwimming接口不仅有ISwimming自己的功能
                               // 还有IRunning这个接口的功能
        void swim();
        }
        // 两栖的动物, 既能跑, 也能游

    class Frog implements ISwimming {

    @Override
    public void run() {


    }

    @Override
    public void swim() {

    }
}

通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.

接口间的继承相当于把多个接口合并在一起.

7.接口使用实例

Student 类实现 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='" + name + '\'' +
                ", age=" + age +
                '}';
    }

//通过对象的引用调用compareTo方法，默认只能是年龄的比较
    @Override
    public int compareTo(Student o) {//对类的侵入性比较强一旦写好了规定的比较方式那么以后就只能以这种方式比较了
        if (this.age > o.age){
            return  1;
        }else if (this.age == o.age){
            return 0;
        }else {
            return -1;
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 =new Student("kk",9);
        Student student2 =new Student("bb",7);
        System.out.println(student1.compareTo(student2));
    }
}

在这里插入图片描述

单独的类实现Comparator接口

这种方式做到了灵活比较，只需要传入2个要比较的对象


class 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='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//比较器
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);//调用compareTo时调用的是String自己重写的compareTo方法
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 =new Student("kk",9);
        Student student2 =new Student("bb",7);

        //比较年龄
        AgeComparator ageComparator = new AgeComparator();
        System.out.println(ageComparator.compare(student1,student2));

        //比较名字
        NameComparator nameComparator = new NameComparator();
        System.out.println(nameComparator.compare(student1,student2));
    }
}

在这里插入图片描述

给对象数组排序

class Student {
    private String name;
    private int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
 
    @Override
    public String toString() { //重写toString方法，方便后续使用
        return "[" + this.name + ":" + this.score + "]";
    }
}

再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序).

public static void main(String[] args) {
        Student[] students = new Student[] {
                new Student("张三", 95),
                new Student("李四", 96),
                new Student("王五", 97),
                new Student("赵六", 92),
        };
    }

按照之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢?

Arrays.sort(students);
System.out.println(Arrays.toString(students));
 
// 运行出错, 抛出异常.
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable

在这里插入图片描述

仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎么确定? 需要我们额外指定

让 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

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() { //重写toString方法，方便后续使用
        return "[" + this.name + ":" + this.score + "]";
    }


    @Override
    public int compareTo(Student o) {
        return this.score - o.score;//成绩从小到大排序
       // return o.score - this.score;//成绩从大到小排序
    }
}

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[] {
                new Student("张三", 95),
                new Student("李四", 96),
                new Student("王五", 97),
                new Student("赵六", 92),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }


}

在这里插入图片描述

用比较器给对象数组排序

class 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='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//比较器
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);//调用compareTo时调用的是String自己重写的compareTo方法
    }
}
public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] =  new Student("张三",23);
        students[1] =  new Student("王五",3);
        students[2] =  new Student("李四",14);
        System.out.println("排序前：" + Arrays.toString(students));

        /* AgeComparator ageComparator = new AgeComparator();
        //年龄比较
        Arrays.sort(students,ageComparator);*/

        //名字比较
        NameComparator nameComparator = new NameComparator();

        Arrays.sort(students,nameComparator);

        System.out.println("排序后：" + Arrays.toString(students));
    }
}

在这里插入图片描述

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.
然后比较当前对象和参数对象的大小关系(按分数来算).

1.如果当前对象应排在参数对象之前, 返回小于 0 的数字;
2. 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
3.如果当前对象和参数对象不分先后, 返回 0;
再次执行程序, 结果就符合预期了

注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 "可比较" 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则.

为了进一步加深对接口的理解, 可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序)

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

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

    public int compareTo(Student o){
        return o.age - this.age;
    }

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

    }


}
public class Test {
    public static void  bubbleSort(Comparable[] comparables){
        for (int i = 0; i < comparables.length - 1; i++) {
            for (int j = 0; j < comparables.length - 1 - i ; j++) {
                 if(comparables[j].compareTo(comparables[j + 1] )> 0){
                     Comparable tamp = comparables[j];
                     comparables[j] = comparables[j + 1];
                     comparables[j + 1] = tamp;
                 }
            }
        }
    }

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] =  new Student("张三",23);
        students[1] =  new Student("王五",3);
        students[2] =  new Student("李四",14);
        System.out.println("排序前：" + Arrays.toString(students));

        bubbleSort(students);

        System.out.println("排序后：" + Arrays.toString(students));
    }
}

在这里插入图片描述

8.Cloneable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.

class Person implements Cloneable{ //Cloneable 空接口/标记接口。表面当前类是可以被克隆的
    public String name;
    public 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
    protected Object clone() throws CloneNotSupportedException {//可能会抛出异常---不支持克隆异常
        return super.clone();
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("张三",10);

        Person person1 = (Person)person.clone();  //调用clone方法

        System.out.println(person);
        System.out.println(person1);

    }
}

在这里插入图片描述
浅拷贝 VS 深拷贝
Cloneable 拷贝出的对象是一份 “浅拷贝”

浅拷贝

观察以下代码:

class Money{
    public double m = 113.3;
}
class Person implements Cloneable{ //Cloneable 空接口/标记接口。表面当前类是可以被克隆的
    public String name;
    public int age;

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

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

    @Override
    protected Object clone() throws CloneNotSupportedException {//可能会抛出异常---不支持克隆异常
        return super.clone();
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("张三",10);

        Person person1 = (Person)person.clone();  //调用clone方法

        System.out.println("person:" + person.money.m);
        System.out.println("person1:" +person1.money.m);
        System.out.println("===========分割线=======");
        person.money.m = 1331.23; 
        System.out.println("person:" + person.money.m);
        System.out.println("person1:" +person1.money.m);

    }
}

在这里插入图片描述

如上代码，可以看到，通过clone，虽然只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。那么如何实现深拷贝呢？

深拷贝

class Money implements  Cloneable{
    public double m = 113.3;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{ //Cloneable 空接口/标记接口。表面当前类是可以被克隆的
    public String name;
    public int age;

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

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

    @Override
    protected Object clone() throws CloneNotSupportedException {//可能会抛出异常---不支持克隆异常
       /* return super.clone();//这里面在克隆person，没有克隆money*/
        Person temp = (Person) super.clone();
        temp.money  = (Money) this.money.clone();
        return temp;
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("张三",10);

        Person person1 = (Person)person.clone();  //调用clone方法

        System.out.println("person:" + person.money.m);
        System.out.println("person1:" +person1.money.m);
        System.out.println("===========分割线=======");
        person.money.m = 1331.23;
        System.out.println("person:" + person.money.m);
        System.out.println("person1:" +person1.money.m);

    }
}

在这里插入图片描述

9.抽象类和接口的区别

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! ).
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口

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

再次提醒: 抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们

在这里插入图片描述

莲雾flops

关注

15
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录