java -- 标记接口

标记接口

标记接口（Marker Interface），又称标签接口（Tag Interface）
仅代表一个标记 不包含任何方法
标记接口是用来判断某个类是否具有某种能力
Cloneable标记接口

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

1. // Cloneable源码:
2. public interface Cloneable { }
3. // 仅代表一个标记
5. // 克隆的前提条件:
6.     // 被克隆的对象必须实现Cloneable接口
7.     // 必须重写clone方法

复制代码

基本使用

1. public class CloneableDemo {
2.     public static void main(String[] args) throws CloneNotSupportedException {
3.         // ArrayList类实现了Cloneable接口
4.         ArrayList<String> list = new ArrayList<String>();
5.         list.add("张三");
6.         list.add("李四");
7.         list.add("王五");
9.         ArrayList<String> listClone = (ArrayList<String>) list.clone();
10.         System.out.println(list == listClone);
11.         System.out.println(listClone);
12.     }
13. }

复制代码

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

1. public class CloneTest {
2.     public static void main(String[] args) {
3.         //传统方式:
4.         Student stu1 = new Student("张三", 12);
5.         //再次创建一个新的学生对象
6.         Student stu2 = new Student();
7.         //把stu1对象name的值取出来赋值给stu2对象的name
8.         stu2.setName(stu1.getName());
9.         //把stu1对象age的值取出来赋值给stu2对象的age
10.         stu2.setAge(stu1.getAge());
12.         System.out.println(stu1 == stu2);
13.         System.out.println(stu1);
14.         System.out.println(stu2);
16.         System.out.println("================");
17.         stu1.setName("李四");
18.         System.out.println(stu1);
19.         System.out.println(stu2);
20.     }
21. }
22. class Student {
23.     private String name;
24.     private int age;
26.     public String getName() {
27.         return name;
28.     }
30.     public void setName(String name) {
31.         this.name = name;
32.     }
34.     public int getAge() {
35.         return age;
36.     }
38.     public void setAge(int age) {
39.         this.age = age;
40.     }
42.     public Student(String name, int age) {
43.         this.name = name;
44.         this.age = age;
45.     }
47.     public Student() {
48.     }
50.     @Override
51.     public String toString() {
52.         return "Student{" +
53.                 "name='" + name + '\'' +
54.                 ", age=" + age +
55.                 '}';
56.     }
57. }

复制代码

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

克隆方式(浅拷贝):

1. /*
2. 实现Cloneable接口
3. 重写clone方法 将访问权限改为public 并将返回值类型改为Student
4. */
5. class Student implements Cloneable{
6.     private String name;
7.     private int age;
9.     public Student(String name, int age) {
10.         this.name = name;
11.         this.age = age;
12.     }
14.     @Override
15.     public Student clone() throws CloneNotSupportedException {
16.         return (Student) super.clone();
17.     }
18. }

复制代码

1. class CloneTest01 {
2.     public static void main(String[] args) throws CloneNotSupportedException {
3.         //克隆方式
4.         //创建学生对象
5.         Student stu1 = new Student("张三",12);
6.         //通过克隆获得一个student对象
7.         Student stu2 = stu1.clone();
10.         System.out.println(stu1 == stu2);
11.         System.out.println(stu1);
12.         System.out.println(stu2);
14.         stu1.setName("李四");
15.         System.out.println(stu1);
16.         System.out.println(stu2);
17.     }
18. }

复制代码

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

1. class Student implements Cloneable{
2.     private String name;
3.     private int age;
4.     private Car car;
6.     @Override
7.     public Student clone() throws CloneNotSupportedException {
8.         return (Student) super.clone();
9.     }
10. }
12. class Car {
13.     private String brand;
15.     public Car() {
16.     }
18.     public Car(String brand) {
19.         this.brand = brand;
20.     }
22.     public String getBrand() {
23.         return brand;
24.     }
26.     public void setBrand(String brand) {
27.         this.brand = brand;
28.     }
30.     @Override
31.     public String toString() {
32.         return "Car{" +
33.                 "brand='" + brand + '\'' +
34.                 '}';
35.     }
36. }
38. class CloneTest02 {
39.     public static void main(String[] args) throws CloneNotSupportedException {
40.         //克隆方式
41.         //创建学生对象
42.         Student stu1 = new Student("张三",12,new Car("宝马"));
43.         //通过克隆获得一个student对象
44.         Student stu2 = stu1.clone();
46.         System.out.println(stu1 == stu2);
47.         System.out.println(stu1);
48.         System.out.println(stu2);
50.         stu1.setName("李四");
51.         //stu1获得了Car修改Car的品牌
52.         stu1.getCar().setBrand("奔驰");
53.         //浅拷贝的局限性 引用类型只是拷贝了地址值 修改一个对象的的属性 另一个也改变了
54.         System.out.println(stu1);
55.         System.out.println(stu2);
56.     }
57. }

复制代码

