java 抽象类与接口——接口

文章目录

• 1. 接口
• • 1.1 接口的概念
  • 1.2 语法规则
  • 1.3 接口的使用
  • 1.4 接口的特性
  • 1. 5 实现多个接口
  • 1.6 接口间的继承
  • 1.7 接口使用实例
  • 1.8 Clonable 接口和深拷贝
  • 1.9 抽象类和接口的区别
• 1. Object类
• • 2.1 获取实例对象
  • 2.2 对象比较equals方法
  • 2.3 hashcode方法

1. 接口

1.1 接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，手机的Type—c接口等。

电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备。

手机Type—c接口上，可以插：耳机、充电线…所有符合规范的设备。

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

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

1.2 语法规则

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

interface IShape{
    public abstract void draw();
}
public class Test {
}

这里定义了一个draw方法（抽象方法），因为被abstract修饰所以不需要写出是怎样实现的。

1. 创建接口时, 接口的命名一般以大写字母 I 开头。
2. 接口的命名一般使用 “形容词” 词性的单词。
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性。

可以实现一个静态方法

interface IShape{
    public abstract void draw();
    default public void func() {
        System.out.println("YYDS！");
    }
    public static  void func1() {
        System.out.println("java!");
    }
}

接口不能实例化，那该怎么使用？

类与接口之间使用implements来实现多个接口。

class A implements IShape {
    @Override
    public void draw() {
        System.out.println("*******");
    }
}

1.3 接口的使用

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

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

【注意】

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

interface USB {
    public void openDevice();//打开
    public void closeDevice();//关闭
}
class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘~");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘~");
    }
    public void inPut(){
        System.out.println("键盘输入~");
    }
}
class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标~");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标~");
    }
    public void click() {
        System.out.println("鼠标点击~");
    }
}
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) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }
    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接口的对象

编译器报错

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

可见编译器报错。

1. 接口中不能有方法的具体实现。

可见编译器报错。

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

编译器报错。

1. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量。

   interface USB {

   public void openDevice();//打开
   public void closeDevice();//关闭
   public static final int brand = 1;

   }

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

报错

1. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
2. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
3. jdk8中：接口中还可以包含default方法

1. 5 实现多个接口

Java中不支持多继承，但是一个类可以实现多个接口。

用implements来实现，每个接口之间用逗号来连接。

interface A1 {
    public void func1();
}
interface B1 {
    public void func2();
}
class C1 implements A1,B1 {
    @Override
    public void func1() {
    }
    @Override
    public void func2() {
    }
}
public class Test {
}

下面来看一个例子。

interface IFlying {
    public void fly();
}
interface IRunning {
    public void run();
}
interface ISwimming {
    public void swim();
}
class Animals {
    protected String name;
    public void eat() {
        System.out.println("吃食物~");
    }
    public Animals(String name) {
        this.name = name;
    }
}
class Dog extends Animals implements IRunning, ISwimming{
    public Dog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑~");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳~");
    }
}
class Bird extends Animals implements IFlying{
    public Bird(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name + "正在飞~");
    }
}
class Frog extends Animals implements IRunning, ISwimming{
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑~");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳~");
    }
}
class Duck extends Animals implements IFlying, IRunning, ISwimming{
    public Duck(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name + "正在飞~");
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑~");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳~");
    }
}
class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}
public class Test1 {
    public static void walk(IRunning iRunning) {
       iRunning.run();
    }
    public static void main(String[] args) {
        walk(new Dog("小狗"));
        walk(new Duck("鸭子"));
        walk(new Frog("青蛙"));
        walk(new Robot("机器人"));
    }
}

狗是一种动物, 具有会跑、游泳的特性。
鸟是一种动物，具有会飞的特性。
青蛙也是一种动物, 既能跑, 也能游泳。
鸭子也是一种动物, 既能跑, 也能游, 还能飞。

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

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

1.6 接口间的继承

接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

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

interface Iflying {
    public void fly();
}
interface Iswimming {
    public void swim();
}
interface Ifunc extends Iflying, ISwimming {
    public void func();
}
interface Ifunc1 extends Ifunc {
    public void func1();
}

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

1.7 接口使用实例

class Student {
    public String name;
    public int age;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student[] student = new Student[3];
        student[0] = new Student("zhangsan", 19);
        student[1] = new Student("lisi", 17);
        student[2] = new Student("wangwu", 20);
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}

上面代码是按照学生的姓名比较的？还是按照学生的年龄比价的？

我们要让Student类可支持比较大小。

