接口，抽象，拷贝

最新推荐文章于 2022-06-10 18:09:08 发布

mayu1020

最新推荐文章于 2022-06-10 18:09:08 发布

阅读量217

点赞数

分类专栏：对象与类接口与抽象与拷贝文章标签： java eclipse

本文链接：https://blog.csdn.net/mahongyu12/article/details/118878236

版权

对象与类同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

接口与抽象与拷贝

1 篇文章 0 订阅

订阅专栏

7.1引用拷贝：创建一个指向对象的引用变量的拷贝。

1、什么是抽象：

抽象关键字(abstract)。“抽象只从正确的角度，透露对象的某些相关细节。”

在面向对象编程理论中，抽象涉及到定义抽象对象的语言基础，它到底如何工作、如何获取和改变状态，并与系统中的其他对象进行“交流”。

抽象在任何编程语言中的许多方面起作用。从创建子程序到定义接口来，生成低级语言调用，例如设计模式。

抽象分为数据抽象和控制抽象：

（1）数据抽象：

数据抽象是创建复杂数据类型，只公开与数据类型交互有意义的操作，对外界隐藏了所有实现细节。

这种方法的好处包括随着时间的推移改进实现的能力，例如解决性能问题。其思想是，这些更改不应对客户机代码产生任何影响，因为它们不涉及抽象行为。

（2）控制抽象：

软件本质上是用任何编程语言编写的大量语句的集合。大多数情况下，语句都是相似的，多次重复。

控制抽象是识别所有这些语句并将其作为一个工作单元展现的过程(提取方法)。当我们创建一个函数来执行任何工作时，我们通常就是在抽象。

抽象是一种面向对象的编程实践的核心原则， Java具有所有OOPs原则，抽象是一个Java语言的主要构建块。

数据抽象的跨度从创建简单的数据对象集合的实现复杂如HashMap或HashSet。类似地，从定义简单的函数调用到完整的开源框架，可以看到控制抽象。控制抽象是结构化编程背后主要驱动力。

Java关于抽象最常被讨论的是abstract类和interfaces。

2、什么是接口：

接口(interface)是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。接口是多个应用程序的通信标准。接口就是给出一些没有内容的方法，封装在一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。

在jdk1.8以前的接口：
只包含常量和抽象方法，用于定义一组规范（相关或者不相关的对象的共同行为）。

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

注：JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。更多内容可参考 Java 8 默认方法。

注：JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。更多内容可参考 Java 9 私有接口方法。

3、什么是拷贝：

就是对对象的变量和属性进行拷贝。java里面拷贝分为深拷贝和浅拷贝。

4、抽象类详细学习：

抽象方法：只包含一个方法名，而没有方法体，使用abstract修饰，需要实现的话需要在子类或者接口里去进行实现。
格式：

{修饰符} abstract 返回类型方法名（）；

抽象类必须使用abstract修饰符来修饰。抽象方法也必须使用abstract修饰符来修饰，不能有方法体。
抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。
抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。

抽象类的构造器不能用于创建实例，主要是用于被其子类调用。抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

5、接口详细学习：

接口（interface），在java编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
在java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象；修饰符public、abstract。

接口：

1)、接口中的所有方法都不能有主体，不能被实例化。
2)、一个类可以实现多个接口。
3)、接口中可以有变量【但变量不能用private和protected修饰】。a、Java接口中的变量是公共的(public)，静态的(static)，最终的常量（final），相当于全局常量，所以定义接口变量时必须初始化。 b、接口中的变量，本质上都是static的，不管你加不加static修饰。c、在java开发中，我们经常用的变量，定义在接口中，作为全局变量使用。访问形式：接口名.变量名。
4)、一个接口不能继承其它的类，但是可以继承别的接口。
5)、接口没有方法就可以作为一个标志，比如可序列化的接口Serializable，没有方法的接口称为空接口。

格式：

public interface 接口名{}

接口的特性：

1）接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
2）接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
3）接口中的方法都是公有的。
4）编译时自动为接口里定义的方法添加public abstract修饰符
5）java接口里的成员变量只能是public static final共同修饰的，并且必须赋初值，可以不写public static final，编译的时候会自动添加。

实现接口：

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。类使用implements关键字实现接口。在类声明中，implements关键字放在class声明后面。接口运行多继承。

6、接口与抽象类的区别

7、深拷贝和浅拷贝的区别：

7.1引用拷贝：创建一个指向对象的引用变量的拷贝。

 public static void main(String[] args) {
        Teacher teacher = new Teacher("riemann", 28);
        Teacher otherTeacher = teacher;
        System.out.println(teacher);
        System.out.println(otherTeacher);
    }
}

