Java-对对象的拷贝、抽象类和接口的区别、Object类、对象的比较方法和内部类

冷不防 2024-03-23 18:43 20阅读 0赞

**目录**

1.Clonable接口和深拷贝

2.抽象类和接口的区别

3.Object类

4.获取对象的信息

5.对象比较方法equals

6.内部类

--------------------

## **1.Clonable接口和深拷贝** ##

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

![8dffa056e6384118b5f04c40412090d6.png][]

![f2388de5376f444a93d33a5b13fedee1.png][]

![6ce156cc684d42bb80fc4d3159357d25.png][]

>     class Students  implements Cloneable {
>         public String name;
>         public int age;
>     
>         @Override
>         protected Object clone() throws CloneNotSupportedException {
>             return super.clone();
>         }
>     
>         public Students(String name, int age) {
>             this.name = name;
>             this.age = age;
>         }
>         @Override
>         public String toString() {
>             return "{" +
>                     "name=" + name +
>                     ", age=" + age +
>                     "}";
>         }
>     }
> 
>     public class text {
>         public static void main(String[] args) throws CloneNotSupportedException {
>             Students student1=new Students("张三",10);
>             Students student2=(Students) student1.clone();//强制类型转化
>             System.out.println(student1);
>             System.out.println(student2);
>         }
>     }

![430ebc09ca8343ec9873b5112821fc7b.png][]

>     class Money{
>         public double m=25.0;
>     }
>     class Students  implements Cloneable {
>         public String name;
>         public int age;
>         public Money money=new Money();
>     
>         @Override              浅拷贝
>         protected Object clone() throws CloneNotSupportedException {
>             return super.clone();
>         }
>     
>         public Students(String name, int age) {
>             this.name = name;
>             this.age = age;
>         }
>     
>         @Override
>         public String toString() {
>             return "{" +
>                     "name=" + name + " "+
>                     ", age=" + age +" "+
>                     ", money=" + money.m +
>                     '}';
>         }
>     }
>     
>     
>     public class text {
>         public static void main(String[] args) throws CloneNotSupportedException {
>             Students student1=new Students("张三",10);
>             Students student2=(Students) student1.clone();
>             System.out.println(student1);
>             System.out.println(student2);
>             System.out.println("====");
>             student1.money.m=15.0;
>             System.out.println(student1);
>             System.out.println(student2);
>         }
>     }

![bc9587a41b0a4d65befa7d9380c71580.png][]

![e944109442c347fa8323b8d257481b8c.png][]

**通过clone，我们只是拷贝了Students对象，但是Students对象中的Money对象，并没有拷贝，通过student1这个引用修改了m的值后，student2这个引用访问m的时候，值也发生了改变**。

>     class Money implements Cloneable{
>         public double m=25.0;
>     
>         @Override
>         protected Object clone() throws CloneNotSupportedException {
>             return super.clone();
>         }
>     }
>     class Students  implements Cloneable {
>         public String name;
>         public int age;
>         public Money money=new Money();
>     
>         @Override  //深拷贝，将引用的对象（student1）中的对象也拷贝到目标对象中
>         protected Object clone() throws CloneNotSupportedException {
>             Students temp=(Students) super.clone();
>             temp.money=(Money)this.money.clone();
>             return temp;
>         }
>     
>         public Students(String name, int age) {
>             this.name = name;
>             this.age = age;
>         }
>     
>         @Override
>         public String toString() {
>             return "{" +
>                     "name=" + name + " "+
>                     ", age=" + age +" "+
>                     ", money=" + money.m +
>                     '}';
>         }
>     }
>     
>     
>     public class text {
>         public static void main(String[] args) throws CloneNotSupportedException {
>             Students student1=new Students("张三",10);
>             Students student2=(Students) student1.clone();
>             System.out.println(student1);
>             System.out.println(student2);
>             System.out.println("====");
>             student1.money.m=15.0;
>             System.out.println(student1);
>             System.out.println(student2);
>         }
>     }

![1cc304719f924c1a914fe5d83d9e046a.png][]

![f8f4a77c56d244ebb2acc129eb5a367a.png][]

**通过clone，我们拷贝Students对象，同时将Students对象中的Money对象也进行拷贝。通过student1这个引用修改了m的值后，student2这个引用访问m的时候，值不会发生改变**。

## **2.抽象类和接口的区别** ##

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别，  
**核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。**  
抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。

![c2032ae1443a46f8840c6d81be5082cc.png][]

## **3.Object类** ##

Object是Java默认提供的一个类。Java里面除了Object类，**所有的类都是存在继承关系的。默认会继承Object父类**。即所有类的对象都可以使用Object的引用进行接收。

