## 形参和返回值

### 类名作为形参和返回值

方法的参数是类名，其实需要的是该类的子类对象

方法的返回值类型是类名，其实返回的是该类的子类对象

### 抽象类名作为形参和返回值

方法的参数是抽象类名，其实需要的是该抽象类的子类对象

方法的返回值类型是抽象类名，其实返回的是该抽象类的子类对象

### 接口名作为形参和返回值

方法的参数是接口名，其实需要的是该接口的实现对象

方法的返回值类型是接口名，其实返回的是该接口的实现对象

## 报Error:java: 无效的源发行版: 13

[解决方法](https://blog.csdn.net/Sunshine_Mr_Sun/article/details/108109669)

## 内部类

### 内部类概述

1. 内部类：就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，那么叫类B为内部类。

2. 定义格式：

> **public class 类名 { **
  >
  > 		`修饰符 class 内部类名{ }`
  >
  > **}**

3. 范例：

~~~java
  public class Outer {
   	public class Inner{
      }   
  }
  ~~~

4. 访问特点：

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

5. 代码演示：

~~~java
  package com.itheima.day04.outerInter;
  
  /**
   * @Author: ✎﹏ Sunflower丶
   * @Specification: 内部类
   */
  public class Outer {
      /*
      内部类访问特点：
          内部类可以直接访问外部类的成员，包括私有
          外部类要访问内部类的成员，必须创建对象
   */
      private int num = 20;
      public class Inner {
          int a = 10;
          public void method() {
             //内部类可以直接访问外部类的成员，包括私有 System.out.println("我是内部类方法" + num);
          }
      }
      public void show() {
          //外部类要想访问内部类成员，必须创建对象
          Inner oi = new Inner();
          oi.method();
      }
  }
  ~~~

6. 按照内部类的位置不同，可分为如下两种形式：

* 在类的`成员位置`：成员内部类
  * 在类的`局部位置`：局部内部类

### 成员内部类

1. 成员内部类的定义位置

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

2. 外界创建成员内部类格式：

> `外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();`

3. 范例：

~~~java
  Outer.Inter oi = new Outer().new Inner();
  ~~~

4. 代码演示：

~~~java
  package com.itheima.day04.test;
  
  import com.itheima.day04.outerInter.Outer;
  
  /**
   * @Author: ✎﹏ Sunflower丶
   * @Specification: 测试类
   */
  public class Test {
      public static void main(String[] args) {
          Outer.Inter oi = new Outer().new Inter();
          oi.method();
      }
  }
  ~~~

### 私有成员内部类

1. 定义格式：

> **public class 类名 { **
    >
    > 		**`private` class 内部类名{ }**
    >
    > **}**

2. 范例：

~~~java
    public class Outer {
     	private class Inner{
        }   
    }
    ~~~

3. 私有成员内部类访问：

* `在自己所在的外部类中创建对象访问`

4. 代码演示：

~~~java
    public class Outer {
        private class Inner {
            public void method() {
                System.out.println("这是私有内部类");
            }
        }
        public void show() {
            Inner inner = new Inner();
            inner.method();
        }
    }
~~~

~~~java
    public class Test01 {
        public static void main(String[] args) {
            //Outer.Inner io = new Outer().new Inner();  
            // 因为私有内部类Inner 无法访问，但可以在所在的外部类创建对象访问。
            Outer o = new Outer();
            o.show();
        }
    }
~~~

### 静态成员内部类

1. 定义格式：

> **public class 类名 { **
    >
    > 		**`static` class 内部类名{ }**
    >
    > **}**

2. 范例：

~~~java
    public class Outer {
     	static class Inner{
        }   
    }
~~~

3. 静态成员内部类访问格式：

> `外部类名.内部类名 对象名 = new 外部类名.内部类名();`

4. 静态成员内部类中的静态方法：

> `外部类名.内部类名.方法名();`

5. 代码演示：

~~~java
    public class Outer {
    
        public static class Inner {
            public void method() {
                System.out.println("这是静态内部类中的非静态方法method");
            }
    
            public static void show() {
                System.out.println("这是静态内部类中的静态方法show");
            }
        }
    }
    
~~~

~~~java
    public class Test {
        public static void main(String[] args) {
            //访问静态成员内部类的非静态方法
            Outer.Inner oi = new Outer.Inner();
            oi.method();
            oi.show();
            //访问静态成员内部类中的静态方法
            Outer.Inner.show();
        }
    }
~~~

### 局部内部类

1. 局部内部类的定义位置

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

2. 局部内部类方式方式

> - 局部内部类，`外界是无法直接使用，需要在方法内部创建对象并使用`
  > - 该类可以直接访问`外部类的成员`，也可以访问`方法内的局部变量`

3. 代码演示：

~~~java
  public class Outer {
      int num  = 20;
      public void method() {
          int a = 10;
          class Inner{
              public void show() {
                  System.out.println(a);
                  System.out.println(num);
                  System.out.println("这是局部内部类");
              }
          }
          Inner inner = new Inner();
          inner.show();
      }
  }
~~~

~~~java
  public class Demo {
      public static void main(String[] args) {
          Outer outer = new Outer();
          outer.method();
      }
  }
  ~~~

### 匿名内部类

1. 概述：

> `匿名内部类本质是一个特殊的局部内部类 (定义在方法内部)`

2. 匿名内部类的前提：

* 需要存在一个`类`或者`接口`。这里的类可以是`具体类`，也可以是`抽象类`。

3. 匿名内部类的格式：

> `new 类名或者接口名() {`
  >
  > 			`重写方法`
  >
  > `};`

4. 范例：

~~~java
  new Inner() {
      @Override
      public void show() {
      }
  }
  ~~~

5. 匿名内部类的本质

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

6. 匿名内部类的细节

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

```java
    Inter i = new Inter(){
      @Override
        public void method(){
            
        }
    }
```

7. 匿名内部类直接调用方法

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

> `理解：匿名内部类是将(继承\实现)(方法重写)(创建对象)三个步骤，放在一步进行`

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

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

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

> `当方法的形式参数是接口或者抽象类时，可以将匿名内部类作为实际参数进行传递`

- 示例代码：

~~~java
  /*
      游泳接口
   */
  interface Swimming {
      void swim();
  }
  
~~~

```java
  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();
      }
  }
```

**注意事项：**

> `如果接口中的方法不大于一个，那么建议使用匿名内部类。否则，原始定义方式更好。`

## Lambda表达式

### 体验Lambda表达式

1. 代码演示

~~~java
  /*
      游泳接口
   */
  interface Swimming {
      void swim();
  }
~~~

~~~java
  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();
      }
  }