class Teacher {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

结果分析：由输出结果可以看出，它们的地址值是相同的，那么它们肯定是同一个对象。teacher和otherTeacher的只是引用而已，他们都指向了一个相同的对象Teacher(“riemann”,28)。这就叫做引用拷贝。

结果：

dac.Teacher@4517d9a3
dac.Teacher@4517d9a3

7.2对象拷贝：创建对象本身的一个副本。

  public static void main(String[] args) {
        Teacher teacher = new Teacher("riemann", 28);
        Teacher otherTeacher = teacher;
        System.out.println(teacher);
        System.out.println(otherTeacher);
    }
}

class Teacher {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

结果分析：由输出结果可以看出，它们的地址是不同的，也就是说创建了新的对象，而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。

结果：

dac.Teacher@4517d9a3
dac.Teacher@4517d9a3

7.3浅拷贝定义：

如果一个对象内部还有一个引用类型的基本变量，那么在拷贝该对象的时候，只是在通过clone方法新产生的新对象中拷贝一个该基本类型的引用。换句话说，也就是新对象和原对象他们内部都含有一个指向同一对象的引用。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

 public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("riemann");
        teacher.setAge(28);

        Student student1 = new Student();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student student2 = (Student) student1.clone();
        System.out.println("-------------拷贝后-------------");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());

        System.out.println("-------------修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("jack");
        System.out.println("student1的teacher为： " + student1.getTeacher().getName());
        System.out.println("student2的teacher为： " + student2.getTeacher().getName());

    }
}

class Teacher implements Cloneable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Student implements Cloneable {
    private String name;
    private int age;
    private Teacher teacher;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }

结果：

-------------拷贝后-------------
edgar
18
riemann
28
-------------修改老师的信息后-------------
student1的teacher为： jack
student2的teacher为： jack

结果分析：两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。

7.4深拷贝定义：

拷贝对象的时候，如果对象内部含有一个引用类型的变量，那么就会再将该引用类型的变量指向的对象复制一份，然后引用该新对象。

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

 public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("riemann");
        teacher.setAge(28);

        Student student1 = new Student();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student student2 = (Student) student1.clone();
        System.out.println("-------------拷贝后-------------");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());

        System.out.println("-------------修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("jack");
        System.out.println("student1的teacher为： " + student1.getTeacher().getName());
        System.out.println("student2的teacher为： " + student2.getTeacher().getName());
    }
}

class Teacher implements Cloneable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student implements Cloneable {
    private String name;
    private int age;
    private Teacher teacher;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Object clone() throws CloneNotSupportedException {
        // 浅复制时：
        // Object object = super.clone();
        // return object;

        // 改为深复制：
        Student student = (Student) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher) student.getTeacher().clone());
        return student;

    }

结果：

-------------拷贝后-------------
edgar
18
riemann
28
-------------修改老师的信息后-------------
student1的teacher为： jack
student2的teacher为： riemann

结果分析：
两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。

8、修饰符范围

9、Comparable接口

功能：Comparable接口可用于对象的比较、对象的排序或者对象的分组。

介绍：

Comparable接口强行对实现它的类的每个实例进行自然排序，该接口的唯一方法compareTo方法被称为自然比较方法。

方法： int compareTo（Object o）

利用当前对象和传入的目标对象进行比较：

若是当前对象比目标对象大，则返回1，那么当前对象会排在目标对象的后面

若是当前对象比目标对象小，则返回-1，那么当前对象会排在目标对象的后面

若是两个对象相等，则返回0。

实例：

public class User implements Comparable<User> {
    
    public int age;
    public String username;

    public User(int age, String username) {
        this.age = age;
        this.username = username;
    }

    @Override
    public String toString() {
        return this.username;
    }

    @Override
    public int compareTo(User o) {
        if(this.age>o.age) {
            return 1;
        } else if(this.age<o.age) {
            return -1;
        } else {
            return 0;
        }
    }
    
    public static void main(String[] args) {
        User[] arr = new User[3];
        arr[0] = new User(15,"user1");
        arr[1] = new User(10,"user2");
        arr[2] = new User(20,"user3");
        
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        
        Arrays.sort(arr);
        
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));

    }

10、Cloneable接口

10.1使用：

创建对象有两种方式: new 和 clone

当一个对象创建过程复杂，我们是否可以根据已有的对象直接来克隆一份，而不必关系创建的细节呢（原型模式）。

定义：