例如：使用Object接收所有类的对象。。

> class Person\{
> 
> \}  
> class Student\{
> 
> \}  
> public class Test \{  
> public static void main(String\[\] args) \{  
> function(new Person());  
> function(new Student());  
> \}  
> public static void function(Object object) \{  
> System.out.println(object);  
> \}
> 
> \}

![84e81c3e35364a7bb3a2330b3166bd74.png][]

Object类中有以下方法

![18a4a0b766074298a2d232825495b4dd.png][]

## 4.获取对象的信息 ##

如果要打印对象中的内容，可以直接重写Object类中的toString()方法。

> // Object类中的toString()方法实现  
> public String toString() \{  
> return getClass().getName() + "@" + Integer.toHexString(hashCode());  
>

![221643aab5bf42f192b28c02505db56a.png][]

## 5.对象比较方法equals ##

在Java中，==进行比较时：**如果==左右两侧是基本类型变量，比较的是变量中值是否相同；  
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同；如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的**。

> / /Object类中的equals方法  
> public boolean equals(Object obj) \{  
> return (this == obj); // 使用引用中的地址直接来进行比较  
> \}
> 
> class Person\{  
> private String name ;  
> private int age ;  
> public Person(String name, int age) \{
> 
> this.age = age ;  
> this.name = name ;  
> \}  
> \}  
> public class Test \{  
> public static void main(String\[\] args) \{  
> Person p1 = new Person("zhangsan", 20) ;  
> Person p2 = new Person("lisi", 20) ;  
> int a = 10;  
> int b = 10;
> 
> System.out.println(a == b);  
> System.out.println(p1 == p2);  
> System.out.println(p1.equals(p2));
> 
> \}  
> \}

![2b118f681e2543c39b03498d4b9a34ae.png][]

Person类重写equals方法后，然后比较：

> class Person\{  
> ...  
> @Override  
> public boolean equals(Object obj) \{  
> if (obj == null) \{  
> return false ;  
> \}
> 
> if(this == obj) \{  
> return true ;  
> \}
> 
> // 不是Person类对象  
> if (!(obj instanceof Person)) \{  
> return false ;  
> \}
> 
> Person person = (Person) obj ; // 向下转型，比较属性值  
> return this.name.equals(person.name) && this.age==person.age ;  
> \}  
>   
> \}

结论：**比较对象中内容是否相同的时候，一定要重写equals方法。**

## **6.内部类** ##

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么这个内部的完整结构最好使用内部类。在 Java  中， **可以将一个类定义在另一个类或者一个方法的内部，** **前者称为内部类，后者称为外部类** 。内部类也是封装的一种体现。

>  // OutClass是外部类 
> 
> public classOutClass  \{ 
> 
>  // InnerClass是内部类 
> 
>  class InnerClass \{ 
> 
>  \} 
> 
> \}

注意： **定义在** **class**  **类名** **\{\}花括号外部的，即使是在一个文件里，都不能称为内部类；内部类和外部类共用同一个** **java** **源文件，但是经过编译之后，内部类会形成单独的字节码文件。**

> public class  A \{ 
> 
>  ...
> 
> \} 
> 
> class  B \{ 
> 
> ...
> 
> \}//A、B是两个独立的类

1. **内部类的分类**

> 根据内部类在一个类的位置可以分为实例内部类、静态内部类和局部内部类。

> public class OutClass \{ 
> 
>  //成员位置： 实例内部类（未被static修饰）
> 
>  public class InnerClass1\{ 
> 
>  \} 
> 
>  // 成员位置：静态内部类 
> 
>  static class InnerClass2\{ 
> 
>  \} 
> 
>  public void method()\{ 
> 
>  // 方法中定义内部类： 局部内部类：几乎不用 
> 
>  class InnerClass5\{ 
> 
>  \} 
> 
>  \} 
> 
> \}

2. **内部类**

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

1. **实例内部类**

public class OutClass {
            private int a;
            static int b;
            int c;
            public void methodA(){
                    a = 10;
                    System.out.println(a);
            }
            public static void methodB(){
                    System.out.println(b);
            } 
            // 实例内部类：未被static修饰
            class InnerClass{
                    int c;
                    public void methodInner(){
                            // 实例内部类中可以直接访问外部类中任意访问限定符修饰的成员
                            a = 100;
                            b =200;
                            methodA();
                            methodB();
                            // 如果具有相同名称成员时，优先访问的是内部类自己的
    
                            c = 300;
                            System.out.println(c);
                            // 如果要访问外部类同名成员，使用外部类名称.this.同名成员名字 
    
                            OutClass.this.c = 400;
    
                            System.out.println(OutClass.this.c);
                       }
            } 
            public static void main(String[] args) {
            // 外部类：对象创建 以及 成员访问
            OutClass outClass = new OutClass();
            System.out.println(outClass.a);
            System.out.println(OutClass.b);
            System.out.println(outClass.c);
            outClass.methodA();
            outClass.methodB();
            // 创建实例内部类对象
    
            OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
            // 也可以先将外部类对象先创建出来，然后再创建实例内部类对象(常用)
            OutClass.InnerClass innerClass2 = outClass.new InnerClass();
            innerClass2.methodInner();
            }
    }

注意：**外部类中的任何成员都可以在实例内部类方法中直接访问；实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束；实例内部类对象必须在先有外部类对象前提下才能创建 ；实例内部类的非静态方法中包含了一个指向外部类对象的引用；外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。**

**2.静态内部类**

public class OutClass {
            private int a;
            static int b;
            public void methodA(){
                    a = 10;
                    System.out.println(a);
            }
            public static void methodB(){
                    System.out.println(b);
            }
            // 静态内部类：被static修饰的成员内部类
            static class InnerClass{
                    public void methodInner(){
                            // 在内部类中只能访问外部类的静态成员
                            // a = 100; // 编译报错，a不是静态成员变量
                            b =200;
                            // methodA(); // 编译报错，methodB()不是静态成员方法
                            methodB();
                    }
            }
            public static void main(String[] args) {
    
                    // 静态内部类对象创建 、成员访问
                    OutClass.InnerClass innerClass = new OutClass.InnerClass();
                    innerClass.methodInner();
             }
    }

注意：**在静态内部类中只能访问外部类中的静态成员；创建静态内部类对象时，不需要先创建外部类对象。**

**3.匿名内部类**

>     interface IA {
>         void test();
>     }
>     public class text {
>         public static void main(String[] args) {
>             //匿名内部类
>             IA a = new IA() {
>                 @Override
>                 public void test() {
>                     System.out.println("这是重写了接口的方法！");
>                 }
>             };
>             a.test();
>             new IA() {
>                 @Override
>                 public void test() {
>                     System.out.println("这是重写了接口的方法！");
>                 }
>             }.test();
>         }
>     }

4.**局部内部类**

定义在外部类的方法体或者\{\}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。

> public class OutClass \{ 
> 
>  int a = 10; 
> 
>  public void method()\{ 
> 
>  int b = 10; 
> 
>  // 局部内部类：定义在方法体内部 
> 
>  // 不能被public、static等访问限定符修饰 
> 
>  class InnerClass\{ 
> 
>  public void methodInnerClass()\{ 
> 
>  System.out.println(a); 
> 
>  System.out.println(b); 
> 
>  \} 
> 
>  \} 
> 
>  // 只能在该方法体内部使用，其他位置都不能用 
> 
>  InnerClass innerClass = new InnerClass(); 
> 
>  innerClass.methodInnerClass(); 
> 
>  \} 
> 
>  public static void main(String\[\] args) \{ 
> 
>  // OutClass.InnerClass innerClass = null; 编译报错
> 
>  \} 
> 
> \}

[8dffa056e6384118b5f04c40412090d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7a7b395aa85b40028191e7f2b9ff1919.png
[f2388de5376f444a93d33a5b13fedee1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1b8ba458293a4297b31bf454a89fcb91.png
[6ce156cc684d42bb80fc4d3159357d25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/12893691cfac4b87a53bde882a3c8c0f.png
[430ebc09ca8343ec9873b5112821fc7b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6c9fe7e0fa334ecb84eb18f176dc285e.png
[bc9587a41b0a4d65befa7d9380c71580.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/46de73c6338547a7b11ece050dd0c0fb.png
[e944109442c347fa8323b8d257481b8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7843486767e240f68308dc2560d870a8.png
[1cc304719f924c1a914fe5d83d9e046a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6977792d7b7c43a496f34c59f1db9421.png
[f8f4a77c56d244ebb2acc129eb5a367a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c5baebb9221143dd9d8fa624cd40fbf4.png
[c2032ae1443a46f8840c6d81be5082cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6939b9ccfeeb49daa70d224b94772edc.png
[84e81c3e35364a7bb3a2330b3166bd74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7691c56205464b13a8e92c2a13a9930b.png
[18a4a0b766074298a2d232825495b4dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3cdda751c0324b1cbcdb33d4f8d98c7e.png
[221643aab5bf42f192b28c02505db56a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/79e69ca1d494408680bceedcb6d279ad.png
[2b118f681e2543c39b03498d4b9a34ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3af7615ece464ff2963bcb9d69667559.png