Java笔记—JDK新特性

2021-01-31

Java 笔记—JDK 新特性

1、Lambda 表达式

1.1、函数式编程思想概述

image.png

1.2、体验 Lambda 表达式

image.png

import java.util.concurrent.TransferQueue;
public class LambdaDemo {
    public static void main(String[] args) {
        //采用实现类方式实现需求
        MyRunnable my=new MyRunnable();
        Thread t=new Thread(my);
        t.start();
        //匿名内部类的方式改进
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程2启动了");
            }
        }).start();
        //Lambda表达式方式改进
        new Thread(()->{
            System.out.println("多线程程序启动了");
        }).start();
    }
}

1.3、Lambda 表达式

image.png

image.png

1.4、Lambda 表达式的练习

image.png

Eatable 接口

public interface Eatable {
    //有且仅有一个抽象方法
    void eat();
}

EatableIml 类实现接口

public class EatableImpl implements  Eatable{
    @Override
    public void eat() {
        System.out.println("一天一个苹果 李生远离我");
    }
}

EatableDemo 测试类

public class EatableDemo {
    public static void main(String[] args) {
        //主方法中调用useEable方法
        Eatable e=new EatableImpl();
        useEable(e);
        //匿名内部类
        useEable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一个苹果,医生远离我");
            }
        });
        //Lambda表达式
        useEable(()->{
            System.out.println("一天一个苹果,医生远离我");
        });
    }
    private static void useEable(Eatable e){
        e.eat();
    }
}

1.5、Lambda 表达式使用—传递参数

image.png

public interface Flyable {
    void fly(String s);
}
import javax.crypto.spec.PSource;
public class FlayableDemo {
    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("风和日丽");
    }
}

1.6、Lambda 表达式使用—有返回值

image.png

Addable 类

public interface Addable {
    int add(int a,int b);
}

FlayableDemo 类

public class FlayableDemo {
    public static void main(String[] args) {
        //主方法中调用useFlyable
        //匿名内部类
        useAddable(new Addable() {
            @Override
            public int add(int a,int b) {
                return a+b;
            }
        });
        System.out.println("---------");
        //Lambda  用Lambda实现接口
        useAddable((int a,int b)->{
            return a+b;
        });
    }
    private static void useAddable(Addable a){
        int sum= a.add(1,2);
        System.out.println(sum);
    }
}

总结

Lambda 可以用来实现抽象类或者抽象接口的一种方法

1.7、Lambda 表达式的省略模式

image.png

Addable 接口

public interface Addable {
    int add(int a,int b);
}

Flyable 接口

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

测试类

import java.util.concurrent.TransferQueue;
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((a,b)->a+b);
    }
    private static  void useFlyable(Flyable f) {
        f.fly("飞翔");
    }
    private static void useAddable(Addable a) {
        int sum=a.add(10,20);
        System.out.println(sum);
    }
}

1.8、Lambda 表达式注意事项

image.png

Inter 接口

public interface Inter {
    void show();
}

LambdaDemo 类

public class LambdaDemo {
    public static void main(String[] args) {
        //使用Lambda必须有接口,并有且仅有一个
        useInter(()-> System.out.println("好好学习天天向上"));
        //使用Lambda必须有上下文环境,才能推导出Lambda对应的接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        }).start();
        Runnable r=()-> System.out.println("Lambda表达式");
        new Thread(r).start();
        new Thread(()-> System.out.println("Lambda表达式2")).start();
    }
    private static void useInter(Inter i) {
        i.show();
    }
}

1.9、Lambda 表达式和匿名类的区别

image.png

Inter 接口

public interface Inter {
    void show();
}

Student 类

public class Student {
    public  void study(){
        System.out.println("爱我小波波");
    }
}

Animal 抽象类

public abstract class Animal {
    public abstract void method();
}

LambdaDemo 测试类

public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });
        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });
        useStudent(new Student(){
            @Override
            public void study() {
                System.out.println("具体类");
            }
        });
        //Lambda表达式
        useInter(()-> System.out.println("接口2"));
      //  useAnimal(()-> System.out.println("抽象类2"));
      //  useStudent(()-> System.out.println("具体类"));
    }
    private static void useInter(Inter i) {
        i.show();
    }
    private static void useAnimal(Animal i) {
        i.method();
    }
    private static void useStudent(Student i) {
        i.study();
    }
}

2. 接口新特性

2.1、接口组成更新概述

image.png

2.2、接口中的默认方法

image.png

Inter 接口

public interface Inter {
    void show1();
    void show2();
    default void show3() {
        System.out.println("show3");
    }
}

Inter2 接口

public interface Inter2 extends Inter{
    void show3();
}

MyinterfaceDemo 测试类

public class MyinterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        Inter i=new MyInterfacteImplOne();
        i.show1();
        i.show2();
        i.show3();
    }
}

MyInterfacteImplOne 实现类

public class MyInterfacteImplOne implements Inter{
    @Override
    public void show1() {
        System.out.println("Two show1");
    }
    @Override
    public void show2() {
        System.out.println("Two show2");
    }
    @Override
    public void show3() {
        System.out.println("Two show3");
    }
}

MyInterfacteImplTwo 实现类

public class MyInterfacteImplTwo implements Inter{
    @Override
    public void show1() {
        System.out.println("show one1");
    }
    @Override
    public void show2() {
        System.out.println("show one2");
    }
}

