- 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. 接口的要求
- 接口中不能包含普通方法, 子类必须重写所有的抽象方法
- 接口的成员都是默认public static final的 所以必须初始化
- 接口中的方法都是默认抽象方法public abstract。并且不能有具体实现
- 如果有具体实现,必须加上default修饰方法(此方法就不是抽象方法了)(默认还有public)default + 方法名
- 静态的方法,也可以实现(public) static + 方法名
- 接口中不能有静态,实例代码块,构造方法
- 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract(只能是public abstract,其他修饰符都会报错)
public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}
- 重写接口中方法时,不能使用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.调用接口函数(传入的值,应该是具体对象,这一过程也是向上转型)
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 Comparable1.1.3 sort排序规则{ 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)); } }
2. 比较器 Comparator -> compare前 - 后 是从小到大
后 - 前 是从大到小
//比较器 class AgeComparator implements Comparator补充:String自带compareTo 用于字符串比较{ @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)); }
class NameComparator implements Comparator{ @Override public int compare(Student o1, Student o2) { return o1.name.compareTo(o2.name); } }



