Java笔记—JDK新特性

1、Lambda表达式

1.1、函数式编程思想概述

1.2、体验Lambda表达式

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表达式

1.4、Lambda表达式的练习

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表达式使用—传递参数

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表达式使用—有返回值

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表达式的省略模式

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表达式注意事项

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表达式和匿名类的区别

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、接口组成更新概述

2.2、接口中的默认方法

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、接口中的静态方法

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、接口中的私有方法

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、体验方法引用

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、方法引用符

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表达式支持的方法引用

3.4、引用类方法

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、引用对象的实例方法

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、引用类的实例方法

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、引用构造器

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