[学习交流] day13学习总结

本帖最后由段孟钊于 2019-5-19 10:17 编辑

个人笔记一、体验Lambda表达式

案例需求
启动一个线程，在控制台输出一句话：多线程程序启动了
实现方式一
- 实现步骤
  - 定义一个类MyRunnable实现Runnable接口，重写run()方法
  - 创建MyRunnable类的对象
  - 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
  - 启动线程
实现方式二
- 匿名内部类的方式改进
实现方式三
- Lambda表达式的方式改进

[Java] 纯文本查看 复制代码

package lambdatest;
  
  public class MyThread implements Runnable {
      @Override
      public void run() {
          System.out.println("多线程启动了");
      }
  }
  package lambdatest;
  
  public class ThreadTest {
      public static void main(String[] args) {
          //标准格式
          MyThread mt = new MyThread();
          Thread t1 = new Thread(mt);
          t1.start();
          //简写版
          new Thread(new MyThread()).start();
          //匿名内部类
          new Thread(new Runnable() {
              @Override
              public void run() {
                  System.out.println("多线程启动了");
              }
          }).start();
          //lambda表达式
          new Thread(() -> {
                  System.out.println("多线程启动了");
          }).start();
      }
  }

函数式编程思想概述

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

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

二、Lambda表达式的标准格式

格式：
(形式参数) -> {代码块}（这一个整体返回的是你要实现接口的实现类）
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
组成Lambda表达式的三要素：
- 形式参数，箭头，代码块

三、Lambda表达式练习1（抽象方法无参无返回值）

Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习描述
无参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
- 定义一个测试类(EatableDemo)，在测试类中提供两个方法
  - 一个方法是：useEatable(Eatable e)
  - 一个方法是主方法，在主方法中调用useEatable方法

[Java] 纯文本查看 复制代码

package lambdatest1;
  
  public interface Eatable {
      void eat();
  }
  package lambdatest1;
  
  public class EatableImp implements Eatable {
      @Override
      public void eat() {
          System.out.println("均衡饮食");
      }
  }
  package lambdatest1;
  
  public class EatableTest {
      public static void main(String[] args) {
          //用实现类的方式，来调用接口的方法
          Eatable e = new EatableImp();
          getEatable(e);
          //用匿名内部类的方式，来调用接口的方法
          getEatable(new Eatable() {
              @Override
              public void eat() {
                  System.out.println("均衡饮食");
              }
          });
          //用Lambda表达式的方式，来调用接口方法，
          // Lambda表达式只能调用接口，并且这个接口只能有一个抽象方法
          getEatable(() -> {
              System.out.println("均衡饮食");
          });
      }
      public static void getEatable(Eatable e){
          e.eat();
      }
  }

四、Lambda表达式练习2（抽象方法带参无返回值）

练习描述
有参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
- 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
  - 一个方法是：useFlyable(Flyable f)
  - 一个方法是主方法，在主方法中调用useFlyable方法练习描述
    有参无返回值抽象方法的练习
  - 操作步骤
    - 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
    - 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
      - 一个方法是：useFlyable(Flyable f)
      - 一个方法是主方法，在主方法中调用useFlyable方法

[Java] 纯文本查看 复制代码

package lambdaTest2;
  
  public interface Flyable {
      void fly(String s);
  }
  package lambdaTest2;
  
  public class FlyTest {
      public static void main(String[] args) {
          //匿名内部类
          useFly(new Flyable() {
              @Override
              public void fly(String s) {
                  System.out.println(s);
              }
          },"哈哈");
          System.out.println("========");
          //lambda表达式
          useFly((s) -> {
              System.out.println(s);
          },"哈哈");
      }
      public static void useFly(Flyable f,String s){
          f.fly(s);
      }
  }

五、Lambda表达式练习2（抽象方法带参带返回值）

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

[HTML] 纯文本查看 复制代码

package lambdatest3;
  
  public interface Addable {
      int add(int x,int y);
  }
  package lambdatest3;
  
  public class AddableTest {
      public static void main(String[] args) {
          useAddable((x,y) -> {
              return x+y;
          },2,3);
      }
      public static void useAddable(Addable a,int x,int y){
          int sum = a.add(x, y);
          System.out.println(sum);
      }
  }

