🐷1.接口的概念
🐱🚀2.接口的语法规则
💚3.接口的使用
🚀4.接口的特性
🎆5.实现多个接口
🐶6.接口间的继承
🎊7.接口使用的实例
1.什么是接口呢？？？
接口放在现实生活中来说呢，就是手机啊。电脑的插座之类的，我们会发现那些插座几乎大家的充电口都能用，那么这就是一种标准
在
Java
中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
也就是对抽象类的的进一步抽象
接口的语法规则
接口用interface来修饰
创建接口时, 接口的命名一般以大写字母 I 开头.
接口的命名一般使用 "形容词" 词性的单词
.
接口不能直接实例化，会报错
interface IShape{
public abstract void draw();
public static final String name="一宝";
default public void func(){
System.out.println("默认的");
}
}
class Rect implements IShape{
@Override
public void draw() {
System.out.println("🟥");
}
}
class Circle implements IShape{
@Override
public void draw() {
System.out.println("○");
}
}
class Heart implements IShape{
@Override
public void draw() {
System.out.println(";❤");
}
}
public class Test {
public static void main(String[] args) {
IShape shape = new Rect();
IShape shape2 = new Circle();
IShape shape3 = new Heart();
shape.draw();
shape.func();
shape2.draw();
shape2.func();
shape3.draw();
shape3.func();
}
}
这个代码的结果是什么呢，shape.func()可以被调用吗？？？
对于shape.func（）可以这样理解，调用shape.draw()发生动态绑定，就到那个Rect重写的draw方法去了，但是调用shape.fun（）就到接口中去了，因为func本身也是一个抽象方法，因为有了default的修饰，所以可以不在子类中重写，通过接口的引用，就直接到IShape当中去调了
下面实现电脑USB接口
package demo2;
/**
* Created with IntelliJ IDEA.
* Description:
* User: WHY
* Date: 2022-11-16
* Time: 10:52
*/
interface IUSB{
void openDevice();
void closeDevice();
}
class KeyBoard implements IUSB {
@Override
public void openDevice() {
System.out.println("打开键盘");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘");
}
public void intput(){
System.out.println("敲击键盘");
}
}
class Mouse implements IUSB{
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("点击鼠标");
}
}
class Computer{
public void open(){
System.out.println("开机");
}
public void close(){
System.out.println("关机");
}
public void useDevice(IUSB usb){//判断一下是不是所有的USB接口都可以被使用
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse=(Mouse)usb;//向下转型
mouse.click();//执行子类中特有的方法
}else if(usb instanceof KeyBoard){
KeyBoard keyBoard=(KeyBoard)usb;
keyBoard.intput();
}
usb.closeDevice();
}
}
public class Test {
public static void main(String[] args) {
Computer computer=new Computer();
IUSB iusb=new KeyBoard();//向上转型
computer.useDevice(iusb);
IUSB iusb1=new Mouse();
computer.useDevice(iusb1);
}
}
package demo3;
/**
* Created with IntelliJ IDEA.
* Description:
* User: WHY
* Date: 2022-11-16
* Time: 13:48
*/
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 Duck extends Animal implements IFly,IRunning,ISwimming{
public Duck(String name) {
super(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 ISwimming{
public String name;
public robot(String name) {
this.name = name;
}
@Override
public void swim() {
System.out.println(name+"机器人在游泳");
}
}
public class TestDemo {
public static void walk(IRunning iRunning){
iRunning.run();
}
public static void swim(ISwimming iSwimming){
iSwimming.swim();
}
public static void main(String[] args) {
walk(new Dog("贝贝"));
walk(new Duck("丫丫"));
swim(new Duck("丫丫1"));
swim(new robot("小冰"));
}
}
从这两段代码可以看出，只要这个类继承了这个接口，就可以实现
package demo4;
/**
* Created with IntelliJ IDEA.
* Description:
* User: WHY
* Date: 2022-11-16
* Time: 14:14
*/
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 +
'}';
}
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 sort(Comparable[] array) {
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
/*if(array[j] > array[j+1]) {
交换；
}*/
if(array[j].compareTo(array[j+1]) > 0) {
Comparable tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
}
}
}
}
public static void main(String[] args) {
Student[] students=new Student[3];
students[0]=new Student("wangyibo",25,100);
students[1]=new Student("weihongyan",19,99);
students[2]=new Student("gaoyan",19,95);
System.out.println(students[0].compareTo(students[1]));
}
}
这个是调用sort函数实现排序
这个是调用compareTo方法实现的
当比较字符串是否相等用equals方法，当比较大小也要用compareT方法，要是想从大到小排，换个return 就好
下面来总结一下接口的知识点
使用interface 接口来定义接口
接口不能被实例化
接口中的方法默认是public abstract 修饰的
接口中的成员默认是public static final 修饰的
接口当中的方法，不能有具体实现，但是从jdk8开始，可以写一个default来修饰，我已经子啊前面的代码展示并解释了
接口当中不能有构造方法
接口需要被类实现，使用关键字implements
接口中可以有static修饰的方法
接口和接口之间使用关键字extends继承，与类的单继承不一样啊，类可以同时继承多个接口，接口和接口之间也可以多继承
interface A {
void funcA();
}
interface B {
void funcB();
}
//CC这个接口 不仅仅具备func这个功能，还具备了A和B接口的功能
interface CC extends A,B {
void funcC();
}
class C implements CC {
public void funcA() {
}
public void funcB() {
}
public void funcC() {
}
}
public class Test2 {
}就像这个，一个接口也可以同时继承多个接口，并拥有被继承接口的功能
类继承另一个类同时实现多个接口，代码也有体现到
今天的内容就到此结束，我们下期再见，886！！！
💚💚💚💚💚💚💚💚💚💚
![[附源码]计算机毕业设计JAVA房屋租赁管理系统](https://img-blog.csdnimg.cn/31dc35b8dea64614a8f2c16c4fe14b59.png)
