1.理解内部类的使用场景 2.能够正确的在代码中使用匿名内部类 3.理解函数式编程思想 4.使用lamda表达式 优化匿名内部类 5. 匿名内部类的书写 6. lambda表达式书写

1.内部类

1.1 内部类的基本使用(理解)

  • 内部类概念

    • 在一个类中定义一个类。举例:在一个类A的内部定义一个类B,类B就被称为内部类
  • 内部类定义格式

    • 格式&举例:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      /*
      格式:
      class 外部类名{
      修饰符 class 内部类名{

      }
      }
      */

      class Outer {
      public class Inner {

      }
      }
  • 内部类的访问特点

    • 内部类可以直接访问外部类的成员,包括私有
    • 外部类要访问内部类的成员,必须创建对象,也可以访问内部类的私有成员
  • 示例代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /*
    内部类访问特点:
    内部类可以直接访问外部类的成员,包括私有
    外部类要访问内部类的成员,必须创建对象
    */
    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();
  • 私有成员内部类

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

    • 示例代码:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      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 外部类名.内部类名();

    • 静态成员内部类中的静态方法:外部类名.内部类名.方法名();

    • 示例代码

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      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
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    class Outer {
    private int num = 10;
    public void method() {
    int num2 = 20;
    class Inner {
    public void show() {
    System.out.println(num);
    System.out.println(num2);
    }
    }
    Inner i = new Inner();
    i.show();
    }
    }
    public class OuterDemo {
    public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
    }
    }

1.4 匿名内部类(应用)

  • 匿名内部类的前提

    • 存在一个类或者接口,这里的类可以是具体类也可以是抽象类
  • 匿名内部类的格式

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

    • 举例:

      1
      2
      3
      4
      new Inter(){
      @Override
      public void method(){}
      }
  • 匿名内部类的本质

    • 本质:是一个继承了该类或者实现了该接口的子类匿名对象
  • 匿名内部类的细节

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

      1
      2
      3
      4
      5
      6
      Inter i = new Inter(){
      @Override
      public void method(){

      }
      }
  • 匿名内部类直接调用方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    interface Inter{
    void method();
    }

    class Test{
    public static void main(String[] args){
    new Inter(){
    @Override
    public void method(){
    System.out.println("我是匿名内部类");
    }
    }.method(); // 直接调用方法
    }
    }

1.5 匿名内部类在开发中的使用(应用)

  • 匿名内部类在开发中的使用

    • 当发现某个方法需要,接口或抽象类的子类对象,我们就可以传递一个匿名内部类过去,来简化传统的代码
  • 示例代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    /*
    游泳接口
    */
    interface Swimming {
    void swim();
    }

    public class TestSwimming {
    public static void main(String[] args) {
    goSwimming(new Swimming() {
    @Override
    public void swim() {
    System.out.println("铁汁, 我们去游泳吧");
    }
    });
    }

    /**
    * 使用接口的方法
    */
    public static void goSwimming(Swimming swimming){
    /*
    Swimming swim = new Swimming() {
    @Override
    public void swim() {
    System.out.println("铁汁, 我们去游泳吧");
    }
    }
    */
    swimming.swim();
    }
    }

2.Lambda表达式

2.1体验Lambda表达式【理解】

