Java之接口+Object类

约定不等于承诺〃 2024-04-01 19:24 58阅读 0赞

**目录**

1.接口

1.1 接口的概念

1.2 语法规则

1.3.接口使用

1.4 接口特性

1.5 实现多个接口

1.6 接口间的继承

1.7 接口使用实例

1.8 Clonable 接口和深拷贝

1.9 抽象类和接口的区别

2 Object类

2.1 获取对象信息

2.2 对象比较equals方法

2.3 hashcode方法

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

## 1.接口 ##

### 1.1 接口的概念 ###

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

### 1.2 语法规则 ###

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

public interface 接口名称{
        // 抽象方法
        // public abstract 是固定搭配，可以不写
        public abstract void method1();
        public void method2();
        abstract void method3();
        void method4();
        //在接口中上述写法都是抽象方法
    }

提示:

1. 创建接口时, 接口的命名一般以大写字母 I 开头.

2. 接口的命名一般使用 "形容词" 词性的单词.

### 1.3.接口使用 ###

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

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

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

> 请实现笔记本电脑使用USB鼠标、USB键盘的例子
> 
> 1. USB接口：包含打开设备、关闭设备功能
> 
> 2. 笔记本类：包含开机功能、关机功能、使用USB设备功能
> 
> 3. 鼠标类：实现USB接口，并具备点击功能
> 
> 4. 键盘类：实现USB接口，并具备输入功能

1.USB接口

public interface USB {
        //打开设备
        void openDevice();
        //关闭设备
        void closeDevice();
    }

2. 鼠标类

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("鼠标点击");
        }
    }

3. 键盘类

public class KeyBoard implements USB{
        @Override
        public void openDevice() {
            System.out.println("打开键盘");
        }
    
        @Override
        public void closeDevice() {
            System.out.println("关闭键盘");
        }
        public void click(){
            System.out.println("鼠标点击");
        }
    
        public void inPut() {
            System.out.println("键盘输入");
        }
    }

4. 笔记本类

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){
                //向下转型，需要强制类型转换
                // instanceof ，如果该表达式为true，则可以安全转换
                Mouse mouse=(Mouse)usb;
                mouse.click();
            }else if(usb instanceof KeyBoard){
                KeyBoard keyBoard=(KeyBoard)usb;
                keyBoard.inPut();
            }
            usb.closeDevice();
        }
    }

5.测试类

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

运行结果

> 打开电脑  
> 打开鼠标  
> 鼠标点击  
> 关闭鼠标  
> 打开键盘  
> 键盘输入  
> 关闭键盘  
> 关闭电脑

### 1.4 接口特性 ###

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

public class Test {
        public static void main(String[] args) {
            //接口不能实例化
            //IShape shape=new IShape() ;
        }
    }
    // Error:(10, 19) java: day20210915.shape是抽象的; 无法实例化

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

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

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

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

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

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

5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量(静态常量)

public interface USB {
        double brand = 3.0; 
    }

6. 接口中不能有静态代码块和构造方法

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

7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

9. jdk8中：接口中还可以包含default方法。

default public void func(){
          System.out.println("fasfdfg");
    }

10.接口可以实现多态

interface IShape{
        void draw();
    }
    class Rect implements IShape{
        @Override
        public void draw() {
            System.out.println("矩形");
        }
    }
    class Circle implements  IShape{
        @Override
        public void draw() {
            System.out.println("圆形");
        }
    }
    public class Test {
        public static void drawMap(IShape shape){
            shape.draw();
        }
        public static void main(String[] args) {
            //向上转型
            IShape shape=new Rect();
            drawMap(shape);
            Rect rect=new Rect();
            drawMap(rect);
        }
    }

### 1.5 实现多个接口 ###

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物.

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

另外我们再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的".

interface IRunning{
        void run();
    }
    interface ISwimming{
        void swimming();
    }
    interface IFly{
        void fly();
    }

接下来我们创建几个具体的动物

狗, 是会跑的.

class Dog extends Animal implements IRunning{
        //先继承再实现
        public Dog(String name) {
            super(name);
        }
        @Override
        public void run() {
            System.out.println(name+"正在用四条腿跑");
        }
    }

鱼, 是会游的.

class Fish extends Animal implements ISwimming{
        public Fish(String name) {
            super(name);
        }
        @Override
        public void swimming() {
            System.out.println(name+"正在用尾巴游泳");
        }
    }

还有一种神奇的动物, 水陆空三栖, 叫做 "鸭子"

