栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java接口总结

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java接口总结

java接口总结
  • 1. 接口的要求
  • 2. 接口的定义 interface
  • 3. 接口使用
  • 4. 接口的例子
    • 画图接口
    • usb接口使用
  • 5. 多接口的继承
  • 6. 接口的扩展
  • 7. 比较大小的接口
    • 1. Comparable -> compareTo
      • 1.1 sort排序
        • 1.1.1 Compara接口实现后,可以用sort之间排序
        • 1.1.2 排序前后可用用 toString 输出数组
        • 1.1.3 sort排序规则
    • 2. 比较器 Comparator -> compare
      • 补充:String自带compareTo 用于字符串比较

1. 接口的要求
  1. 接口中不能包含普通方法, 子类必须重写所有的抽象方法
  2. 接口的成员都是默认public static final的 所以必须初始化
  3. 接口中的方法都是默认抽象方法public abstract。并且不能有具体实现
  4. 如果有具体实现,必须加上default修饰方法(此方法就不是抽象方法了)(默认还有public)default + 方法名
  5. 静态的方法,也可以实现(public) static + 方法名
  6. 接口中不能有静态,实例代码块,构造方法
  7. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract(只能是public abstract,其他修饰符都会报错)
public interface USB { 
    // Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice(); 
    void closeDevice(); 
}
  1. 重写接口中方法时,不能使用default访问权限修饰
public interface USB {
    void openDevice();
    // 默认是public的 void closeDevice();
    // 默认是public的 }
    public class Mouse implements USB {
        @Override
    void openDevice() {
            System.out.println("打开鼠标");
        }
        // ...
    }
    // 编译报错,重写USB中openDevice方法时,不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
2. 接口的定义 interface

3. 接口使用
public class 类名称 implements 接口名称{

}
4. 接口的例子 画图接口
//接口
interface IShape {
    void draw();
    default void func() {
        System.out.println("faa");
    }
}
//用类继承接口
class Rect implements IShape {
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }

    @Override
    public void func() {
        System.out.println("重写了func");
    }
}
//用类继承接口
class Flower implements IShape {
    @Override
    public void draw() {
        System.out.println("画一朵花!");
    }
}
class Test {
    //用接口接收类,实现接口的作用
    public static void drawMap(IShape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        //向上转型,实现接口的作用——把类 传给 接口
        drawMap(new Flower());
        drawMap(new Rect());

    }
}
usb接口使用
//usb接口
public interface USB {
    void openDevice();
    void closeDevice();
}

// 鼠标类,实现USB接口(并且实现自己的功能)
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("鼠标点击");
    }
}

// 键盘类,实现USB接口(并且同时实现自己的功能)
public class KeyBoard implements USB {
    @Override
public void openDevice() {
        System.out.println("打开键盘");
    }
    @Override
public void closeDevice() {
        System.out.println("关闭键盘");
    }
    public void inPut(){
        System.out.println("键盘输入");
    }
}

// 笔记本类:使用USB设备
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 是 Java 的保留关键字,它的
        //作用是测试它左边的对象是否是它右边的类的
        //实例,返回 boolean 的数据类型

//之后我再直接调用 mouse类(通过usb接口调用)
            Mouse mouse = (Mouse)usb;
        mouse.click();
        }else if(usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }
}

// 测试类:
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(); 
    } 
}
5. 多接口的继承
  1. 主对象的创建
  2. 多接口的创建
  3. 一个对象既继承主对象(记得构造)然后实现多个接口(在对象里,把每个接口都重写)
  4. 在测试类中,把每个接口都在函数中用接口接收并且都使用
  5. 如果使用接口的话,1.直接创建一个类 2.调用接口函数(传入的值,应该是具体对象,这一过程也是向上转型)
abstract class Animal {
    public String name;
    public int age;
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public abstract void eat();
    //跑  游泳 .....
}
interface IRunning {
    void run();
}
interface IFlying {
    void fly();
}
interface ISwimming {
    void swim();
}
// 叫 跑  游泳
class Dog extends Animal implements IRunning,ISwimming {