​ 理解: 将没有声明的方法在{}中声明一下

  • 代码演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    /*
    游泳接口
    */
    interface Swimming {
    void swim();
    }

    public class TestSwimming {
    public static void main(String[] args) {
    // 通过匿名内部类实现
    goSwimming(new Swimming() {
    @Override
    public void swim() {
    System.out.println("铁汁, 我们去游泳吧");
    }
    });

    /* 通过Lambda表达式实现
    理解: 对于Lambda表达式, 对匿名内部类进行了优化
    */
    goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
    * 使用接口的方法
    */
    public static void goSwimming(Swimming swimming) {
    swimming.swim();
    }
    }
  • 函数式编程思想概述

    在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿数据做操作”

    面向对象思想强调“必须通过对象的形式来做事情”

    函数式思想则尽量忽略面向对象的复杂语法:“强调做什么,而不是以什么形式去做”

    而我们要学习的Lambda表达式就是函数式思想的体现

2.2Lambda表达式的标准格式【理解】

  • 格式:

    ​ (形式参数) -> {代码块}

    • 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可
    • ->:由英文中画线和大于符号组成,固定写法。代表指向动作
    • 代码块:是我们具体要做的事情,也就是以前我们写的方法体内容
  • 组成Lambda表达式的三要素:

    • 形式参数,箭头,代码块
  • lambda表达式的前提

    • 接口只有一个方法

    • 方法需要是一个接口

2.3Lambda表达式练习1【应用】

  • Lambda表达式的使用前提

    • 有一个接口
    • 接口中有且仅有一个抽象方法
  • 练习描述

    ​ 无参无返回值抽象方法的练习

  • 操作步骤

    1.编写一个接口(ShowHandler)

    1. 在该接口中存在一个抽象方法(show),该方法是无参数无返回值
    2. 在测试类(ShowHandlerDemo)中存在一个方法(useShowHandler)
       方法的的参数是ShowHandler类型的
       在方法内部调用了ShowHandler的show方法
  • 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    public class TestLambda {
    /*
    Lambda表达式的使用前提
    1. 一个接口
    2. 接口中有且仅有一个抽象方法

    练习1:
    1. 编写一个接口(ShowHandler)
    2. 在该接口中存在一个抽象方法(show),该方法是无参数无返回值
    3. 在测试类(ShowHandlerDemo)中存在一个方法(useShowHandler)
    方法的的参数是ShowHandler类型的
    在方法内部调用了ShowHandler的show方法
    */
    public static void main(String[] args) {
    useShowHandler(new ShowHandler() {
    @Override
    public void show() {
    System.out.println("我是匿名内部类中的show方法");
    }
    });

    // Lambda实现
    useShowHandler( () -> System.out.println("我是Lambda中的show方法"));
    }

    public static void useShowHandler(ShowHandler showHandler){
    showHandler.show();
    }

    }

    interface ShowHandler {
    void show();
    }

2.4Lambda表达式练习2【应用】

  • 练习描述

    有参无返回值抽象方法的练习

  • 操作步骤

    1.首先存在一个接口(StringHandler)
    2.在该接口中存在一个抽象方法(printMessage),该方法是有参数无返回值
    3.在测试类(StringHandlerDemo)中存在一个方法(useStringHandler)

                方法的的参数是StringHandler类型的
                在方法内部调用了StringHandler的printMessage方法
  • 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    public class StringHandlerDemo {
    /*
    1.首先存在一个接口(StringHandler)
    2.在该接口中存在一个抽象方法(printMessage),该方法是有参数无返回值
    3.在测试类(StringHandlerDemo)中存在一个方法(useStringHandler)
    方法的的参数是StringHandler类型的
    在方法内部调用了StringHandler的printMessage方法
    */
    public static void main(String[] args) {
    useStringHandler(new StringHandler() {
    @Override
    public void printMessage(String msg) {
    System.out.println("我是匿名内部类" + msg);
    }
    });

    // Lambda实现
    useStringHandler( msg -> System.out.println("我是Lambda表达式" + msg));
    }

    public static void useStringHandler(StringHandler stringHandler){
    stringHandler.printMessage("itheima");
    }
    }

    interface StringHandler {
    void printMessage(String msg);
    }


2.5Lambda表达式练习3【应用】

  • 练习描述

    无参有返回值抽象方法的练习

  • 操作步骤

    1. 首先存在一个接口(RandomNumHandler)

    2. 在该接口中存在一个抽象方法(getNumber),该方法是无参数但是有返回值

    3. 在测试类(RandomNumHandlerDemo)中存在一个方法(useRandomNumHandler)

       方法的的参数是RandomNumHandler类型的
       在方法内部调用了RandomNumHandler的getNumber方法
  • 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    public class RandomNumHandlerDemo {
    /*
    1. 首先存在一个接口(RandomNumHandler)
    2. 在该接口中存在一个抽象方法(getNumber),该方法是无参数但是有返回值
    3. 在测试类(RandomNumHandlerDemo)中存在一个方法(useRandomNumHandler)
    方法的的参数是RandomNumHandler类型的
    在方法内部调用了RandomNumHandler的getNumber方法
    */
    public static void main(String[] args) {
    useRandomNumHandler(new RandomNumHandler() {
    @Override
    public int getNumber() {
    Random r = new Random();
    int num = r.nextInt(10) + 1;
    return num;
    }
    });

    useRandomNumHandler( () -> {
    Random r = new Random();
    int num = r.nextInt(10) + 1;
    return num;
    // 注意: 如果lambda所操作的接口中的方法, 有返回值, 一定要通过return语句, 将结果返回
    // 否则会出现编译错误
    } );
    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler){
    int result = randomNumHandler.getNumber();
    System.out.println(result);
    }
    }

    interface RandomNumHandler {
    int getNumber();
    }


2.6Lambda表达式练习4【应用】

  • 练习描述

    有参有返回值抽象方法的练习

  • 操作步骤

    ​ 1.首先存在一个接口(Calculator)
    ​ 2. 在该接口中存在一个抽象方法(calc),该方法是有参数也有返回值
    ​ 3. 在测试类(CalculatorDemo)中存在一个方法(useCalculator)
    ​ 方法的的参数是Calculator类型的
    ​ 在方法内部调用了Calculator的calc方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    public class CalculatorDemo {
    /*
    1. 首先存在一个接口(Calculator)
    2. 在该接口中存在一个抽象方法(calc),该方法是有参数也有返回值
    3. 在测试类(CalculatorDemo)中存在一个方法(useCalculator)
    方法的的参数是Calculator类型的
    在方法内部调用了Calculator的calc方法

    */
    public static void main(String[] args) {
    useCalculator(new Calculator() {
    @Override
    public int calc(int a, int b) {
    return a + b;
    }
    });

    useCalculator( ( a, b) ->
    a + b
    );
    }

    public static void useCalculator(Calculator calculator){
    int result = calculator.calc(10,20);
    System.out.println(result);
    }
    }

    interface Calculator {
    int calc(int a, int b);
    }

2.7Lambda表达式的省略模式【应用】

  • 省略的规则

    • 参数类型可以省略。但是有多个参数的情况下,不能只省略一个
    • 如果参数有且仅有一个,那么小括号可以省略
    • 如果代码块的语句只有一条,可以省略大括号和分号,和return关键字
  • 代码演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    public interface Addable {
    int add(int x, int y);
    }

    public interface Flyable {
    void fly(String s);
    }

    public class LambdaDemo {
    public static void main(String[] args) {
    // useAddable((int x,int y) -> {
    // return x + y;
    // });
    //参数的类型可以省略
    useAddable((x, y) -> {
    return x + y;
    });

    // useFlyable((String s) -> {
    // System.out.println(s);
    // });
    //如果参数有且仅有一个,那么小括号可以省略
    // useFlyable(s -> {
    // System.out.println(s);
    // });

    //如果代码块的语句只有一条,可以省略大括号和分号
    useFlyable(s -> System.out.println(s));

    //如果代码块的语句只有一条,可以省略大括号和分号,如果有return,return也要省略掉
    useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
    f.fly("风和日丽,晴空万里");
    }

    private static void useAddable(Addable a) {
    int sum = a.add(10, 20);
    System.out.println(sum);
    }
    }

2.8Lambda表达式和匿名内部类的区别【理解】

  • 所需类型不同
    • 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
    • Lambda表达式:只能是接口
  • 使用限制不同
    • 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类
    • 如果接口中多于一个抽象方法,只能使用匿名内部类,而不能使用Lambda表达式
  • 思想不同
    • lambda表达式是函数式编程思想
    • 匿名内部类是面向对象的思想
  • 实现原理不同
    • 匿名内部类:编译之后,产生一个单独的.class字节码文件
    • Lambda表达式:编译之后,没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成