java—接口

标签：java name age 接口 public 方法 void

接口：是一种规则，是对行为的抽象。

接口的定义和使用

接口用关键字interface来定义

public interface 接口名{}

接口不能实例化

接口和类之间是实现关系，通过implements关键字表示

public class 类名 implements 接口名{}

接口的子类（实现类）

要么重写接口中的所有抽象方法

要么是抽象类

注意1：接口和类的实现关系，可以单实现，也可以多实现。

public class类名implements接口名1，接口名2}

注意2：实现类还可以在继承一个类的同时实现多个接口。

public class类名extends父类implements接口名1，接口名2}

代码案例：

public abstract class dongwu {
    private String name;
    private int age;
    public dongwu(){

    }
    public dongwu(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public abstract void eat();

}

class tuzi extends dongwu{
    public tuzi() {
    }

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

    @Override
    public void eat() {
        System.out.println("兔子在吃胡罗卜");
    }
}

class qingwa extends dongwu implements swim{
    public qingwa() {
    }

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

    @Override
    public void eat() {
        System.out.println("青蛙再吃虫子");

    }

    @Override
    public void swim() {

    }
}
class dog extends dongwu implements swim{
    public dog() {
    }
    public dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");

    }
    @Override
    public void swim() {
    }
}

public interface swim {
        public void swim();

}

public class text {
    public static void main(String[] args) {
        qingwa qw = new qingwa("小青",1);
        System.out.println(qw.getName()+","+qw.getAge());
        qw.eat();
        qw.swim();
        tuzi tz = new tuzi("兔子",1);
        System.out.println(tz.getName()+","+tz.getAge());
        tz.eat();
    }
}

接口中成员的特点：

成员变量

只能是常量

默认修饰符：public static final

构造方法

没有

成员方法

只能是抽象方法

默认修饰符：public abstract

接口和类之间的关系

类和类的关系

继承关系，只能单继承，不能多继承，但是可以多层继承

类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的关系

继承关系，可以单继承，也可以多继承

JDK8以后接口中新增的方法

●JDK8的新特性：接口中可以定义有方法体的方法。（默认，静态）

●允许在接口中定义默认方法，需要使用关键字default修饰

作用：解决接口升级的问题

接口中默认方法的定义格式：

●格式：public default返回值类型方法名（参数列表）{}

范例：public default void show（）{}

接口中默认方法的注意事项：

●默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字

●public可以省略，default不能省略

●如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

public interface inter {
    public abstract(可以省略) void method1();   接口中的抽象方法
    public default void show(){
        System.out.println("接口中的默认方法可以重写");
    }
}

●允许在接口中定义定义静态方法，需要用static修饰

接口中静态方法的定义格式：

格式：public static返回值类型方法名（参数列表）{}

范例：public static void show(）{}

接口中静态方法的注意事项：

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

public可以省略，

static不能省略

public interface inter {

public abstract(可以省略) void method1(); 接口中的抽象方法

public static void show(){ 注：静态方法不允许被重写

System.out.println(" hellow");

}

调用接口中的静态放法：接口名.方法名（）；

接口中私有方法的定义格式：

格式1:private返回值类型方法名（参数列表）{}

范例1:private void show（）{}

格式2:private static返回值类型方法名（参数列表）{}

范例2:private static void method（）{}

静态只能访问静态。

1.接口代表规则，是行为的抽象。想要让哪个类拥有一

个行为，就让这个类实现对应的接口就可以了。

2.当一个方法的参数是接口时，可以传递接口所有实现

类的对象，这种方式称之为接口多态

适配器设计模式

1.当一个接口中抽象方法过多，但是我只要使用其中一部分的

时候，就可以适配器设计模式

2.书写步骤：

编写中间类XXXAdapter,实现对应的接口

对接口中的抽象方法进行空实现

让真正的实现类继承中间类，并重写需要用的方法

为了避免其他类创建适配器类的对象，中间的适配器类

用abstract进行修饰

标签：java,name,age,接口,public,方法,void
From： https://blog.csdn.net/2302_80073130/article/details/145242039