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表达式被构造器替代的时候,所有的形式参数全部传递构造方法作为参数

你可能感兴趣的:(从零开始Java学习,java,学习,笔记)