class Duck extends Animal implements IRunning,IFly,ISwimming{
        public Duck(String name) {
            super(name);
        }
    
        @Override
        public void run() {
            System.out.println(name+"正在用两条腿跑");
        }
    
        @Override
        public void swimming() {
            System.out.println(name+"正在漂在水上");
        }
    
        @Override
        public void fly() {
            System.out.println(name+"正在用翅膀飞");
        }
    }

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

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

> 狗是一种动物, 具有会跑的特性.
> 
> 鸭子也是一种动物, 既能跑, 也能游, 还能飞

有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.

例如, 现在实现一个方法, 叫 "散步"

public static void walk(IRunning iRunning){
        iRunning.run();
    }

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行

//第一种
    Dog dog = new Dog("狗");
    walk(dog);
    //第二种
    walk(new Dog("小白"));
    walk(new Duck("唐老鸭"));
    // 执行结果
    狗正在用四条腿跑
    小白正在用四条腿跑
    唐老鸭正在用两条腿跑

甚至参数可以不是 "动物", 只要会跑!

只要实现了IRunning接口的都能接收

class Robot implements  IRunning{
        private String name;
        public Robot(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            System.out.println(this.name+"跑");
        }
    }
    
    //第一种
    Robot robot = new Robot("机器人");
    walk(robot);
    //第二种
    walk(new Robot("机器人"));
    // 执行结果
    机器人跑
    机器人跑

### 1.6 接口间的继承 ###

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface  A{
        void funcA();
    }
    interface  B{
        void funcB();
    }
    //接口的拓展：通过extends拓展多个接口的功能
    //CC这个接口不仅具备func这个功能，还具备了A和B接口的功能
    interface CC extends A,B{
        void funcC();
    }
    //C要重写A,B,CC三个接口的方法
    class C implements CC{
        @Override
        public void funcA() {
    
        }
    
        @Override
        public void funcB() {
    
        }
    
        @Override
        public void funcC() {
    
        }
    }

通过接口继承创建一个新的接口CC. 此时实现接口创建的 C 类, 就继续要实现 funcC 方法, 也需要实现 funcA,funcB方法.

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

### 1.7 接口使用实例 ###

给对象数组排序

class Student {
        private String name;
        private int score;
        public Student(String name, int score) {
            this.name = name;
            this.score = score;
        }
        @Override
        public String toString() {
            return "[" + this.name + ":" + this.score + "]";
        }
    }

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

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 {
        private String name;
        private int score;
        public Student(String name, int score) {
            this.name = name;
            this.score = score;
        }
        @Override
        public String toString() {
            return "[" + this.name + ":" + this.score + "]";
        }
        @Override
        public int compareTo(Object o) {
            Student s = (Student)o;
            if (this.score > s.score) {
                return -1;
            } else if (this.score < s.score) {
                return 1;
            } else {
                return 0;
            }
        }
    }

sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.

然后比较当前对象和参数对象的大小关系(按分数来算).

*  如果当前对象应排在参数对象之前, 返回小于 0 的数字;
 *  如果当前对象应排在参数对象之后, 返回大于 0 的数字;
 *  如果当前对象和参数对象不分先后, 返回 0;

再次执行程序, 结果就符合预期了.

> // 执行结果
> 
> \[Student\{name='王五', score=97\}, Student\{name='李四', score=96\}, Student\{name='张三', score=95\}, Student\{name='赵六', score=92\}\]

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

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

public static void sort(Comparable[] array){
            for (int i = 0; i < array.length-1; i++) {
                for (int j = 0; j < array.length - 1 - i; j++) {
                    if(array[j].compareTo(array[j+1])>0){
                        Comparable tmp=array[j];
                        array[j]=array[j+1];
                        array[j+1]=tmp;
                    }
                }
            }
        }

再次执行代码

sort(students);
    System.out.println(Arrays.toString(students));

> 执行结果
> 
> \[Student\{name='王五', score=97\}, Student\{name='李四', score=96\}, Student\{name='张三', score=95\}, Student\{name='赵六', score=92\}\]

### 1.8 Clonable 接口和深拷贝 ###

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.

class Money{
        public  double money=12.25;
    }
    //空接口--》标记接口：表示当前对象可以被克隆
    class Student  implements  Cloneable{
      public String name;
      public Money m=new Money();
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    
        //浅拷贝
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
    }
    public class Test {
    
        public static void main(String[] args){
            Student student1=new Student();
            student1.name="mq";
            Student student2=(Student)student1.clone();
            System.out.println(student1);
            System.out.println(student2);
        }
    }
    // 输出结果
    // java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出