2.3、接口中的静态方法

image.png

Inter

public interface Inter {
    void show();
    default void method() {
        System.out.println("默认");
    }
    public static void test(){
        System.out.println("静态");
    }
}

Inter2

public interface Inter2 {
    public static void test() {
        System.out.println("执行吧");
    }
}

MyInterfacteImplOne

public class MyInterfacteImplOne implements Inter,Inter2{
    @Override
    public void show() {
        System.out.println("Two show1");
    }
}

MyinterfaceDemo

public class MyinterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        Inter i=new MyInterfacteImplOne();
        i.show();
        i.method();
      //  i.test();
        Inter.test();
        Inter2.test();
    }
}

2.4、接口中的私有方法

image.png

Inter 接口

public interface Inter {
    default void show1() {
        System.out.println("默认1");
        show();
        System.out.println("默认1");
    }
    default void show2() {
        System.out.println("默认2");
        show();
        System.out.println("默认2");
    }
    private void show(){
        System.out.println(1);
    }
    static void method1(){
        System.out.println("静态1");
        Inter.method();
        System.out.println("静态1");
    }
    static void method2(){
        System.out.println("静态2");
        Inter.method();
        System.out.println("静态2");
    }
    private static method() {
        System.out.println(1);
    }
}

MyinterfaceDemo 测试类

public class MyinterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        Inter i=new MyInterfacteImplOne();
        i.show1();
        System.out.println("-------");
        i.show2();
        System.out.println("-------");
        Inter.method1();
        System.out.println("-------");
        Inter.method2();
    }
}
public class MyInterfacteImplOne implements Inter{
}

3、方法引用

3.1、体验方法引用

image.png

Printable 类

public interface Printable {
    void printString(String s);
}

MyinterfaceDemo 类

public class MyinterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        usePrintable(s-> System.out.println(s));
        //方法引用  ::
        usePrintable(System.out::println);
        //可推导的就是可省略的
    }
    private static void usePrintable(Printable p) {
        p.printString("小波波");
    }
}

3.2、方法引用符

image.png

Printable

public interface Printable {
    void printString(int i);
}

MyinterfaceDemo

public class MyinterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        usePrintable(i-> System.out.println(i));
        //方法引用  ::
        usePrintable(System.out::println);
        //可推导的就是可省略的
    }
    private static void usePrintable(Printable p) {
        p.printString(666);
    }
}

3.3 Lambda 表达式支持的方法引用

image.png

3.4、引用类方法

image.png

Converter 类

public interface Converter {
    int convert(String s);
}

MyinterfaceDemo 类

public class MyinterfaceDemo {
    public static void main(String[] args) {
        usePrintable(s ->Integer.parseInt(s));
        //引用类方法改进
        usePrintable(Integer::parseInt);
        //Lambda表达式被类方法替代的时候,它的形参数全部传递给静态方法作参数
        
    }
    private static void usePrintable(Converter p) {
        int number = p.convert("6666");
        System.out.println(number);
    }
}

3.5、引用对象的实例方法

image.png

Printer

public interface Printer {
    public void printUpper(String s);
}

PrintString

import java.util.Locale;
public class PrintString {
    public void printUpper(String s) {
        String result=s.toUpperCase();
        System.out.println(result);
    }
}

PrinterDemo

public class PrinterDemo {
    public static void main(String[] args) {
        usePrinter((String s)->{
            System.out.println(s.toUpperCase());
        });
        usePrinter(s->System.out.println(s.toUpperCase()));
        //方法引用  对象的实例方法
        PrintString ps=new PrintString();
        usePrinter(ps::printUpper);
        //Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数
    }
    private static void usePrinter(Printer p) {
        p.printUpper("HelloWorld");
    }
}

3.6、引用类的实例方法

image.png

MyString

public interface MyString {
    String  mySubString(String s,int x,int y);
}

PrinterDemo

public class PrinterDemo {
    public static void main(String[] args) {
        useMyString((String s, int x,int y)->{
            return s.substring(x,y);
        });
        useMyString((String s, int x,int y)->s.substring(x,y));
        //方法引用类中的实例方法
        useMyString(String::substring);
        //Lambda表达式被类的实例方法替代时
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数
    }
    private static void useMyString(MyString p) {
        String s=p.mySubString("HelloWorld",2,5);
        System.out.println(s);
    }
}

省略的时候若只包含一个语句这大括号和分号可省略

参数行可以省略

3.7、引用构造器

image.png

Student

package UIDesign;

public class Student {
    private String name;
    private int age;

    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 void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

StudentBuilder

import UIDesign.Student;
public interface StudentBuilder {
    Student build(String name, int age);
}

PrinterDemo

import UIDesign.Student;

public class PrinterDemo {
    public static void main(String[] args) {

        useStudentBuilder((String name,int age)->{
            return new Student(name,age);
        });
        useStudentBuilder((name, age) -> new Student(name,age));

        //方法引用 构造器
        useStudentBuilder(Student::new);

        //Lambda表达式被构造器替代的时候,它的形式参数全部传递给该方法作为参数

    }
    private static void useStudentBuilder(StudentBuilder sb) {
        Student s=sb.build("小波",18);
        System.out.println(s.getName()+" "+s.getAge());
    }
}


标题:Java笔记—JDK新特性
作者:xiaob0
地址:https://xiaobo.net.cn/articles/2021/01/31/1612085069759.html