接口(interface)

接口【不允许出现普通的成员方法，没有构造方法】

概述

  • 接口，是java语言中的一种引用类型，是【方法的集合】，如果说类的内部封装了成员变量，构造方法和成员方法，那么接口的内部主要就是【封装了方法】，包含了抽象方法【JDK1.7及以前】，默认方法和静态的方法【JDK.18】，私有方法【JDK1.9】
  • 接口的定义和类很相似，不在使用class关键字进行声明，而是用interface关键字进行声明
    定义格式
    public interface 接口名称{
	//接口内容
	//抽象方法为主
}
//接口就是多个类的公共规范。接口也是一种引用数据类型。如，类，数组，接口。
//备注：源文件还是.java，编译之后生成的字节码文件还是.class   .java~~~~.class
//JDK1.7那么接口中包含的内容
  //1.静态常量 public static final
  //2.抽象方法 public abstract 
//JDK1.8
  //3.默认方法 default 返回值类型 method(){}  
  //4.静态方法 public 返回值类型 method(){}
//JDK1.9
  //5.私有方法 private 返回值类型 moethod(){}

接口的使用步骤

  1. 接口是不能直接使用的，必须有一个“实现类”(普通类)来“实现”该接口。
    使用格式
    public class 实现类名称 implements 接口名称{
  //类的成员信息
}
  2. 接口的实现类必须重写（实现）接口中的所有方法。
    实现：去掉abstract关键字，分号换成大括号。
  3. 创建实现类的对象，进行使用。

tips
注意事项
如果实现类当中没有重写接口当中的所有的抽象方法，那么这个实现类自己必须是一个抽象类

接口中的方法

  1. 抽象方法：使用abstract关键字修饰，没有方法体内容，该方法内容主要是供子类使用的

    public interface InterfaceName{
	public abstract void method(){
		//public abstract 可以省略不写
	}
}

  2. 默认方法和静态方法
    默认方法：使用default关键字修饰的方法，不可省略，供子类调用或者子类重写。
    静态方法：使用static关键字修饰的方法，共接口直接调用。

  3. 含有的私有方法和私有静态的方法
    私有方法：使用private关键字，提供接口中的默认方法或者静态方法调用。

    public interface InterfaceName{
	private void moethod(){
		//方法体内容
	}
}

基本的实现

  • 实现的概述
    类于接口的关系，为实现关系。即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似于继承，格式相仿，只是关键字不同，实现使用【implements】关键字

  • 非抽象类实现接口：

    1. 必须重写接口当中的所有的抽象方法
    2. 继承了接口当中的默认方法，即可以直接调用，也可以重写。
    //格式
public class 实现类 implements 接口名称{
	//重写接口当中的所有的抽象方法
	//重写接口当中的默认方法【可选】
}

  • 抽象方法的使用
    必须全部实现

    //定义一个接口
public interface Biological{//生物
	//定义一个吃东西的功能
	public abstract void eat();
	//定义一个休息的功能
	public abstract void sleep();
}
//定义一个实现类
public class Animal implements Biological{
	//重写接口中的方法
	@Override
	public void eat(){
		Systen.out.println("吃东西");
	}
	@Override
	public void sleep(){
		Systen.out.println("睡觉");
	}
}
public class Text{
	public static void main(String[] args){
		Animal a=new Animal();
		a.eat();//吃东西
		a.sleep();//睡觉
	}
}

  • 默认方法的使用
    可以继承，可以重写，二选一，但是只能通过实现类的对象来调用

    1. 继承默认方法
    //定义接口类 
public interface Biological{//生物
	public default void fly(){
		System.out.println("天上飞");
	}
}
//定义实现类
public class Animal implements Biological{
	//继承 什么也不写，直接调用
}
public class Text{
	public static void main(String[] args){
		//创建子类对象
		Animal a=new Animal();
		//调用默认方法
		a.fly();//天上飞
	}
}
    1. 重写默认的方法
    //定义接口类 
