抽象类和接口（二）

最新推荐文章于 2024-06-21 17:14:47 发布

Kyrie~Irving

最新推荐文章于 2024-06-21 17:14:47 发布

阅读量586

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_53714343/article/details/126807866

版权

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

package One;
//创建接口：
//可以先创建一个类，然后将class关键字修改为interface
//可以在创建类时，在窗口选择创建接口
/*
接口是一个规范，是一个公共标准，因此不给方法体
接口中的方法都是抽象方法
 */
public interface IUSB {
    void openusb();
    void closeusb();
}

package One;
/*
键盘需要通过USB设备来与电脑连接，所以要遵循接口规范
即键盘类只需要实现USB接口即可
 */
public class KeyBorad implements IUSB{
    public KeyBorad() {
        super();
    }
    //在ideal中按ctrl+I 键可以快速实现接口方法
    @Override
    public void openusb() {
        System.out.println("打开键盘");
    }
    public void takeon(){
        System.out.println("原神启动");
    }
    @Override
    public void closeusb() {
        System.out.println("关闭键盘");
    }
}

package One;
/*
鼠标需要通过USB设备来与电脑连接，所以要遵循接口规范
即鼠标类只需要实现USB接口即可
 */
public class Mouse implements IUSB {
    public Mouse() {
        super();
    }

    @Override
    public void openusb() {
        System.out.println("打开鼠标");
    }
      public void click(){
          System.out.println("点击鼠标");
      }
    @Override
    public void closeusb() {
        System.out.println("关闭鼠标");
    }
}

package One;

public class Computer {
    public void poweron(){
        System.out.println("开机");
    }
    public void poweroff(){
        System.out.println("关机");
    }
    public void UseIUSB(IUSB usb){
     usb.openusb();
     //此处就可以使用USB
        // 向下转型不安全
       // Mouse mouse=(Mouse)usb;
        if(usb instanceof Mouse){
            Mouse mouse=(Mouse)usb;
            mouse.click();
        }
        if(usb instanceof KeyBorad) {
         KeyBorad keyboard=(KeyBorad) usb;
         keyboard.takeon();
        }
     usb.closeusb();
    }
}

package One;

public class TestComputer {
    public static void main(String[] args) {
        Computer c=new Computer();
        c.poweron();
        c.UseIUSB(new Mouse());
        c.UseIUSB(new KeyBorad());

        c.poweroff();

    }
}

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

package Three;

public interface IInterface {
    //接口中的方法都是抽象方法
    //默认接口中的方法都是public abstract修饰
    //访问权限默认是public的，非public限定词修饰直接报错
    //接口中的方法默认情况下是抽象方法，所以不能添加实现体
    //接口中可以有成员变量，而且默认修饰符是public final static
    //接口中不能有构造方法和实例代码快以及静态代码块，因为：
    //1、实例代码块中的内容经过编译器编译之后，按照其在类中声明的先后次序需要依次加载到构造方法中的第一条语句之前
    //2、构造方法作用就是初始化对象，给对象中的普通成员变量一个合适的初始值
    //构造方法肯定有自己的实现体，即构造方法不能是抽象方法
    //但是在接口中的方法默认都是抽象方法，因此在接口中不能有构造方法和示例代码块以及静态代码块
    int a=100;
    public abstract void method();
    public void method2();
    abstract void method3();
    void method1();//更推荐这种
    /*IIterface(){
        //构造方法
    }
    static{
    // 静态代码块
    }
    {
    //代码块
    }
     */
    //在接口中如果接口必需要有实现体可以加修饰符default限定符修饰方法
    default void method4(){
        int a=10;
    }
}

package Three;

public class ComplementIInterface implements IInterface{
   // 在接口的实现类中：必须要将接口中的所有的抽象方法全部重写，否则将类实现为抽象类
    @Override
    public void method() {

    }
//类中实现接口中的抽象方法，访问限定词必须是public，因为接口中抽象方法默认是public修饰
    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method1() {

    }

    public static void main(String[] args) {

    }
}

package Three;

public class Test {

    public static void main(String[] args) {
      //  IInterface i1 = new IInterface();//接口无法实例化对象
    }
}

package Three;

public abstract class B implements IInterface{
    // 在接口的实现类中：必须要将接口中的所有的抽象方法全部重写，否则将类实现为抽象类
    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method1() {

    }

    @Override
    public void method4() {
        IInterface.super.method4();
    }
}

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

package Four;