    public Dog(String name,int age) {
        super(name,age);
    }

    @Override
    public void eat() {
        System.out.println(name +" 正在吃狗粮!");
    }

    @Override
    public void run() {
        System.out.println(name + " 正在四条腿跑!");
    }

    @Override
    public void swim() {
        System.out.println(name + " 正在四条腿狗刨!");
    }
}
//叫 跑 飞
class Bird extends Animal implements IRunning,IFlying {
    public Bird(String name,int age) {
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println(name +" 正在吃鸟粮!");
    }

    @Override
    public void run() {
        System.out.println(name+" 正在用两条细细的腿在跳着跑!");
    }

    @Override
    public void fly() {
        System.out.println(name +" 正在用两个翅膀飞!");
    }
}
class Duck extends Animal implements IFlying,IRunning,ISwimming {

    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name +"正在吃鸭粮!");
    }

    @Override
    public void run() {
        System.out.println(name +"正在用大脚掌跑!");
    }

    @Override
    public void fly() {
        System.out.println(name +"正在用大翅膀飞!");
    }

    @Override
    public void swim() {
        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 main(String[] args) {
        walk(new Robot());
    }

    public static void fly(IFlying iFlying) {
        iFlying.fly();
    }

    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }

    public static void main5(String[] args) {
        swim(new Dog("狗子",10));
        swim(new Duck("唐老鸭",3));
    }

    public static void main3(String[] args) {
        fly(new Bird("小鸟",3));
        fly(new Duck("唐老鸭",3));
    }



    public static void main2(String[] args) {
        walk(new Dog("狗子",10));
        walk(new Bird("小鸟",3));
        walk(new Duck("唐老鸭",3));
    }


    public static void func1(Animal animal) {
        animal.eat();
    }

    public static void main1(String[] args) {
        func1(new Dog("狗子",10));
        func1(new Bird("小鸟",3));
        func1(new Duck("唐老鸭",3));
    }
}
6. 接口的扩展
interface IA {
    void funcA();
}
interface IB {
    void funcB();
}
//扩展功能
interface IC extends IA,IB {
    void funcC();
}
class T implements IC {

    @Override
    public void funcA() {

    }

    @Override
    public void funcB() {

    }

    @Override
    public void funcC() {

    }
}
7. 比较大小的接口 1. Comparable -> compareTo

这个是在类里面定义比较函数,要比较的时候,调用的是比较函数,但是这个就会限制比较的条件,所以比较器更方便一点

1.1 sort排序 1.1.1 Compara接口实现后,可以用sort之间排序 1.1.2 排序前后可用用 toString 输出数组

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

    public Student(String name, int age, double 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) {
        return this.age-o.age;
    }
}


public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("bit",10,78.9);
        students[1] =  new Student("abc",4,98.9);
        students[2] =  new Student("gb",14,38.9);
        System.out.println("排序前"+Arrays.toString(students));
        sort(students);
        System.out.println("排序后"+Arrays.toString(students));
    }
}
1.1.3 sort排序规则

前 - 后 是从小到大
后 - 前 是从大到小

2. 比较器 Comparator -> compare
//比较器
class AgeComparator implements Comparator {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}

class ScoreComparator implements Comparator {
    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score-o2.score);
    }
}

class NameComparator implements Comparator {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

    public static void main8(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("bit",10,78.9);
        students[1] =  new Student("abc",4,98.9);
        students[2] =  new Student("gb",14,38.9);
        System.out.println("排序前"+Arrays.toString(students));

        AgeComparator ageComparator = new AgeComparator();
        ScoreComparator scoreComparator = new ScoreComparator();
        NameComparator nameComparator = new NameComparator();

        Arrays.sort(students,nameComparator);

        System.out.println("排序后"+Arrays.toString(students));
    }

补充:String自带compareTo 用于字符串比较
class NameComparator implements Comparator {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/979244.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号