六、Lambda表达式的省略模式

省略的规则

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

[Java] 纯文本查看 复制代码

package lambdaTest4;
  
  public interface Addable {
      int add(int x,int y);
  }
  package lambdaTest4;
  
  public interface Flyable {
      void fly(String s);
  }
  package lambdaTest4;
  
  public class LambdaTest {
      public static void main(String[] args) {
          //lambda表达式简写规则：
          //()，里面可以省略数据类型
          /*useFly((s) -> {
              System.out.println(s);
          },"哈哈");*/
          //当()里只有一个参数时，()可以省略
          /*useFly(s -> {
              System.out.println(s);
          },"哈哈");*/
          //当{}方法体内只有一条代码语句，可以把{}省略，还可以省略;(代码语句的;)
  //        useFly(s -> System.out.println(s),"哈哈");
          /*useAdd((x,y) -> {
              return x+y;
          },2,3);*/
          //当{}方法体内只有一条代码语句，可以把{}省略，还可以省略;(代码语句的;)，还可以省略return。
          useAdd((x,y) -> x+y,2,3);
      }
      public static void useAdd(Addable a,int x,int y){
          int sum = a.add(x, y);
          System.out.println(sum);
      }
      public static void useFly(Flyable f,String s){
          f.fly(s);
      }
  }

七、Lambda表达式的注意事项

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
必须有上下文环境，才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口
  Runnable r = () -> System.out.println("Lambda表达式");
- 根据调用方法的参数得知Lambda对应的接口
  new Thread(() -> System.out.println("Lambda表达式")).start();

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

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

九、接口组成更改概述

常量
public static final
抽象方法
public abstract
默认方法(Java 8)
静态方法(Java 8)
私有方法(Java 9)

十、接口中默认方法（被重写，需把default去掉）

格式
public default 返回值类型方法名(参数列表) { }
范例

  public default void show3() {
  }
注意事项
- 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
- public可以省略，default不能省略

十一、接口中静态方法（只能用类名调用）

格式
public static 返回值类型方法名(参数列表) { }
范例

  public static void show() {
  }
注意事项
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略

十二、接口中私有方法（提取其它方法共有功能，只供本类调用）

私有方法产生原因
Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性
定义格式
- 格式1
  private 返回值类型方法名(参数列表) { }
- 范例1
  
    private void show() {
    }
- 格式2
  private static 返回值类型方法名(参数列表) { }
- 范例2
  
    private static void method() {
    }
注意事项
- 默认方法可以调用私有的静态方法和非静态方法
- 静态方法只能调用私有的静态方法

[Java] 纯文本查看 复制代码

 package interfacetest;
  
  public interface MyInterface {
      void show1();
      default void show2(){
          show();
          method();
          System.out.println("show2");
      }
      default void show3(){
          show();
          method();
          System.out.println("show3");
      }
      public static void method1(){
          method();
          System.out.println("method1");
      }
      static void method2(){
          method();
          System.out.println("method2");
      }
      private void show(){
          System.out.println("show");
      }
      private static void method(){
          System.out.println("method");
      }
  }
  package interfacetest;
  
  public class MyInterfaceIml implements MyInterface {
      @Override
      public void show1() {
          System.out.println("Iml show1");
      }
  
      @Override
      public void show3() {
          System.out.println("Iml show3");
      }
  }
  package interfacetest;
  
  public class MyInterfaceTest {
      public static void main(String[] args) {
          MyInterface mi = new MyInterfaceIml();
          mi.show1();
          mi.show2();
          mi.show3();
          MyInterface.method1();
          MyInterface.method2();
      }
  }

十三、体验方法引用

方法引用的出现原因

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要

那我们又是如何使用已经存在的方案的呢？

这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