public interface Biological{//生物
	public default void fly(){
		System.out.println("天上飞");
	}
}
//定义实现类
public class Animal implements Biological{
	@Oberride
	public void fly(){
		System.out.println("自由自在的飞");
	}
}
public class Text{
	public static void main(String[] args){
		//创建子类对象
		Animal a=new Animal();
		//使用子类的方法
		a.fly();//自由自在的飞
	}
}

  • 静态方法的使用
    静态的一般都是和类.class文件相关，【只能】使用【接口名】来调用，不可以通过实现类的类名或者实现类的对象来调用

    //定义接口类 
public interface Biological{//生物
	public static void run(){
		System.out.println("跑跑");
	}
}
//定义实现类
public class Animal implements Biological{
	//无法重写静态方法
}
public class Text{
	public static void main(String[] args){
		//Animal.run();//错误的操作，无法继承，也无法调用        
		Biological.run();//跑跑
	}
}

  • 私有方法的使用
    私有方法：只有默认方法可以调用
    私有的静态方法：默认方法和静态方法都可以调用
    如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度考虑，私有的方法是对默认的方法和静态的方法的一种辅助，

    //定义接口类 
public interface Biological{//生物     
	private static void run(){         
		System.out.println("跑起来，跑起来");     
	} 
	public default void funMethod(){
		run();
	}
}

接口的多实现

  • 在继承体系中，一个类只能直接继承一个父类，而对于接口来说，一个类可以实现多个接口，这叫接口的【多实现】。并且，一个类能直接继承一个父类同时还可以实现多个接口。一个接口可以继承多个接口。

    public class Zi extends Fu implements 接口1,接口2，...{
	//重写接口中的所有抽象方法
	//重写接口中的默认的方法【可选】
	//抽象方法重名
}

  • 抽象方法
    接口中，有多个抽象方法，实现类必须重写所有的抽象方法，如果抽象方法有重名的，只需要重写一次即可

    //定义多个接口
public interface Animal{
	public abstract void eat();
	public abstract void run();
} 
public interface Human{
	pubic abstract void eat();
	pubic abstract void run();
}
//定义实现类
public class People implements Animal,Human{
	@Override
	public void eat(){
		System.out.println("吃东西！");
	}
	@Override
	public void run(){
		System.out.println("健身！");
	}
}

  • 默认方法
    接口中，有多个默认方法是，实现类都可继承使用，如果默认方法有重名的，【必须重写一次】

    public interface A{
	public default void methodA{}
	public default void method{}
}
public interface B{
	public default void methodB{}
	public default void method{}
}
//定义实现类
public class C implements A,B{
	@Override
	public void method(){
		System.out.println("method的方法被调用");
	} 
}

  • 静态方法
    接口中，如果存在同名的静态方法并不会冲突，原因是只能通过各自的接口名访问静态方法。

  • 优先级的问题
    当一个类，即继承了一个父类，又同时实现了多个接口，父类中的成员与接口当中的默认方法重名，【子类就近选择执行父类的成员方法】。

    //定义接口
public interface A{
	public default void methodA(){
		System.out.println("AAAAA");
	}
}
//定义父类
public class D{
	public void methodA{
		System.out.println("DDDDD");
	}
}
//定义子类
public class E extends D implements A{
	//为重写methodA();方法
}
//测试类
public class Text{
	public static void main(String[] args){
		E e=new E();
		e.methodA();//DDDDD
	}
}

  • 接口的多继承
    一个接口能继承另一个或者多个接口，这和类之间的继承向比较相似。接口的继承使用extends关键字，子接口继承接口的方法，如果父接口中的默认方法有重名方法，那么子接口需要重写一次。

    public interface A{
	public default void method(){
		System.out.println("AAAAA");
	}
}
public interface B{
	public default void method(){
		System.out.println("BBBBB");
	}
}
//定义接口继承接口
public interface C extends A,B{
	@Oberride
	public default void method(){
		Systemj.out.println();
	}
}
//子接口重写默认方法，【default关键字保留】。

  • 其他成员变量的特点

    1. 接口中，无法定义成员变量，但是可以定义常量，因为值不可变，默认使用public static final 修饰的
    2. 接口中，没有构造方法，不能创建对象
    3. 接口当中，没有静态代码块

  • 接口的好处

    1. 定义规则
    2. 减低低耦合。【高内聚，低耦合】
    3. 扩展原有的类的功能
posted @ 2021-12-02 14:55  MikiKawai  阅读(307)  评论(0)  编辑  收藏  举报