Java学习之接口_interface b extends a{ abstract void b();

可爱的小北又回来啦！喵~~~

今天我们要讲的是java面向对象的接口

当然第一步是思维导图咯：

【1】什么是接口呢？

       

       在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

【2】接口有什么特点呢？

接口特点：A：接口用关键字interface表示              格式：interface 接口名 { }

                  B：类实现接口用implements表示          格式：class 类名 implements 接口名 {  }

                  C：接口不能用于实例化对象

                                             那接口如何实例化呢？ 按照多态的方式实例化

                   D：接口的子类：1)可以是抽象类。但是意义不大

                                               2)可以是具体类。要重写接口中的所有抽象方法。（推荐）

小北来给大家上个例子，我们来初识接口：

以下是三个接口：

public interface BB{
 
    void bb();
 
 
}

public interface CC {
 
   public void cc();
 
 
}

public interface DD{
 
    public void dd();
 
}

以下是MyDemo类，实现BB,CC,DD接口

//一个类可以实现多个接口
public void MyDemo implements BB,CC,DD{
 
    @Overrride
    public void bb()  { }
 
    @Override
    public void cc()  { }
 
    @Override
    public void dd()  { }
 
 
 
}

以上就是一个很简单的接口实现。

小北认为呢，前两个特点接口用关键字interface表示和类实现接口用implement表示大家应该通过这个例子有所感触了

下面小北再给大家举个例子，以便于大家更深的理解

这是一个MyInterface接口

public interface MyInterface{
 
    int NUM=100;
    public static final double D=100;
    //接口中成员变量前面的默认修饰符：public static final 
    
    //接口中所有的方法都是抽象方法，无非抽象方法
    //方法前面默认有修饰符public abstract 
    //接口中无构造方法
    //接口不能创建对象
    //接口的子类可以是抽象类
    //接口与接口之间可以继承，可以多继承
 
    public abstract void fire();
 
    void hehe();
} 

这是一个抽象类Animal

public abstract class Animal{
 
    public abstract void eat();
    public abstract void sleep();
 
 
}

抽象类Animal的子类，也是MyInterface类的接口实现

public class Dog extends Animal implement MyInterface{
 
 
    @Override
    public void eat(){
    
    }
 
    @Override
    public void sleep(){
 
    }
 
    @Override
    public void fire()  {System.out.println("狗经过学习，会钻火圈了");}
 
    @Override
    public void hehe()  {System.out.println("呵呵");}
 
 
 
}

public class Cat extends Animal{
 
    @Override
    public void eat(){
 
    }
 
    @Override
    public void sleep(){
 
    }
}

Test测试类：

public class Test {
    public static void main(String[] args) {
        //接口不能实例化
        MyInterface my = new Dog(); //多态的形式
        my.fire();
    }
}

最后经过多态的形式，这样就能实现接口的实例化啦

【3】接口成员的特点：

A:成员变量：只能是常量，并且是静态的-------->默认修饰符：public static final

B:构造方法：接口没有构造方法

C:成员方法：只能是抽象方法------------->默认修饰符：public abstract

例子呢上面第一个小北已经给大家给出啦。

【4】关系

A：类与类：继承关系，并且只能单继承，可以多层继承

B：类与接口：实现关系，可以单实现，也可以多实现，并且可以在继承一个类的时候同时实现多个接口

C：接口与接口：继承关系，可以单继承也可以多继承

例子相关的概念上面也都有包括

【5】抽象类和接口的区别

A：成员区别

抽象类：成员变量：可以变量，也可以常量

              构造方法：有

              成员方法：可以抽象，也可以非抽象

接口：   成员变量：只可以常量

             成员方法：只可以抽象

B：关系区别

类与类：继承，单继承

类与接口：实现，单实现，多实现

接口与接口：继承，单继承，多继承

C：设计理念区别

抽象类：被继承体现的是：“is a ”的关系     抽象类中定义的是该继承体系的共性功能

接口：    被实现体现的是：“like a”的关系    接口中定义的是该继承体系的扩展功能

接下来就是今天接口的最后一个实例啦。

首先这是一个接口A

public interface A{
 
 
    void a();
 
}

这是接口A的继承接口B（实现接口与接口的继承）

public interface B extends A{
    void b();
}

这是一个接口AA

public interface AA{
 
    void aa();
 
}

同理

public interface C extends B,AA{
 
    void c();
}

接口C的实现

public class MyCat implement C{
 
    @Override
    public void c(){
 
    }
 
    @Override
    public void b(){
 
    }
 
    @Override
    public void a(){
 
    }
 
     @Override
     public void aa() {
 
    }
 
}

好啦，今天的接口部分就到这里啦！喵喵喵~~~~