[Java] 纯文本查看 复制代码

 package methodtrad;
  
  public interface Printable {
      void printString(String s);
  }
  package methodtrad;
  //方法引用，调用引用类的普通方法：对象名::方法名
  public class PrintableTest {
      public static void main(String[] args) {
          //lambda表达式简写
          usePrintable((s)-> System.out.println(s),"哈哈");
          //方法引用，
          /*
          System.out————表示一个字节流对象
          ::————System.out指向引用自己的方法
          println————是System.out的一个方法，用来打印数据，
          System.out::println————把自己的方法println复制给Printable p的printString方法并让printString方法重写
          重写的内容是复制println的方法里面的内容
          并且创建一个Printable接口的实现类对象
          通过usePrintable(System.out::println,"哈哈");
          把这个实现类对象传递到这个方法的第一个参数
           */
          usePrintable(System.out::println,"哈哈");
      }
      public static void usePrintable(Printable p,String s){
          p.printString(s);
      }
  }

十四、方法引用符

方法引用符
:: 该符号为引用运算符，而它所在的表达式被称为方法引用
推导与省略
- 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
- 如果使用方法引用，也是同样可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟（要求相同）

十五、引用类方法

引用类方法，其实就是引用类的静态方法

格式
类名::静态方法
范例
Integer::parseInt
Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据
练习描述
- 定义一个接口(Converter)，里面定义一个抽象方法 int convert(String s);
- 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
  - 一个方法是：useConverter(Converter c)
  - 一个方法是主方法，在主方法中调用useConverter方法

[Java] 纯文本查看 复制代码

package methodtrad1;
  
  public interface Converter {
      int convert(String s);
  }
  package methodtrad1;
  //方法引用，调用引用类的静态方法
  public class ConverterTest {
      public static void main(String[] args) {
          useConverter((s) -> Integer.parseInt(s),"100");
          //通过方法引用，引用静态方法：类名::方法名
          useConverter(Integer::parseInt,"100");
      }
      public static void useConverter(Converter c,String s){
          int num = c.convert(s);
          System.out.println(num);
      }
  }

十六、引用对象的实例方法

[Java] 纯文本查看 复制代码

 package methodtrad2;
  
  public class PrintString {
      public void printUpper(String s){
          String str = s.toUpperCase();
          System.out.println(str);
      }
  }
  package methodtrad2;
  
  public interface Printable {
      void print(String s);
  }
  package methodtrad2;
  //方法引用，调用引用类的不同方法：对象名::方法名
  public class PrintableTest {
      public static void main(String[] args) {
          PrintString ps = new PrintString();
          usePrintable(s -> ps.printUpper(s),"哈哈");
          usePrintable(ps::printUpper,"哈哈");
      }
      public static void usePrintable(Printable p,String s){
          p.print(s);
      }
  }

十七、引用类的实例方法

[Java] 纯文本查看 复制代码

 package methodtrad3;
  
  public interface MyString {
      String mySubString(String s,int start,int end);
  }
  package methodtrad3;
  //方法引用，如果非要调用引用类的非静态方法，
  /*
  1、传入的第一个参数一定要是这个引用类的对象
  2、例如 ：String::substring,"hello",1,3
   */
  public class MyStringTest {
      public static void main(String[] args) {
          useMyString((s,start,end) -> s.substring(start,end),"hello",1,3);
          useMyString(String::substring,"hello",1,3);
      }
      public static void useMyString(MyString ms,String s,int start,int end){
          String s1 = ms.mySubString(s,start,end);
          System.out.println(s1);
      }
  }

十八、引用构造器

[Java] 纯文本查看 复制代码

package methodtrad4;
  
  public class Student {
      private String name;
      private int age;
  
      public Student() {
      }
  
      public Student(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;
      }
  
      @Override
      public String toString() {
          return "Student{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  '}';
      }
  }  package methodtrad4;
  
  public interface StudentBuilder {
      Student build(String name,int age);
  }
  package methodtrad4;
  //方法引用，调用引用类的构造方法（构造器）类名::new————表示调用构造方法(创建一个对象)
  public class StudentbuilderTest {
      public static void main(String[] args) {
          useStudentBuilder((name, age) -> new Student(name,age),"张三",20);
          useStudentBuilder(Student::new,"张三",20);
      }
      public static void useStudentBuilder(StudentBuilder sb,String name,int age){
          Student s = sb.build(name, age);
          System.out.println(s);
      }
  }

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] day13学习总结

0 个回复