使用深拷贝解决上述问题

1. //首先 Car类实现克隆接口 重写clone方法
2. class Car implements Cloneable {
3.     private String brand;
5.     public Car() {
6.     }
8.     public Car(String brand) {
9.         this.brand = brand;
10.     }
12.     public String getBrand() {
13.         return brand;
14.     }
16.     public void setBrand(String brand) {
17.         this.brand = brand;
18.     }
20.     @Override
21.     public String toString() {
22.         return "Car{" +
23.                 "brand='" + brand + '\'' +
24.                 '}';
25.     }
27.     @Override
28.     protected Car clone() throws CloneNotSupportedException {
29.         return (Car) super.clone();
30.     }
31. }
33. //修改Student的clone方法
34. class Student implements Cloneable {
35.     private String name;
36.     private int age;
37.     private Car car;
39.     public String getName() {
40.         return name;
41.     }
43.     public void setName(String name) {
44.         this.name = name;
45.     }
47.     public Student(String name, int age, Car car) {
48.         this.name = name;
49.         this.age = age;
50.         this.car = car;
51.     }
53.     public Car getCar() {
54.         return car;
55.     }
56.     public void setCar(Car car) {
57.         this.car = car;
58.     }
60.     public int getAge() {
61.         return age;
62.     }
63.     public void setAge(int age) {
64.         this.age = age;
65.     }
67.     public Student(String name, int age) {
68.         this.name = name;
69.         this.age = age;
70.     }
71.     public Student() {
72.     }
74.     @Override
75.     public String toString() {
76.         return "Student{" +
77.                 "name='" + name + '\'' +
78.                 ", age=" + age +
79.                 ", car=" + car +
80.                 '}';
81.     }
83.     @Override
84.     public Student clone() throws CloneNotSupportedException {
85. //        return (Student) super.clone();
86.         Student student = (Student) super.clone();
87.         Car car = this.car.clone();
88.         student.setCar(car);
89.         return student;
90.     }
91. }

复制代码

RandomAccess标记接口

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

1. public class ArrayList_Demo01 {
2.     public static void main(String[] args) {
3.         //创建ArrayList集合
4.         List<String> list = new ArrayList<String>();
5.         //添加100W条数据
6.         for (int i = 0; i < 1000000; i++) {
7.             list.add(i+"a");
8.         }
10.         //测试普通循环
11.         long startTime = System.currentTimeMillis();
12.         for (int i = 0; i < list.size(); i++) {
13.             //取出集合的每一个元素
14.             list.get(i);
15.         }
16.         long endTime = System.currentTimeMillis();
17.         System.out.println("普通循环遍历: "+(endTime-startTime));
19.         //测试迭代器遍历
20.         startTime = System.currentTimeMillis();
21.         //获取迭代器
22.         Iterator<String> it = list.iterator();
23.         while (it.hasNext()){
24.             //取出集合的元素
25.             it.next();
26.         }
27.         endTime = System.currentTimeMillis();
28.         System.out.println("迭代器遍历: "+(endTime-startTime));
29.     }
30. }

复制代码

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

1. ublic class LinkedList_Demo01 {
2.     public static void main(String[] args) {
3.         //创建LinkedList集合
4.         List<String> list = new LinkedList<String>();
5.         //添加10W条数据
6.         for (int i = 0; i < 100000; i++) {
7.             list.add(i+"b");
8.         }
10.         //测试普通遍历时间
11.         long startTime = System.currentTimeMillis();
12.         for (int i = 0; i < list.size(); i++) {
13.             //取出集合的每一个元素
14.             list.get(i);
15.         }
16.         long endTime = System.currentTimeMillis();
17.         System.out.println("普通遍历时间: "+(endTime-startTime));
19.         //测试迭代器
20.         startTime = System.currentTimeMillis();
21.         //获取迭代器
22.         Iterator<String> it = list.iterator();
23.         while (it.hasNext()){
24.             //取出集合的每一个元素
25.             it.next();
26.         }
27.         endTime = System.currentTimeMillis();
28.         System.out.println("顺序迭代器访问时间: "+(endTime-startTime));
29.     }
30. }

复制代码

实际应用

1. public class Test {
2.     public static void main(String[] args) {
3.         //我们今后可能有的集合不是直接创建的 可能是别人传递的
4.         //我们看到的就是一个List接口
5.         //至于具体的实现类可能不清楚
6.         List<String>  list = new ArrayList<>();
8.         //list = new LinkedList<>();
9.         //我们可以判断以下 这个list集合是否实现了RandomAccess接口
10.         //如果实现了 可以使用随机访问的方式来进行遍历
11.         //如果没实现 可以使用迭代器的方式来进行遍历 这样可以提高效率
12.         if(list instanceof  RandomAccess){
13.             for (int i = 0; i < list.size(); i++) {
14.             }
16.         }else {
17.             for (String s : list) {
19.             }
20.         }
21.     }
22. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！