java 之 接口

于 2022-11-17 11:29:36 发布
阅读量176 收藏
点赞数 1
分类专栏： 学习笔记 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47265327/article/details/127900753
版权

接口

1.1接口的概念

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

1.2接口的定义

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

public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

提示:

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

注意：类与接口是implements实现关系

  1. 使用关键字interface 来定义接口

  2. 接口不能被实例化

  3. 接口当中的成员默认是 public static final

  4. 接口当中的方法不写 默认为Public abstra

  5. 接口当中的方法不能有具体的实现，但是在JDK8开始，//但是从JDK8开始，可以写一个default修饰的方法

    interface IShape {
    //public String name = "1";
    //public static String name2 = "2";
    //public static final String name3 = "3";
    //String name4 = "4";

    void draw();
    
  	default public void func() {
        System.out.println("asdf");
  

}

  6. 接口当中不能有构造方法

  7. 接口需要被类实现 使用关键字implements

  8. 接口当中可以有static修饰的方法

1.3接口的使用

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

代码示例：

//usb接口
public interface IUSB {
    void openDevice();
    void closeDevice();

}

//鼠标类
public class Mouse implements IUSB {
    @Override
    public void openDevice() {
        System.out.println("打开鼠标服务");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标服务");
    }
    public void click(){
        System.out.println("点击鼠标");
    }
}

//键盘类
public class KeyBoard implements IUSB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
    public void inPut() {
        System.out.println("敲击键盘");
    }
}

//电脑类
public class Computer{

    public void open() {
        System.out.println("开机");
    }


    public void close() {
        System.out.println("关机");
    }

    //所有的USB设备 在电脑上都可以使用
    public void useDevice(IUSB 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 class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Mouse mouse = new Mouse();
        KeyBoard keyBoard = new KeyBoard();
        computer.useDevice(mouse);
        computer.useDevice(keyBoard);
    }
}

抽象类 是对一个事物在抽象

接口 是对一个行为 或者规范在 设定标准

1.4接口特性

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

    public class TestUSB {
    public statuc void main(String[] args) {
        USB usb = new USB();
    }
}

//error

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

    public interface USB {
    private void openDevice();//error
    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; // 默认被：final public static修饰
void openDevice();
void closeDevice();
}
public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性
}
}

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

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

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

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

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

1.5实现多个接口

一个类可以实现多个接口

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

代码示例：

package demo4;
//类可以实现一个普通类
//类还可以实现一个抽象类
//类可以实现一个普通类/抽象类的同时，实现多个接口

//接口可以通过extends拓展多个接口的功能


abstract class Animal {
    public String name;

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

interface IRunning {
    void run();
}
interface  ISwimming {
    void swim();
}
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 swim() {
        System.out.println( name + "游泳");
    }
}
class Bird extends Animal implements IFly {

    public Bird(String name) {
        super(name);
    }

    @Override
    public void fly() {
        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 swim() {
        System.out.println(name + "游泳");
    }

    @Override
    public void fly() {
        System.out.println(name + "飞");
    }
}
class Robot implements IRunning {

    @Override
    public void run() {
        System.out.println("机器人会跑");
    }
}

public class Test {

    public static void walk(IRunning iRunning) {
        iRunning.run();
    }
    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }
    public static void fly(IFly iFly) {
        iFly.fly();
    }

    public static void main(String[] args) {
        walk(new Dog("阿I"));
        walk(new Duck("阿e"));
        walk(new Robot());

        swim(new Fish("阿p"));
        swim(new Duck("阿e"));

        fly(new Bird("阿J"));
        fly(new Duck("阿e"));
    }
}

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

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

1.6接口之间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到
多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface A {
    void funcA();
}
interface B {
    void funcB();
}

//代表CC这个接口不仅具备func这个功能，还具备了A和B接口的功能
interface CC extends A,B {
    void funcC();
}
class C implements CC {


    @Override
    public void funcA() {
        
    }

    @Override
    public void funcB() {

    }

    @Override
    public void funcC() {

    }
}

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

类 可以继承一个类

类 可以继承一个抽象类

类 可以继承一个普通了/抽象类 同时 实现多个接口

接口 可以通过exends 拓展多个接口的功能

1.7接口的使用案例

package demo5;

