接口知识点

定义:接口其实就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用.在Java中,接口可以看成是:多个类的公共规范,是一种引用数据类型.可以算抽象类的进一步抽象

1.接口是试用interface来进行定义的

2.接口当中不能有实现的方法,但是有两种类型的方法需要注意

    2.1 静态方法可以有具体的实现

    2.2 这个方法如果被default关键字修饰,也是可以的

interface IShape{
    public abstract void draw();
    public void draw2();
    default public void draw3(){
        System.out.println("lalala");
    }
    public static void draw4(){
        System.out.println("hahaha");
    }
}

3.接口当中的方法默认是public abstract 修饰的(可以省略不写)

4.接口当中的成员变量默认是public static final修饰的(可以省略不写)

5.接口也不能通过new关键字来进行实例化

6.类和接口之间使用关键字implements来进行关联

7.当一个类实现一个接口之后,这个类必须重写这个接口中的抽象方法

8.当接口中存在default方法,可以选择重写,也可以不重写,具体看业务需求

interface IShape{
    void draw();

    default public void draw3(){
        System.out.println("lalala");
    }
    public static void draw4(){
        System.out.println("hahaha");
    }
}

class Flower implements IShape{
    public void draw(){
        System.out.println("❀");
    }
    public void draw4(){
        System.out.println("我觉得父接口的这个默认方法不好,我自己写");
    }
}

9.不管是接口还是抽象类,他们仍然是可以发生向上转型的

接口实现多态

interface IShape{
    void draw();

    default public void draw3(){
        System.out.println("lalala");
    }
    public static void draw4(){
        System.out.println("hahaha");
    }
}

class Flower implements IShape{
    public void draw(){
        System.out.println("❀");
    }
    public void draw4(){
        System.out.println("我觉得父接口的这个默认方法不好,我自己写");
    }
}
class Rect implements IShape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}

public class testdemo {
    public static void drawMap(IShape shape)
    {
        shape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Flower());
        drawMap(new Rect());

    }
}

多数时候,一个类\一个接口就是一个Java文件

10.子类实现接口的方法的时候,这个方法一定要是public修饰的

11.接口中不能有构造方法和代码块

12.一个类不想实现接口当中的方法,这个类可以被定义为抽象类

一个类实现多个接口可以解决多继承的问题

interface IFlying{
    void fly();
}
interface ISwimming{
    void swim();
}
interface IRunning{
    void run();
}
abstract class Animal{
    public String name;
    public int age;
    public abstract void eat();
}
class Dog extends Animal implements IRunning,ISwimming{//一定是先继承,后接口
    @Override
    public void eat() {
        System.out.println(this.name+"正在吃狗粮");
    }

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

    @Override
    public void swim() {
        System.out.println(this.name+"正在狗刨");
    }
}

问:为什么不直接把三个接口中的方法都写在Animal这个类中呢?

答:不是所有动物都会飞

问:这些接口都写成类行不行?

答:不行,因为Java是单继承

所以我们才说接口的出现可以解决Java当中多继承的问题

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

interface A{
    void testA();
}
interface B{
    void testB();
}
interface C extends A,B{
    void testC();
}
class D implements C{

    @Override
    public void testA() {

    }

    @Override
    public void testB() {

    }

    @Override
    public void testC() {

    }
}

抽象类和接口的区别:

1.接口当中的方法只能是抽象方法,成员变量只能是public static final

抽象类的成员变量可以是变量,也可以是常量

2.接口的成员方法默认修饰符public abstract

抽象类的成员方法可以是抽象的,也可以是非抽象的

3.接口没有构造方法

抽象类有构造方法,用于子类实例化使用

4.一个子类可以实现多个接口

一个子类只能继承一个抽象类

5.接口不能继承抽象类,但是接口可以使用extends关键字继承多个父接口

一个抽象类可以实现若干接口

一个接口的案例
 

interface IFlying{
    void fly();
}
interface ISwimming{
    void swim();
}
interface IRunning{
    void run();
}
abstract class Animal{
    private String name;
    private int age;
    public Animal(String name,int age){
        this.age=age;
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}
class Dog extends Animal implements IRunning,ISwimming{
    public Dog(String name, int age) {
        super(name, age);
    }//一定是先继承,后接口
    @Override
    public void eat() {
        System.out.println(this.getName()+"正在吃狗粮");
    }

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

    @Override
    public void swim() {
        System.out.println(this.getName()+"正在狗刨");
    }
}
class Robot implements ISwimming{
    @Override
    public void swim() {
        System.out.println("机器人在游泳");
    }
}
public class test1 {
    public static void test1(Animal animal){
        animal.eat();
    }
    public static void testFly(IFlying iFlying){//只要实现了这个接口就都能接收
        iFlying.fly();
    }
    public static void testRun(IRunning iRunning){//只要实现了这个接口就都能接收
        iRunning.run();
    }
    public static void testSwim(ISwimming iSwimming){//只要实现了这个接口就都能接收
        iSwimming.swim();
    }

    public static void main(String[] args) {
        test1(new Dog("大黄",5));//多态
        testRun(new Dog("小白",3));
        testSwim(new Dog("大旺",6));
        testSwim(new Robot());//接口存在的最大意义

    }
}