浅拷贝 VS 深拷贝

Cloneable 拷贝出的对象是一份 "浅拷贝"

深拷贝：增加一个引用并且申请了一个新的内存，使新的引用指向新的内存

浅拷贝：增加一个引用指向已经存在的内存

观察以下代码:

浅拷贝

class Money{
        public  double money=12.25;
    }
    //空接口--》标记接口：表示当前对象可以被克隆
    class Student  implements  Cloneable{
      public String name;
      public Money m=new Money();
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    
        //浅拷贝
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
    }
    public class Test {
        public static void main(String[] args) throws CloneNotSupportedException{
            Student student1=new Student();
            Student student2=(Student)student1.clone();
            System.out.println(student1.m.money);
            System.out.println(student2.m.money);
            student2.m.money=9.9;
            System.out.println(student1.m.money);
            System.out.println(student2.m.money);
        }
    }
    // 执行结果
    12.25
    12.25
    9.9
    9.9

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

深拷贝

class Money implements Cloneable{
        public  double money=12.25;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    class Student  implements  Cloneable{
        public String name;
        public Money m=new Money();
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    
        //深拷贝
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Student student=(Student)super.clone();
            student.m=(Money)this.m.clone();
            return student;
        }
    
    }
    public class Test {
        public static void main(String[] args) throws CloneNotSupportedException{
            Student student1=new Student();
            Student student2=(Student)student1.clone();
            System.out.println(student1.m.money);
            System.out.println(student2.m.money);
            student2.m.money=9.9;
            System.out.println(student1.m.money);
            System.out.println(student2.m.money);
        }
    }
    // 执行结果
    12.25
    12.25
    12.25
    9.9

##  ##

先克隆Student的对象，克隆了Student对象里面的Money对象，从而实现深拷贝。

##  ##

### 1.9 抽象类和接口的区别 ###

核心区别:

抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写),

接口中不能包含普通方法, 子类必须重写所有的抽象方法.

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.

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

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>区别</td> 
   <td>抽象类</td> 
   <td>接口</td> 
  </tr> 
  <tr> 
   <td>结构组成</td> 
   <td>普通类+抽象方法</td> 
   <td>抽象方法+全局变量</td> 
  </tr> 
  <tr> 
   <td>权限</td> 
   <td>各种权限</td> 
   <td>public</td> 
  </tr> 
  <tr> 
   <td>子类使用</td> 
   <td>使用extends关键字继承抽象类</td> 
   <td>使用implements关键字实现接口</td> 
  </tr> 
  <tr> 
   <td>关系</td> 
   <td>一个抽象类可以实现多个接口</td> 
   <td>接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口</td> 
  </tr> 
  <tr> 
   <td>子类限制</td> 
   <td>一个子类只能继承一个抽象类</td> 
   <td>一个子类可以实现多个接口</td> 
  </tr> 
 </tbody> 
</table>

## 2 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 obj) {
            System.out.println(obj);
        }
    }
    //执行结果：
    Person@1b6d3586
    Student@4554617c

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。

### 2.1 获取对象信息 ###

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

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

### 2.2 对象比较equals方法 ###

在Java中，==进行比较时：

a.如果==左右两侧是基本类型变量，比较的是变量中值是否相同

b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

c.如果要比较对象中内容，必须重写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("mq", 20) ;
            Person p2 = new Person("mq", 20) ;
            int a = 10;
            int b = 10;
            System.out.println(a == b); // 输出true
            System.out.println(p1 == p2); // 输出false
            System.out.println(p1.equals(p2)); // 输出false
        }
    }

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方法。

### 2.3 hashcode方法 ###

回忆刚刚的toString方法的源码：

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

hashcode方法源码：

public native int hashCode();

代码：

class Person {
        public String name;
        public int age;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    public class Test2 {
        public static void main(String[] args) {
            Person per1 = new Person("mq", 20) ;
            Person per2 = new Person("mq", 20) ;
            System.out.println(per1.hashCode());
            System.out.println(per2.hashCode());
        }
    }
    //执行结果
    460141958
    1163157884

注意事项：两个对象的hash值不一样。

像重写equals方法一样，我们也可以重写hashcode()方法。

class Person {
        ...
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    //执行结果
    460141958
    460141958

注意事项：哈希值一样。

结论：

1、hashcode方法用来确定对象在内存中存储的位置是否相同

2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。