public abstract class Animal {
    protected String name;
    protected String gender;
    protected int age;
    //经过分析发现所有的动物都需要吃饭睡觉，这些是共性方法
    public abstract void eat();
    public abstract void sleep();
    //跑，飞，游泳这些不是所有动物所具备的能力
    //这种情况下可以考虑将这些方法放到接口中
    /*
    public abstract void walk() ;
    public abstract void fly();
    public abstract void swim();
     */
}

package Four;
//类和类之间是extends继承关系，而且是单继承
//类和接口之间是implements 实现关系，一个类可以实现多个接口
//接口和接口之间是extends继承关系，一个接口可以继承多个接口
public class Dog extends Animal implements IWalk,ISwim{
    @Override
    public void sleep() {
        System.out.println("睡觉呼呼呼~~~");
    }
    @Override
    public void eat() {
        System.out.println("干饭");
    }

    @Override
    public void walk() {
        System.out.println("跑的快");
    }

    @Override
    public void swim() {
        System.out.println("狗砸会游泳！！");
    }
    public void method(Dog dog){
        dog.swim();
        dog.walk();
        dog.eat();
        dog.sleep();
    }
/*
    @Override
    public void swim() {

    }

    @Override
    public int hashCode() {

    }



    @Override
    public void walk() {

    }

    @Override
    public void fly() {

    }

     */
}

package Four;

public class Fish extends Animal implements ISwim{
    @Override
    public void eat() {
        System.out.println("嘬着吃");
    }

    @Override
    public void sleep() {
        System.out.println("睁着眼睛睡觉");
    }

    @Override
    public void swim() {
        System.out.println("游泳！！！");
    }
    public void fish(Fish f){
        f.eat();
        f.sleep();
        f.swim();
    }
}

package Four;
//接口和接口之间可以多继承
//接口之间的继承相当于是将多个接口合并到一起
public interface IAmphibious extends IWalk,ISwim{
}

package Four;

public interface IFly {
    void fly();
}

package Four;

public interface ISwim {
    void swim();
}

package Four;

public interface IWalk {
    void walk();
}

package Four;

public class TestAnimal {
    public static void main(String[] args) {
        Dog a1=new Dog();
        a1.eat();
        a1.sleep();
        a1.walk();
        a1.swim();
        System.out.println("--------------");
        a1.method(new Dog());
        System.out.println("--------------");
        Fish a2=new Fish();
        a2.fish(new Fish());
    }
}

接口使用实例：
给对象数组排序

package Five;

import java.util.Arrays;
//如果类的对象具有可比较性，只需要实现Comparable接口，并将接口中的抽象方法重写
//注意Comparable接口是泛型的
//Comparable接口是java.lang包中的接口，使用时不需要导入import对应的类或者接口
// public int compareTo(Object o)
public class Student implements Comparable<Student>{
    public String name;
    public int score;

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

    public static void main(String[] args) {
        Student[] student=new Student[]{
                new Student("张三",87),
                new Student("李四",88),
                new Student("王麻子",56),
                new Student("王五",32),
                new Student("张力",34),
        };
        Arrays.sort(student);//排序方法一：系统自带comparable接口
        Util.sort(student);//排序方法二：自己编写的Util方法
        for(int i=0;i<student.length;i++){
            System.out.println(student[i]);
        }
    }
    @Override
    public String toString() {
        return "["+name+" "+score+"]";
    }
    public int compareTo(Student o) {
        //在该方法内部我们需要用this和o关键字引用的对象中的某些字段进行比较
        //假设我们需要对学生的成绩进行比较
       /* if(this.score>o.score){
            return 1;
        }
        else if(this.score==score){
            return 0;
        }
        else{
            return -1;
        }
        */
        //注意如果使用this 引用对象减去o引用对象排序为升序，反之则为降序
        return score-o.score;

    }

}

package Five;

import java.util.Arrays;

public class TestInt {
    public static void main(String[] args) {
        int[] array={1,3,5,22,34,4,12,9};
        Arrays.sort(array);
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]+" ");
        }
        System.out.println();
    }
}

package Five;


public class Util {
    //冒泡排序序：
    //注意：通过sort方法实现排序时，创建的元素必须要实现comparable接口
    public static void sort(Comparable[] c){
        //外循环表示趟数
        for(int i=0;i<c.length-1;i++){
            for(int j=0;j<c.length-1-i;j++){
                if(c[j].compareTo(c[j+1])>=0){
                   Comparable temp=c[j];
                   c[j]=c[j+1];
                   c[j+1]=temp;
                }
            }
        }
    }
}

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.
然后比较当前对象和参数对象的大小关系(按分数来算).
如果当前对象应排在参数对象之前, 返回小于 0 的数字;
如果当前对象应排在参数对象之后, 返回大于 0 的数字;
如果当前对象和参数对象不分先后, 返回 0;