简单认识接接口与基本的实现

接口

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法、成员方法，那么接口的内部主要就是封装了方法，包含了抽象方法（JDK1.7及以前），默认方法和静态的方法（JDK1.8），私有方法（JDK1.9）。
特点：

• 接口中，无法定义成员变量，但是可以定义常量，因为值不可变，默认使用 public static final 修饰的

• 接口中，没有构造方法，不能创建对象

• 接口中，没有静态代码块

  接口的好处：

• 定义规则

• 降低耦合性 【高内聚,低耦合】

• 扩展原有类的功能

接口的定义格式：它与类的定义很相似，但是使用interface关键字，它也会被编译生成class文件，但一定要明确它不是类,而是另外一种引用数据类型。
我们目前接触到的引用数据类型有：
  类、数组、接口
接口的使用：不能直接创建对象，但是可以被实现（implements关键字,类似于被继承），一个实现接口的类（可以看做是接口的子类），需要重写接口中的所有抽象方法，创建该类对象，就可以调用方法了。

public interface 接口名称{
   //抽象方法   主要
   //默认方法
   //静态方法
   //常量
   //私有方法(JDK1.9)
}

含有抽象方法
抽象方法: 使用abstract关键字修饰，没有方法体内容，该方法主要是供子类使用。

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

含有默认方法和静态方法
默认方法：使用default关键字修饰的方法，我们成为默认方法，不可省略，供子类调用或者子类重写。
静态方法：使用static关键字修饰的方法，供接口直接调用。
含有私有方法和私有静态的方法
私有方法：使用private关键字，供接口中的默认方法或者静态方法调用。
代码如下：

public interface InerfaceName{
    
    private void meth0d(){
        //方法体内容
        
        
    }
    
    
}

基本的实现

实现的概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现动作类似于继承，格式相仿，只是关键字不同,实现使用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(){
        System.out.println("恰");
    }
      @Override
    public void sleep(){
        System.out.println("睡觉");
    }
}


//定义一个测试类
public class InterfaceDemo01{
    
    public static void main(String[] args){
        //创建子类对象
        Animal ani = new Animal();
        //调用重写之后的方法
        ani.eat();
        ani.sleep();
 
    }

}
//输出结果
//恰
//睡觉

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

public interface  Biological{
    //生物
   public default void fly(){ 
       System.out.println("飞");
   }
}
//定义实现类
public class Animal implements Biological{
    //继承  什么也不写
}

//定义测试类
public class InterfaceDemo02{
    
    public static void main(String[] args){
        //创建子类对象
        Animal ani = new Animal;
        //调用默认方法
        ani.fly();
        
    }

}
//输出结果
//飞

2.重写默认方法
代码如下：

public interface  Biological{
    //生物
   public default void fly(){ 
       System.out.println("飞");
   }
}

public class Animal implements Biological{
   @Override
    public void fly(){
        System.out.println("自由自在的飞");
    }
}

public class InterfaceDemo03{
    
    public static void main(String[] args){
        //创建子类对象
        Animal ani = new Animal;
        //调用重写方法
        ani.fly();
        
    }

}

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

public interface  Biological{
    //生物
   public static  void fly(){ 
       System.out.println("跑起来");
   }
}

public class Animal implements Biological{
  //无法重写静态方法
}

//定义测试类
public class InterfaceDemo03{
    
    public static void main(String[] args){
       //Animal.run(); 错误操作，无法继承 ，也无法调用
        Biological.fly();
    }
}
//

4.私有方法的使用
私有方法：只有默认方法可以调用

私有静态方法：默认方法和静态方法都可以调用

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

代码如下：

public interface Biological{
    private void run1(){
        System.out.println("跑起来");
    }
    public default void funMethod1{
       // System.out.println("跑起来");
        run1();
    }
    public default void funMethod2{
       // System.out.println("跑起来");
        run1();
    }
    
 
}

接口的多实现

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

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

抽象方法

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

//定义多个接口
public interface Animal{
   public abstract void eat();
    public abstract void run();
}

public interface Human{
    public abstract void eat();
    public 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 methodA(){}
  
  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("AAAAAAAAA");
    }
}
//定义父类
public class D{
    
    public void methodA(){
        System.out.println("DDDDDDDD");
    }
}
//定义子类
public class E extends D implements A{
    //未重写methodA()方法
}

//定义测试类
public class TestInterfaceDemo06{
    
    public static void main(String[] args){
        
        //创建子类对象E
        E e = new E();
        e.methodA();
        
    }
    
}

备注：子接口重写默认方法，default关键字保留.