# 第四章：接口、lambda表达式、内部类

接口

• 接口不是类，而是对希望符合这个接口的类的一组需求。是一种规则
• 接口绝对不会有实例字段，提供实例字段和方法实现的任务应该有实现接口的那个类完成。

定义

• 使用关键字 interface 来定义

  public interface 接口名{}
  

• 接口不能实例化，接口和类之间是实现关系，通过 implements 关键字表示

  public class 类名 implements 接口名{}
  

• 接口的子类（实现类）

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

示例

//父类：Animal
public class Animal{
	private String name;
	private int age;
	public Animal(){}
	public Animal(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;}
    public abstract void eat();
}

//接口
public interface Swim{
	public abstract eat();
}

//子类
public class Dog extends Animal implements Swim{
	public Dog(){};
	public Dog(String name,int age){super(name,age)}
	@Override
	public void eat(){
	 System.out.println("狗吃骨头")
	}
	@Override
	public void Swim(){
	 System.out.println("狗在游泳")
	}
}

//测试类
public class Test{
	public static void main(String[],args){
		Dog erHa = new Dog("二哈",1);
		erHa.eat();
		erha.Swim();
	}
}

接口中成员的特点

• 成员变量
  • 只能是常量
  • 默认修饰符：public static final
• 构造方法
  • 接口没有构造方法
  • 默认修饰符：public abstract

类和接口的关系

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

接口和接口间的关系

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

扩展

jdk8以后

默认方法

• 允许在接口定义默认方法，需要使用关键字default修饰，他的作用是用于解决接口升级的问题

• 定义格式

  public default void getType(){}
  

• 默认方法不是抽象方法，不用强制重写，如果重写的话，去掉default关键字

• public可以省略，但是default不能省略

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

静态方法

• 允许在接口定义静态方法，使用static修饰

• 定义格式

  public static void getType(){}
  

• 接口名只能通过接口名调用，不能通过实现类或者对象名调用

• public可以省略，但是static不能省略

jdk9

私有方法

• 定义格式

  格式1：private void show(){}
  格式2：private static void method(){}
  

  注意：当一个方法的参数是接口时，可以传递接口所有的实现类的对象，这种方式称之为接口多态

适配器设计模式

解决接口与接口实现类之间的矛盾问题

示例

//先写一个接口
package com.shuaige.day03;

public interface SpeakEnglish {
   //假如我这里有10个方法
}
//然后再写一个类来继承这个接口，这个接口就相当于适配器
public abstract class 类名 extends SpeakEnglish{
//在这里吧接口的所有方法进行空实现（就是方法重写了，但是不写方法体），
}

//然后再用一个类继承这个适配器
public class 类名 extends 适配器{
	//重写接口里你想用的那个方法就可以了
}

lambda表达式

定义：lambda是一个可传递的代码块，可以在以后一次或多次执行，他的本质是一个匿名函数

注意：Lambda表达式只支持函数式接口 也就是只有一个抽象方法的接口

格式：(参数1，…参数n) -> {方法体};

//这段代码的意思是这个lambda表达是接收两个字符串，然后比较他们的长度，根据结果返回相应的值
（String frist,String second){
	if(first.length() < second.length()){
		return -1;
	}else if(fitst.length() > second.length()){
		return 1;
	}else{
		return 0
	}
}

内部类

• 访问特点：

  • 可以直接访问外部类的变量成员，包括私有
  • 外部类要访问内部类的成员，必须创建对象

• 使用场景：b类表示A类的一部分，并且b类没有单独存在的意义

• 分类

  • 成员内部类（了解）
  • 静态内部类（了解）
  • 局部内部类（了解）
  • 匿名内部类（掌握）

成员内部类

• 获取成员内部类的两种方式

  • 当成员内部类被private修饰的时候，在外部类编写方法，对外提供内部类对象

  • 当成员内部类被非私有修饰时，直接创建对象。如

    Outer.Inner oi = new Outer().new Inner();
    

• 外部类成员变量和内部类成员变量重名的时候，在内部类如何访问

  Outer.this.变量名
  

静态内部类

• 静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。原理和静态方法一样
• 创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名（）；

局部内部类

• 将内部类定义在方法里面就叫做局部内部类，类似与方法的局部变量
• 外界无法直接使用，需要在内部创建对象并调用
• 该类可以直接访问外部类的成员，也可以访问方法内的局部便变量

匿名内部类

• 本质上就是隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。

• 格式：包含了继承或实现，方法重写，创建对象。整体就是一个类的子类对象或者接口的实现类对象。

  new 类名或者接口名{
  	重写方法
  }
  

• 使用场景：当方法的参数是接口或类时，以接口为例，可以传递这个接口的实现类对象。如果实现类只要使用一次，就可以用匿名内部类简化代码