~~~

2. 函数式编程思想概述

> * 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
  >
  > * 面向对象思想强调“必须通过对象的形式来做事情”
  >
  > * 函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
  > * 而我们要学习的Lambda表达式就是函数式思想的体现

### Lambda表达式的标准格式

* 格式：

> `(形式参数) -> {代码块}`
  >
  > 这个整体可以理解为接口的实现类对象

* 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有，则空着。
  * -> : 由英文中画线和大于符号组成，固定写法。代表指向动作
  * 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

* 组成Lambda表达式的三要素：

> 1. `(形式参数)`形式参数
  > 2. `->`箭头
  > 3. `{}`代码块

* 代码演示：

~~~java
  public interface ShowHandler {
      void add();
  }
  ~~~

~~~java
  public class AddTest {
      public static void main(String[] args) {
          useShowHandler(new ShowHandler() {
              @Override
              public void add() {
                  System.out.println("我是匿名内部类的add");
              }
          });
          //Lambda实现 ():代表的是接口中抽象方法的参数， {}：重写接口的抽象方法
          //使用前提，有一个接口并且接口里面只有一个抽象方法
          ShowHandler showHandler = () -> {};
          useShowHandler(() -> {
              int a = 1;
              if (a == 1) {
                  System.out.println("我是Lambda的add1");
              }else {
                  System.out.println("我是Lambda的add2");
              }
          });
      }
  
      public static void  useShowHandler(ShowHandler showHandler) {
          showHandler.add();
      }
  }
  ~~~

### Lambda练习--有参数无返回值

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

- 操作步骤
  - 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
  - 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
    - 一个方法是：useFlyable(Flyable f)
    - 一个方法是主方法，在主方法中调用useFlyable方法

- 代码演示

~~~java
  /**
   * @Author: ✎﹏ Sunflower丶
   * @Specification: Flyable接口
   */
  public interface Flyable {
      void fly(String s);
  }
  
~~~

~~~java
  /**
   * @Author: ✎﹏ Sunflower丶
   * @Specification: 测试类
   */
  public class FlyableDemo {
      public static void main(String[] args) {
          //在主方法中调用useFlyable方法
          //匿名内部类
          useFlyable(new Flyable() {
              @Override
              public void fly(String s) {
                  System.out.println(s);
                  System.out.println("飞机自驾游");
              }
          });
          System.out.println("--------");
  
          //Lambda
          useFlyable((String s) -> {
              System.out.println(s);
              System.out.println("飞机自驾游");
          });
  
      }
  
      private static void useFlyable(Flyable f) {
          f.fly("风和日丽，晴空万里");
      }
  }
~~~

### Lambda练习--无参有返回值

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

- 操作步骤
  - 定义一个接口(Randomable)，里面定义一个抽象方法：int random();
  - 定义一个测试类(RandomableDemo)，在测试类中提供两个方法
    - 一个方法是：useRandomable(Randomable a)
    - 一个方法是主方法，在主方法中调用useRandomable方法

### Lambda练习--有参有返回值

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

- 操作步骤
  - 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
  - 定义一个测试类(AddableDemo)，在测试类中提供两个方法
    - 一个方法是：useAddable(Addable a)
    - 一个方法是主方法，在主方法中调用useAddable方法

- 代码演示

~~~java
  /**
   * @Author: ✎﹏ Sunflower丶
   * @Specification: Addable接口
   */
  public interface Addable {
      int add (int x, int y);
  }
  
  ~~~

~~~java
  /**
   * @Author: ✎﹏ Sunflower丶
   * @Specification: 测试类
   */
  public class AddableDemo {
      public static void main(String[] args) {
          //在主方法中调用useAddable方法
          useAddable((int x, int y) -> {
              return x+y;
          });
      }
      public static void useAddable(Addable a){
          int add = a.add(10, 20);
          System.out.println(add);
      }
  }
  ~~~

### Lambda表达式的省略模式

- 省略的规则

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

- 代码演示

~~~java
  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);
      }
  }
  ~~~

### Lambda表达式的使用前提

- `使用Lambda必须要有接口`
- `并且要求接口中有且仅有一个抽象方法`

### Lambda表达式和匿名内部类的区别

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

内部类、Lambda表达式

目录