java — 标记接口

标记接口

标记接口(Marker Interface),又称标签接口(Tag Interface)

仅代表一个标记 不包含任何方法
标记接口是用来判断某个类是否具有某种能力

Cloneable标记接口

此类实现了 Cloneable 接口,以指示 Object.clone 方法可以合法地对该类实例进行按字段复制
如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法, 则会导致抛出 CloneNotSupportedException 异常

// Cloneable源码:
public interface Cloneable { }
// 仅代表一个标记

// 克隆的前提条件:
    // 被克隆的对象必须实现Cloneable接口
    // 必须重写clone方法

基本使用

public class CloneableDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        // ArrayList类实现了Cloneable接口
        ArrayList<String> list = new ArrayList<String>();
        list.add("张三");
        list.add("李四");
        list.add("王五");

        ArrayList<String> listClone = (ArrayList<String>) list.clone();
        System.out.println(list == listClone);
        System.out.println(listClone);
    }
}

Clone案例:将一个学生的数据复制到另一个学生对象中,并且两个对象不受任何的影响.

传统方式:

public class CloneTest {
    public static void main(String[] args) {
        //传统方式:
        Student stu1 = new Student("张三", 12);
        //再次创建一个新的学生对象
        Student stu2 = new Student();
        //把stu1对象name的值取出来赋值给stu2对象的name
        stu2.setName(stu1.getName());
        //把stu1对象age的值取出来赋值给stu2对象的age
        stu2.setAge(stu1.getAge());

        System.out.println(stu1 == stu2);
        System.out.println(stu1);
        System.out.println(stu2);

        System.out.println("================");
        stu1.setName("李四");
        System.out.println(stu1);
        System.out.println(stu2);
    }
}
class Student {
    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 Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

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

此时修改对象1的姓名与对象2的姓名无关

克隆方式(浅拷贝):

/*
实现Cloneable接口
重写clone方法 将访问权限改为public 并将返回值类型改为Student
*/
class Student implements Cloneable{
    private String name;
    private int age;

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

    @Override
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();
    }
}
class CloneTest01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //克隆方式
        //创建学生对象
        Student stu1 = new Student("张三",12);
        //通过克隆获得一个student对象
        Student stu2 = stu1.clone();


        System.out.println(stu1 == stu2);
        System.out.println(stu1);
        System.out.println(stu2);

        stu1.setName("李四");
        System.out.println(stu1);
        System.out.println(stu2);
    }
}

浅拷贝的局限性:基本数据类型(包括String)可以达到完全复制,引用数据类型则不可以;

class Student implements Cloneable{
    private String name;
    private int age;
    private Car car;

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

class Car {
    private String brand;

    public Car() {
    }

    public Car(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

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

class CloneTest02 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //克隆方式
        //创建学生对象
        Student stu1 = new Student("张三",12,new Car("宝马"));
        //通过克隆获得一个student对象
        Student stu2 = stu1.clone();

        System.out.println(stu1 == stu2);
        System.out.println(stu1);
        System.out.println(stu2);

        stu1.setName("李四");
        //stu1获得了Car修改Car的品牌
        stu1.getCar().setBrand("奔驰");
        //浅拷贝的局限性 引用类型只是拷贝了地址值 修改一个对象的的属性 另一个也改变了
        System.out.println(stu1);
        System.out.println(stu2);
    }
}

使用深拷贝解决上述问题

//首先 Car类实现克隆接口 重写clone方法
class Car implements Cloneable {
    private String brand;

    public Car() {
    }

    public Car(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

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

    @Override
    protected Car clone() throws CloneNotSupportedException {
        return (Car) super.clone();
    }
}

//修改Student的clone方法
class Student implements Cloneable {
    private String name;
    private int age;
    private Car car;

    public String getName() {
        return name;
    }

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

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

    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }

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

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

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

    @Override
    public Student clone() throws CloneNotSupportedException {
//        return (Student) super.clone();
        Student student = (Student) super.clone();
        Car car = this.car.clone();
        student.setCar(car);
        return student;
    }
}

RandomAccess标记接口

List 实现所使用的标记接口,用来表明其支持快速(通常是固定时间)随机访问。此接口的主要目的是允许一般的算法更改其行为,从而在将其应用到随机或连续访问列表时能提供良好的性能
简单的来说,如果实现了这个接口,普通for循环的速度要优于增强for的速度.

public class ArrayList_Demo01 {
    public static void main(String[] args) {
        //创建ArrayList集合
        List<String> list = new ArrayList<String>();
        //添加100W条数据
        for (int i = 0; i < 1000000; i++) {
            list.add(i+"a");
        }

        //测试普通循环
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            //取出集合的每一个元素
            list.get(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通循环遍历: "+(endTime-startTime));

        //测试迭代器遍历
        startTime = System.currentTimeMillis();
        //获取迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            //取出集合的元素
            it.next();
        }
        endTime = System.currentTimeMillis();
        System.out.println("迭代器遍历: "+(endTime-startTime));
    }
}

LinkedList没有实现此接口,测试:

ublic class LinkedList_Demo01 {
    public static void main(String[] args) {
        //创建LinkedList集合
        List<String> list = new LinkedList<String>();
        //添加10W条数据
        for (int i = 0; i < 100000; i++) {
            list.add(i+"b");
        }

        //测试普通遍历时间
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            //取出集合的每一个元素
            list.get(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通遍历时间: "+(endTime-startTime));

        //测试迭代器
        startTime = System.currentTimeMillis();
        //获取迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            //取出集合的每一个元素
            it.next();
        }
        endTime = System.currentTimeMillis();
        System.out.println("顺序迭代器访问时间: "+(endTime-startTime));
    }
}

实际应用

public class Test {
    public static void main(String[] args) {
        //我们今后可能有的集合不是直接创建的 可能是别人传递的
        //我们看到的就是一个List接口
        //至于具体的实现类可能不清楚
        List<String>  list = new ArrayList<>();

        //list = new LinkedList<>();
        //我们可以判断以下 这个list集合是否实现了RandomAccess接口
        //如果实现了 可以使用随机访问的方式来进行遍历
        //如果没实现 可以使用迭代器的方式来进行遍历 这样可以提高效率
        if(list instanceof  RandomAccess){
            for (int i = 0; i < list.size(); i++) {
            }

        }else {
            for (String s : list) {

            }
        }
    }
}

原文链接:https://www.cnblogs.com/paopaoT/p/17321793.html

本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:java — 标记接口 - Python技术站

(0)
上一篇 2023年4月17日
下一篇 2023年4月17日

相关文章

