内部类和接口

1.内部类
1.1内部类
在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
内部类定义格式
/*
格式：
class 外部类名{
修饰符 class 内部类名{

	}
}

*/

class Outer {
public class Inner {

}

}
内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有

• 外部类要访问内部类的成员，必须创建对象

• /*
  内部类访问特点：
  内部类可以直接访问外部类的成员，包括私有
  外部类要访问内部类的成员，必须创建对象
  */
  public class Outer {
  private int num = 10;
  public class Inner {
  public void show() {
  System.out.println(num);
  }
  }
  public void method() {
  Inner i = new Inner();
  i.show();
  }
  }
  1.2 成员内部类
  成员内部类的定义位置

• 在类中方法，跟成员变量是一个位置

• 外界创建成员内部类格式

• 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

• 举例：Outer.Inner oi = new Outer().new Inner();

• 私有成员内部类

• 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

• class Outer {
  private int num = 10;
  private class Inner {
  public void show() {
  System.out.println(num);
  }
  }
  public void method() {
  Inner i = new Inner();
  i.show();
  }
  }
  public class InnerDemo {
  public static void main(String[] args) {
  //Outer.Inner oi = new Outer().new Inner();
  //oi.show();
  Outer o = new Outer();
  o.method();
  }
  }
  静态成员内部类

• 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

• 静态成员内部类中的静态方法：外部类名.内部类名.方法名();
  class Outer {
  static class Inner {
  public void show(){
  System.out.println(“inner…show”);
  }

    public static void method(){
        System.out.println("inner..method");
    }
  

  }
  }

public class Test3Innerclass {
/*
静态成员内部类演示
*/
public static void main(String[] args) {
// 外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();

    Outer.Inner.method();
}

}
1.3 局部内部类

• 局部内部类定义位置

  • 局部内部类是在方法中定义的类

• 局部内部类方式方式

  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
    ** 1.4 匿名内部类**

  • 匿名内部类的前提

  • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 匿名内部类的格式

  • 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

  • 举例：

  • new Inter(){
    @Override
    public void method(){}
    }

• 匿名内部类的本质

  • 本质：是一个继承了该类或者实现了该接口的子类匿名对象

• 匿名内部类的细节

  • 匿名内部类可以通过多态的形式接受

  • Inter i = new Inter(){
    @Override
    public void method(){

    }
    }
    匿名内部类直接调用方法
    interface Inter{
    void method();
    }

class Test{
public static void main(String[] args){
new Inter(){
@Override
public void method(){
System.out.println(“我是匿名内部类”);
}
}.method(); // 直接调用方法
}
}
1.5 匿名内部类在开发中的使用
当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
2.Lambda表达式
2.1 Lambda表达式【理解】
函数式编程思想概述
面向对象思想强调“必须通过对象的形式来做事情”
函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现
2.2 Lambda表达式的标准格式

• 格式：
  ​ (形式参数) -> {代码块}
  • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
  • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
• 组成Lambda表达式的三要素：
  • 形式参数，箭头，代码块
    2.3 Lambda表达式练习
  • 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
• 定义一个测试类(AddableDemo)，在测试类中提供两个方法
  • 一个方法是：useAddable(Addable a)
  • 一个方法是主方法，在主方法中调用useAddable方法

public interface Addable {
int add(int x,int y);
}
public class AddableDemo {
public static void main(String[] args) {
//在主方法中调用useAddable方法
useAddable((int x,int y) -> {
return x + y;
});
}
private static void useAddable(Addable a) {
int sum = a.add(10, 20);
System.out.println(sum);
}
}
2.4 Lambda表达式的使用前提

• 使用Lambda必须要有接口
• 并且要求接口中有且仅有一个抽象方法
  2.5 Lambda表达式和匿名内部类的区别
• 所需类型不同
  • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
  • Lambda表达式：只能是接口
• 使用限制不同
  • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
  • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
• 实现原理不同
  • 匿名内部类：编译之后，产生一个单独的.class字节码文件
  • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

3接口
3.1接口的概述

• 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
• Java中接口存在的两个意义
  1. 用来定义规范
  2. 用来做功能的拓展
     3.2接口的特点
     3.2.1 接口用关键字interface修饰
     public interface 接口名 {}
     3.2.2类实现接口用implements表示
     public class 类名 implements 接口名 {}
     3.3.3接口不能实例化
     ​ 我们可以创建接口的实现类对象使用
     3.3.4接口的子类
     ​ 要么重写接口中的所有抽象方法
     ​ 要么子类也是抽象类
     3.3接口的成员特点
     成员特点
     -成员变量
     ​ 只能是常量
     ​ 默认修饰符：public static final
     -构造方法
     ​ 没有，因为接口主要是扩展功能的，而没有具体存在
     -成员方法
     ​ 只能是抽象方法
     ​ 默认修饰符：public abstract
     3.4类和接口的关系

• 类与类的关系
  ​ 继承关系，只能单继承，但是可以多层继承
• 类与接口的关系
  ​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口与接口的关系
  ​ 继承关系，可以单继承，也可以多继承
  ​