当拷贝一个变量时，原始变量和拷贝变量引用同一个对象，也就是说，改变一个变量所引用的对象将会对另一个变量产生影响；如果创建一个对象的新copy，它的初始状态和原始对象一样，但以后将可以各自改变各自的状态，那就需要使用clone方法。默认的克隆操作是浅拷贝，它并没有克隆包含在对象中的内部对象。

Java Object根类默认提供的clone方法：

protected native Object clone() throws CloneNotSupportedException;

更常见的情况是子对象可变，因此必须重新定义clone方法，以便实现克隆子对象的深拷贝。在列举的示例中，hireDay域属于Date类，这就是一个可变的子对象。

对于每一个类，都需要做出下列判断：

默认的clone方法是否满足要求。
默认的clone方法是否能够通过调用可变子对象的clone得到修补。
是否不应该使用clone。

实际上，选项3是默认的。如果要选择1或2，类必须：

实现Cloneable接口。
使用public访问修饰符重新定义clone方法。必须谨慎地实现子类的克隆。

10.2实现Cloneable接口：

我们要使用一个对象的clone方法，必须Cloneable接口，这个接口没有任何实现，跟 Serializable一样是一种标志性接口

如果不实现Cloneable接口，会抛出CloneNotSupportedException异常

重写clone方法，使用public修饰（否则外部调用不到），调用父类的clone方法。

如下：

public class CloneModel implements  Cloneable{
    private String name;

    private int age;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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

10.3重写clone方法原则：

x.clone != x将会是true；

x.clone().getClass()==x.getClass()将会是true（不是绝对的，但建议这么做）

x.clone().equals(x)将会是true（不是绝对的，但建议这么做）。

重写父类（Object）的clone，让其可见
CloneNotSupportedException:调用的是父类的clone(),是一个本地方法
需要我们这个类是支持可克隆 ====> 实现Cloneable接口。

10.4 浅克隆：

例子：

class Model2{
    int height;
}

public class CloneModel implements  Cloneable{
    private String name;

    private int age;

    private Model2 model2;

    public CloneModel() {
        this.model2 = new Model2();
    }

    public Model2 getModel2() {
        return model2;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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

clone之后比较复杂对象是否相等

public static void main(String[] args) throws CloneNotSupportedException {

        CloneModel cloneModel1 = new CloneModel();

        CloneModel cloneModel2 = (CloneModel)cloneModel1.clone();

        System.out.println(cloneModel1.getModel2()==cloneModel2.getModel2());

    }

执行返回：true。

10.5 如何实现深克隆

定义：拷贝对象的时候，如果对象内部含有一个引用类型的变量，那么就会再将该引用类型的变量指向的对象复制一份，然后引用该新对象。

例子：

class Model2 implements Cloneable{
    int height;

    @Override
    public Object clone() throws CloneNotSupportedException {
        System.out.println("clone Model2");
        return super.clone();
    }
}

public class CloneModel implements  Cloneable{
    private String name;

    private int age;

    private Model2 model2;

    public CloneModel() {
        this.model2 = new Model2();
    }

    public Model2 getModel2() {
        return model2;
    }

    public void setModel2(Model2 model2) {
        this.model2 = model2;
    }

    @Override
    public CloneModel clone() throws CloneNotSupportedException {
        CloneModel cloneModelTemp = (CloneModel)super.clone();
        cloneModelTemp.setModel2((Model2)cloneModelTemp.getModel2().clone());
        return cloneModelTemp;
    }

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

操作：

public static void main(String[] args) throws CloneNotSupportedException {

        CloneModel cloneModel1 = new CloneModel();

        CloneModel cloneModel2 = cloneModel1.clone();

        System.out.println(cloneModel1.getModel2()==cloneModel2.getModel2());

    }

执行返回:false。

这么做就要在super.clone的基础上继续对非基本类型的对象递归的再次clone.

显然这么方式是繁琐的且不可靠的。

有没有其他的方式呢？有，序列化。

实现Serializable接口，jdk可以将该类进行序列化
对象转成字节序列（序列化），
作用：完成持久化，数据传输。

mayu1020

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
接口，抽象，拷贝

目录1、什么是抽象：2、什么是接口：3、什么是拷贝：4、抽象类详细学习：5、接口详细学习：6、接口与抽象类的区别7、深拷贝和浅拷贝的区别：7.1引用拷贝：创建一个指向对象的引用变量的拷贝。7.2对象拷贝：创建对象本身的一个副本。7.3浅拷贝定义：7.4深拷贝定义：8、修饰符范围1、什么是抽象：抽象关键字(abstract)。“抽象只从正确的角度，透露对象的某些相关细节。”在面向对象编程理论中，抽象涉及到定义抽象对象的语言基础，它到底如何工作、...
复制链接

扫一扫