Java学习笔记42——方法引用

方法引用

方法引用体验

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

public class PrintableDemo {
    public static void main(String[] args) {
        usePrintable((String s)->{//lamda表达式
            System.out.println(s);
        });

        usePrintable(s->System.out.println(s));//简化

        //方法引用符：：
        usePrintable(System.out::println);//可推导的就是可省略的
    }
    private static void usePrintable(Printable p){
        p.pringstring("你好Java!");
    }
}

lamda表达式可参考lamda表达式详解

方法引用符

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

回顾一下

• Lambda表达式：usePrintable(s->Sysout.out.println(s))
  分析：拿到参数s之后，通过lambda表达式，传递给System.out.println方法去处理
• 方法引用：usePrintable(System.out::println)
  分析：直接使用System.out中的println方法来取代Lambda，代码更简洁

推导与省略

• 如果使用Lambda,那么根据“可推导就是可省略的”原则，无需指定参数类型，也无需指定重载形式，他们都将被自动推导
• 如果使用方法引用，也是同样可以根据上下文进行推导

常见的引用方式

引用类方法

引用类方法就是引用类的静态方法

• 格式： 类名：：静态方法
• 范例： Integer：：parseInt

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

public class ConverterDemo{
	public static void main(String[] args){
		useConverter((String s)->{
			return Integer.parseInt(s); 
		});

		useConverter(s->Integer.parseInt(s));
		//引用类方法
		useConverter(Integer::parseInt);
	}
	private static void useConverter(Converter c){
		int num=c.convert("666");
		System.out.println(num);
	}
}

lambda表达式被类方法替代的时候，形式参数全部传递给静态方法作为参数

引用对象的实例方法

**引用对象的实例方法，实质上是引用类中的成员方法 **

• 格式 对象：：成员方法
• 范例 HelloWorld：：toUpperCase

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

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

public class PrintUpperDemo{
	public static void main(String[] args){
		usePrinter((String s)->{
			String result = s.toUpperCase();
			System.out.priintln(result);
		});

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

		//引用对象实例
		PrintString ps=new PrintString();
		usePrinter(ps::printUpper);
	}
	private static usePrinter(Printer p){
		p.printUpperCase("Hello");
	}
}

lambda表达式被对象的实例方法替代的时候，形式参数全部传递给该方法作为参数

引用类的实例方法

**引用对象的实例方法，实质上是引用类中的成员方法 **

• 格式 类名：：成员方法
• 范例 String：：substring

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

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

		useMySting(String::substring);
		
	} 
	private static useMyString(MyString my){
		String s=my.mySubString("HelloWorld",2,5);
		System.out.println(s);
	}
}

lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数

引用构造器

**引用构造器，实质上是引用构造方法 **

• 格式 类名：：new
• 范例 Student：：new

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

	}
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
}

public interface StudentBuilder{
	Student build(Stringname,int age);
}

public class StudentDemo{
	public static void main(String[] args){
		
		useStudentBulilder((String name,int age)->{
			Student s=new Student(name,age);
			return s;
		})
		useStudentBulilder((name,age)->new Student(name,age));

		//引用构造器
		useStudentBulilder(Student::new);
	}
	private static void useStudentBuilder(StudentBuilder sb){
		Student s=sb.build("R","18");
		System.out.println(s.getName()+","+s.getAge());
	}
}

lambda表达式被构造器替代的时候，所有的形式参数全部传递构造方法作为参数