接口(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();//天上飞
  	}
  }
  

  2. 重写默认的方法

  //定义接口类 
  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. 扩展原有的类的功能