java接口

接口

1.接口的概念

 

接口：是一种标准，接口的实现者和使用者都必须遵循的约定。

从语法角度来讲，接口相当于一个特殊的抽象类。具体特殊在哪？

2.接口的基本语法：

关键字：interface

所有的属性都是公开、静态、常量 public static final

所有的方法都是公开、抽象方法 public abstract

没有构造方法，不能参与创建对象的过程，可以声明引用

package com.baidu.test;
/**接口:主要作用,规定能做什么,不管怎么做
 * 不会使用接口,没有办法写项目
 * */
public interface Usb {
    //Modifier 'private' not allowed here  所有的属性都是public的
    //private int age;
    //Variable 'age' might not have been initialized属性必须有初始值
    int age=9;//可以省略修饰符
    //默认所有的属性都由以下修饰符   所有属性都是公开的静态常量
    public static final int ages=10;
    //接口没有构造方法
    //public Usb(){}
    //Interface abstract methods cannot have body
    //public void a(){}//不能有普通方法
    //所有的方法都是抽象方法  public abstract可以省略
    /**开始*/
    public abstract void star();
    /**结束*/
    void end();
}

​

3.接口和抽象类的区别

相同点： 编译生成字节码文件(.class) 不能创建对象，可以声明引用

不同点： 接口中没有构造方法 接口中所有的方法都是公开、抽象方法，默认public、abstract修饰 接口中所有的属性都是公开、静态、常量，默认public static final 修饰

4.接口的实现类

接口中的所有方法只有声明部分，不涉及到具体的实现，只是制定标准； 实现者需要遵循此标准，给出具体的方法实现，那么如何定义实现类？

实现类： 语法：class 类名 implements 接口名{}

注意： 实现类实现接口，必须实现接口中所有方法，否则实现类也必须定义为抽象类 实现类实现接口中的方法时，访问修饰符必须为public

使用：父接口名 引用名 = new 实现类类名(实参); //多态的使用

package com.baidu.test;
/**U盘:
 * 接口Usb的实现类
 * */
public class Udisk implements Usb{
    //实现类必须重写接口所有的方法
    @Override
    public void star() {
        System.out.println("U盘已插入!");
    }
​
    @Override
    public void end() {
        System.out.println("拔出U盘!");
    }
​
    public static void main(String[] args) {
        Usb usb=new Udisk();
        usb.star();
        usb.end();
    }
}

​

package com.baidu.test;
/**防盗门*/
public class LockDoor implements Door,Lock{
//implements Door,Lock接口可以多实现,同时实现多个接口
    @Override
    public void openDoor() {
        System.out.println("开门");
    }
​
    @Override
    public void closeDoor() {
        System.out.println("关门");
    }
​
    @Override
    public void openLock() {
        System.out.println("开锁");
    }
​
    @Override
    public void closeLock() {
        System.out.println("上锁");
    }
​
    public static void main(String[] args) {
        LockDoor ld=new LockDoor();
        ld.openLock();
        ld.openDoor();
        ld.closeDoor();
        ld.closeLock();
    }
}

​

5.接口的继承关系

接口与接口之间是多继承关系：

interface 接口名 extends 父接口名1,父接口名2{} 类同时可以实现多个接口：类与接口之间是多实现的关系： class 类名 implements 接口名1,接口名2{} 注意：如果实现类不想成为抽象类，需要实现所有接口中所有方法，而且方法 访问修饰符为public 类继承一个父类，同时还可以实现多个父接口: class 类名 extends 父类名 implements 父接口1,父接口2{} 注意：必须是先继承后实现。

接口多继承性：使多态的应用更加的复杂

 

接口多继承的影响

 

package com.baidu.test;
/**动物*/
public class Animail {
    private String name;
    private int age;
    public Animail(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
}
​
package com.baidu.test;
/**跑*/
public interface Runs {
    void runs();
}
package com.baidu.test;
/**游泳*/
public interface Swimming {
    void  swim();
}
package com.baidu.test;
/**猫*/
public class Cat extends Animail implements Runs{
    public Cat(String name, int age,String color) {
        super(name, age);
        this.color=color;
    }
    private String color;
​
    @Override
    public void runs() {
        System.out.println("猫会跑");
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}
package com.baidu.test;
/**狗*/
public class Dog extends Animail implements Runs,Swimming{
    private String strans;
​
    public Dog(String name, int age, String strans) {
        super(name, age);
        this.strans = strans;
    }
​
    public String getStrans() {
        return strans;
    }
​
    public void setStrans(String strans) {
        this.strans = strans;
    }
​
    @Override
    public void runs() {
        System.out.println("狗再跑");
    }
​
    @Override
    public void swim() {
        System.out.println("狗在游泳");
    }
}
package com.baidu.test;
/**鱼*/
public class Fish extends Animail implements Swimming{
    private double width;
​
    public Fish(String name, int age, double width) {
        super(name, age);
        this.width = width;
    }
​
    @Override
    public void swim() {
        System.out.println("鱼在游泳");
    }
​
    public double getWidth() {
        return width;
    }
​
    public void setWidth(double width) {
        this.width = width;
    }
}
​

​

引用类型转换双方有一方为接口类型，则编译一定通过；运行结果如下两种情况： 如果引用中存储的实际对象类型和要转换的类型相匹配，则运行通过； 如果引用中存储的实际对象类型和要转换的类型不匹配，则运行报错，错误信息如下java.lang.ClassCastException（类型转换异常）

 

6.接口回调

 

 

 

 

 

 

7.JDK高版本接口语法补充

JDK8.0开始 ，接口中可以定义默认方法和静态方法。

默认方法：

default 返回值类型 方法名(形参列表){ // 方法实现 }

注意：带有方法实现的非静态方法必须加default

静态方法：

public static 返回值类型 方法名(形参列表)｛ //方法实现 ｝

注意：静态方法没有写访问修饰，默认为public

JDK9.0开始，接口中可以定义私有方法。

private 返回值类型 方法名(形参列表){ //方法实现 }

package com.baidu.test;

public interface Dome01 {
	default void a(){
		System.out.println("默认方法");
	}
	private static void b(){
		System.out.println("静态方法");
	}
}

​

8.接口的分类

常量接口：

接口中只有静态常量，没有定义任何方法，应用不广泛

标记接口：

空接口，接口中没有定义任何的属性和方法。

普通接口：

具有至少一个抽象方法的接口。

函数式接口：

接口中只有一个抽象方法，对静态方法和默认 方法没有要求。

可以用在lambda表达式中

接口和抽象类的区别小结

** **	抽象类	接口
关键字不同	abstract class	interface
extends(类继承抽象类)	implements(类实现接口)
属性和方法	实例变量静态变量4个访问修饰符可以用于修饰属性	公开静态常量
方法	抽象方法普通的成员方法	抽象方法静态方法(jdk8.0)默认方法，带方法实现 私有方法(jdk9.0)
构造方法	有构造方法	没有构造方法
继承关系	单继承	多继承