import java.util.Arrays;

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public int score;

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

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

    @Override
    public int compareTo(Student o) {
        if(this.age > o.age) {
            return 1;

        }else if(this.age < o.age) {
            return -1;
        }else {
            return 0;
        }
        /* if(this.name.compareTo(o.name) > 0) {
            return 1;

        }else if(this.name.compareTo(o.name) < 0) {
            return -1;
        }else {
            return 0;
        }*/

    }
}

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("as",12,14);
        students[1] = new Student("df",44,66);
        students[2] = new Student("gh",32,77);

        //System.out.println(students[0].compareTo(students[1]));

        Arrays.sort(students);

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

    /*public static void main1(String[] args) {
        int[] array = {1,2,4,5,3,6,8,9,8};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }*/
}



package demo;

import java.util.Arrays;
import java.util.Comparator;

class Student1 {
    public String name;
    public int age;
    public int score;

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

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

}
class AgeComparator implements Comparator<Student1> {

    @Override
    public int compare(Student1 o1,Student1 o2) {
        return o1.age - o2.age;//升序
        //return o2.age; -o1.age;//降序
    }
}
class ScoreComparator implements Comparator<Student1> {


    @Override
    public int compare(Student1 o1, Student1 o2) {
        return o1.score - o2.score;
    }
}

class NameComparator implements Comparator<Student1> {

    @Override
    public int compare(Student1 o1, Student1 o2) {
        return o1.name.compareTo(o2.name);
    }
}


public class Test2 {
    public static void main(String[] args) {
        Student1[] students = new Student1[3];
        students[0] = new Student1("zhangsan",10,19);
        students[1] = new Student1("lisi",11,35);
        students[2] = new Student1("wangwu",15,47);

        //比较器
        AgeComparator ageComparator = new AgeComparator();

        ScoreComparator scoreComparator = new ScoreComparator();

        NameComparator nameComparator = new NameComparator();

        //Arrays.sort(students,ageComparator);
        //Arrays.sort(students,scoreComparator);
        Arrays.sort(students,nameComparator);

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

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

然后比较当前对象和参数对象的大小关系(按分数来算).
1.如果当前对象应排在参数对象之前, 返回小于 0 的数字;
2.如果当前对象应排在参数对象之后, 返回大于 0 的数字;
3.如果当前对象和参数对象不分先后, 返回 0;

1.8 Clonable 接口和深拷贝

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

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

1.8.1浅拷贝

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("修改前：");
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
        System.out.println("=================");
        student2.m.money = 99;
        System.out.println("修改后：");
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bvgqUKiS-1668655705695)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1668649016229.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Sh9wzzk-1668655705696)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1668649617367.png)]

1.8.2 深拷贝

若要实现深拷贝，当前对象的每一个对象都要拷贝

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 = (Student)super.clone();
        // 克隆了student对象里面的Money对象
        student.m = (Money) this.m.clone();
        return student;
        //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("修改前：");
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
        System.out.println("=================");
        student2.m.money = 99;
        System.out.println("修改后：");
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4PwThgOC-1668655705697)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1668650600744.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LZ0AcsLv-1668655705698)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1668650684497.png)]

1.9抽象类和普通类的区别（面试）

核心区别:

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0Y9BppRq-1668655705699)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1668650993321.png)]

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

1.1 对象比较equals方法

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

a.如果左右两侧是基本类型变量，比较的是变量中值是否相同
b.如果左右两侧是引用类型变量，比较的是引用变量地址是否相同
c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

 public boolean equals(Object obj) {
       Student student = (Student) obj;
       if (this.name.equals(student.name)) {
           return true;
       }
       return false;
    }

public static void main(String[] args) {
        Student student1 = new Student();
        student1.name = "zhangsan";

        Student student2 = new Student();
        student2.name = "zhangsan";

        boolean flg = student1.equals(student2);
        System.out.println("flg:" + flg);
    }


//运行结果
flg:true

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

public boolean equals(Object obj) {
      /* Student student = (Student) obj;
       if (this.name.equals(student.name)) {
           return true;
       }
       return false;*/
        if (obj == null) {
            return false ;
        }
        //指向的是同一个对象
        if(this == obj) {
            return true ;
        }
        // 不是Student类对象
        if (!(obj instanceof Student)) {
            return false ;
        }

    }

编译器自动生成

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

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

1.2 hashcode 方法

回忆的 toString 方法的源码：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NvPR5VBH-1668655705700)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1668655004806.png)]hashCode()这个方法，他帮我算了一个具体的对象位置

bug抓捕器
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值