  • 详解spring cloud如何使用spring-test进行单元测试

    当我们使用Spring Cloud来构建微服务应用程序的时候,我们需要对代码进行单元测试,以确保代码质量和应用的正确性。Spring提供了一个非常强大的测试框架:Spring Test,可以帮助我们实现Spring Cloud应用程序的单元测试。本文将详细介绍如何使用Spring Test进行单元测试。 什么是Spring Test 在我们开始介绍如何使用S…

    Java 2023年5月31日
    00
  • java用两个例子充分阐述多态的可拓展性介绍

    给您介绍一下如何使用Java的多态来实现可拓展性。 什么是多态 在Java中,多态是指一个对象的实际类型可能是其父类、接口或抽象类,这种特性可以让相同类型的对象执行相同的方法,但可能会有不同的实现方式。因此,多态可以让代码更加灵活,也更容易维护。 多态的可拓展性介绍 多态在Java中实现可拓展性的方法是,当新增一个子类时,只需要重写跟父类相同的方法即可,然后…

    Java 2023年5月20日
    00
  • java中简单的截取分割字符串实例

    那我来详细讲解一下“Java中简单的截取分割字符串实例”的攻略。 什么是字符串? 首先,我们需要明确一下,什么是字符串。在计算机领域中,字符串指的是由零个或多个字符组成的有限序列。 在Java中,字符串是一种特殊类型的对象,由java.lang.String类来实现。Java中的字符串是不可变的,也就是说,我们不能直接修改字符串的内容。但可以使用一些方法来对…

    Java 2023年5月27日
    00
  • java程序运行时内存分配详解

    Java程序运行时内存分配详解 Java程序运行时内存分配是Java程序员必须理解和掌握的重要知识点之一。了解内存分配可以帮助我们更好的管理内存,提高程序性能,避免程序崩溃等问题的出现。 Java内存分区 在Java中,内存分配主要分为以下几个区域: 程序计数器(Program Counter Register) 虚拟机栈(Java Virtual Mach…

    Java 2023年5月23日
    00
  • Java基本类型与byte数组之间相互转换方法

    请看下面的讲解。 Java基本类型与byte数组之间相互转换方法 在Java中,有时候我们需要将基本类型(如int、float等)转换成byte数组,或者将byte数组转换成基本类型。本文将提供两种方法来实现这种相互转换。 1. 使用Java的ByteBuffer类 Java的ByteBuffer类可以很方便地完成基本类型与byte数组的转换。 将基本类型转…

    Java 2023年5月26日
    00
  • Spring整合Struts2的两种方法小结

    下面我将详细讲解“Spring整合Struts2的两种方法小结”的完整攻略。 什么是Spring整合Struts2 Spring整合Struts2指的是将Struts2框架和Spring框架进行整合,使两者能够协同工作,共同完成一个Web应用的构建。这种整合方式有利于提高应用的开发效率和可维护性。 方法一:基于Struts2的Action实现Spring B…

    Java 2023年5月20日
    00
  • 如何自己动手写SQL执行引擎

    如何自己动手写SQL执行引擎 要自己动手写一个SQL执行引擎,需要掌握以下几个步骤: 设计关系型数据库 构建SQL解析器 构建执行计划 执行查询语句 下面逐个步骤进行详细讲解: 设计关系型数据库 在设计关系型数据库时,需要考虑以下几个方面: 数据表设计:每个表需要设计对应的字段、数据类型、主键等信息。 索引设计:需要根据查询需求设计合适的索引,提高查询效率。…

    Java 2023年6月16日
    00
  • Java实现的质因数分解操作示例【基于递归算法】

    下面是“Java实现的质因数分解操作示例【基于递归算法】”的完整攻略: 1. 质因数分解的概念 质因数分解,也叫素因子分解,是将一个正整数分解成一系列质数的积。比如,24可以分解成2x2x2x3,而30可以分解成2x3x5。 2. 基于递归算法的质因数分解示例 下面的示例是使用Java实现基于递归算法的质因数分解: public class PrimeFac…

    Java 2023年5月19日
    00
合作推广
合作推广
分享本页
返回顶部