现在分别写出按照年龄和姓名排序的方法：

import java.util.Arrays;
import java.util.Comparator;
class StudentSort implements Comparable<StudentSort>{
    public String name;
    public int age;
    public StudentSort(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(StudentSort o) {
        if(this.age - o.age > 0) {
            return 1;
        }else if(this.age - o.age < 0) {
            return -1;
        }else {
            return 0;
        }
        //return 0;
    }
}
class AgeComparator implements Comparator<StudentSort> {
    @Override
    public int compare(StudentSort o1, StudentSort o2) {
        return o1.age - o2.age;
    }
}
class NameComparator implements Comparator<StudentSort> {
    @Override
    public int compare(StudentSort o1, StudentSort o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class TestSort {
    public static void main(String[] args) {
        StudentSort[] students = new StudentSort[3];
        students[0] = new StudentSort("zhangsan", 10);
        students[1] = new StudentSort("lisi", 40);
        students[2] = new StudentSort("wangwu", 5);
        AgeComparator ageComparator = new AgeComparator();//按照年龄排序
        Arrays.sort(students, ageComparator);
        System.out.println(Arrays.toString(students));
        NameComparator nameComparator = new NameComparator();//按照姓名排序
        Arrays.sort(students, nameComparator);
        System.out.println(Arrays.toString(students));
    }
}

输出的第一行是年龄有小到排序的，第二行是姓名有小到大排序的。

1.8 Clonable 接口和深拷贝

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

class Person1 implements Cloneable{
    public int id;
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person1 person = new Person1();
        person.id = 99;
        Person1 person1 = (Person1)person.clone();
        person1.id = 100;
        System.out.println(person);
        System.out.println(person1);
    }
}

浅拷贝：

先来看一段代码

class Money {
    public double  money = 12.5;
}
class Person implements Cloneable{
    public int id;
    public Money money = new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person1 = (Person)person.clone();
        System.out.println("person:" + person.money.money);
        System.out.println("person1:" + person.money.money);
    }
}

如果将person1中的money的值改变会发生什么呢？

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person1 = (Person)person.clone();
        person1.money.money = 199;
        System.out.println("person:" + person.money.money);
        System.out.println("person1:" + person.money.money);
    }
}

根据运行结果会发现，person1的值修改后。person的值也跟着一起修改了。
这种情况就叫做浅拷贝。

很明显这并不是想要得到的结果，那该怎么做呢？

深拷贝：

class Money implements Cloneable{
    public double m = 12.5;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public int id;
    public Money money = new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.money = (Money) this.money.clone();
        return tmp;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                '}';
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person2 = (Person)person.clone();
        person2.money.m = 1999;
        System.out.println("person："+person.money.m);
        System.out.println("person2："+person2.money.m);
    }
}

1.9 抽象类和接口的区别

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

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

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

抽象类存在的意义是为了让编译器更好的校验，像 Animal 这样的类我们并不会直接使用，而是使用它的子类。万一不小心创建了 Animal 的实例，编译器会及时提醒我们。

2. Object类

Object是Java默认提供的一个类，所有类的对象都可以使用Object的引用进行接收。

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

对于整个Object类中的方法需要实现全部掌握。
本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法。

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.name = name;
        this.age = age;
    }
}
class Student {
}
public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三", 19);
        Person person2 = new Person("张三", 19);
        System.out.println(person1.equals(person2));
    }
}

调试后可见person1和person2所在的位置不一样。

要换一种比较的方法。

按照自己的逻辑重写一下。

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        Person person = (Person) obj;
        if (this.name.equals(person.name) && this.age == person.age) {
            return true;
        }else {
            return false;
        }
    }
}
class Student {
}
public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三", 19);
        Person person2 = new Person("张三", 19);
        System.out.println(person1.equals(person2));
    }
}

2.3 hashcode方法

hashCode()这个方法，他帮我算了一个具体的对象位置。由于这里面涉及数据结构，现在只是简单的认识一下。

两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法。

我们可以来看示例代码：

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Student {
}
public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("zhangsan", 20) ;
        Person per2 = new Person("zhangsan", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}

可以看到两个值不一样大。

这里和equals一样需要重写一下。

import java.util.Objects;
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
class Student {
}
public class Test {
    public static void main(String[] args) {
        Person per1 = new Person("zhangsan", 20) ;
        Person per2 = new Person("zhangsan", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}

可以发现两个值一样大了。

• hashcode方法用来确定对象在内存中存储的位置是否相同
• 事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置