方法引用

接口组成更新

接口组成:常量，抽象方法，java8之后加入了默认方法和静态方法，java9后加入了私有方法

练习1

定义一个接口MyInterface,里面有两个抽象方法：void show1();void show2();

新建一个类，实现接口，重写接口中的所有抽象方法MyInterfaceImplOne();MyInterfacelmpTwo();

定义一个测试类，MyInterfaceDemo,在主方法中，按照多态的方式创建对象并使用

接口中的默认方法

可以使用默认得方法实现接口的升级

public default void show(){

}

public可以省略，default不能省略

接口中的静态方法

public static void test(){

}

静态方法只能被接口调用

接口中的静态方法只能通过接口名调用，不能通过类名或者对象名调用

public可以省略，static不能省略

接口中的私有方法

java8允许在接口中定义带方法体的默认方法和静态方法

当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必须考虑将这段实现代码抽取出一个共性方法

private 返回值类型 方法名(参数列表) private void show()

private static 返回值类型 方法名(参数列表) private static void method()

需求

定义一个接口Inter,里面有四个方法，两个默认方法，两个静态方法

default void show1(){}
default void show2(){}
static void method1(){}
static void method2(){}

定义接口的一个实现类InterImpl

定义测试类：InterDemo,在方法中，按照多态的方式创建对象并使用

静态方法可以调用静态私有方法

默认方法可以调用静态静态方法

方法引用

通过方法引用使用已经存在的方案

需求

定义一个接口(Printable),定义一个抽象方法:void printString(String s)

定义一个测试类(PrintableDemo),在测试类中提供两个方法：一个方法是usePrintable(Printable p);一个方法是主方法，在主方法中调用usePrintable方法

public class PrintableDemo {
    public static void usePrintable(Printable p){
        p.printString("eeee");
    }
    public static void main(String[] args){
//        usePrintable(s -> System.out.println(s));
        usePrintable(System.out::println);
    }
}

方法引用符号

usePrintable(System.out::println);

可推导的就是可以引用的

::为引用运算符，所在的表达式被称为方法引用

如果使用lamada,根据可推导就是可省略的原则，无需指定参数类型，也无需指定重载形式，都将被自动推导

方法引用也可以根据上下文推导

lamada表达式支持的方法引用

常见的引用方式：引用类方法，引用对象的实例方法，引用类的实例方法，引用构造器

引用类方法

引用类的静态方法

类名::静态方法

Integer::parseInt

练习

定义一个接口（Converter），里面定义一个抽象方法int convert(String s)

定义一个测试类(ConverterDemo),在测试类中提供两个方法，一个方法是：useConverter(Converter c),一个方法是主方法，在主方法中调用useConverter方法

public static void main(String[] args){
        useConverter(s->Integer.parseInt(s));
//        引用类方法
        useConverter(Integer::parseInt);
//        lamada表达式被类方法替代时，它的形式参数全部传递给静态方法作为参数
        
    }

引用对象的实例方法

引用类中的成员方法

对象::成员方法

练习

定义一个类（PrintString）,里面定义一个方法

public void printUpper(String s):把字符串参数变成大写的数据，然后在控制台输出

定义一个接口（Printer）,里面定义一个抽象方法

void printUpperCase(String s)

定义一个测试类（PrinterDemo）,在测试类中提供两个方法

一个方法是：usePrinter(Printer p),一个方法是主方法，在主方法中调用usePrinter方法

public class PrinterDemo {
    public static void usePrinter(Printer p){
        p.printUpperCase("Holle");
    }
    public static void main(String[] args){
        //lamada表达式
//        usePrinter((String s)->{
//            String result = s.toUpperCase();
//            System.out.println(result);
//        });

        usePrinter(s-> System.out.println(s.toUpperCase()));

        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);

//        lamada表达式被对象的实例方法替代的对象，它的形式参数全部传递给该方法作为参数
        
    }

}

引用类的实例方法

引用类中的成员方法

类名::成员方法

练习

定义一个接口(MyString),里面定义一个抽象方法

String mySubString(String s,int x,int y);

定义一个测试类(MyStringDemo),在测试类中提供两个方法

一个方法是：useMyString(MyString my)

一个方法是主方法，在主方法中调用useMyString方法

public class MyStringDemo {
    public static void main(String[] args){
        useMyString((String s,int x,int y)->{
            return s.substring(x,y);
        });
        useMyString((s,x,y)->s.substring(x,y));
        //引用类的实例方法
        useMyString(String::substring);
        //lamada表达式被类的实例方法替代的时候
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数

    }
    public static void useMyString(MyString my){
        String s = my.mySubString("hellorot",2,5);
        System.out.println(s);
    }
}

引用构造器

引用构造方法

类名::new

练习

定义一个类(Student),里面有两个成员变量（name,age）

并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法

定义一个接口(StudentBuilder),里面定义一个抽象方法

Student build(String name,int age)

定义一个测试类(StudentDemo),在测试类中提供两个方法

一个方法是：useStudentBuilder(StudentBuilder s)

一个方法是主方法，在主方法中调用useStudentBuilder方法

public class StudentDemo {
    public static void useStudentBuilder(StudentBuilder s){
        Student sb = s.build("tangtang",90);
        System.out.println(sb.getName()+","+sb.getAge());
    }
    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);
//        lamada表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
    }
}