Java基础（28）之方法引用

1. 方法引用

Java8新特征之方法引用

1.1 体验方法引用

代码示例：

需求：

• 1:定义一个接口(Printable):里面定义一个抽象方法: void printString(String s);
• 2:定义一个测试类(PrintableDemo),在测试类中提供两个方法
  一个方法是: usePrintable(Printable p)
  一个方法是主方法，在主方法中调用usePrintable方法

接口：

//1:定义一个接口(Printable):里面定义一个抽象方法: void printString(String s);
public interface Printable {
	void printString(String s);
}

测试类：

//2:定义一个测试类(PrintableDemo),在测试类中提供两个方法
//一个方法是: usePrintable(Printable p)
//一个方法是主方法，在主方法中调用usePrintable方法
public class PrintableDemo {
	public static void main(String[] args) {
		//Lambda表达式省略参数类型，是因为方法中有参数类型这样Lambda就可以推导出参数类型。
		usePrintable(s -> System.out.println(s));

		// 使用方法一引用，方法引用符::
		//方法引用和Lambda一样都是推导出了参数类型，然后将参数放入println中。
		usePrintable(System.out::println);
	}

	private static void usePrintable(Printable p) {
		p.printString("爱生活爱java");
	}

}

运行结果：

1.2 方法引用符

代码示例：
需求:

• 1:定义一个接口(Printable):里面定义一个抽象方法: void printInt(int i);
• 2:定义一一个测试类(PrintableDemo),在测试类中提供两个方法
  一个方法是: usePrintable(Printable p)
  一个方法是主方法，在主方法中调用usePrintable方法

定义接口：

//1:定义一个接口(Printable):里面定义一个抽象方法: void printInt(int i);
public interface Printable {
	void printInt(int i);
}

定义测试类：

//2:定义一一个测试类(PrintableDemo),在测试类中提供两个方法
//一个方法是: usePrintable(Printable p)
//一个方法是主方法，在主方法中调用usePrintable方法
public class PrintableDemo {
	private static void usePrintable(Printable p) {
		p.printInt(666);
	}

	public static void main(String[] args) {
		//Lambda表达式
		usePrintable(i -> System.out.println(i));
		
		//方法引用
		usePrintable(System.out::println);
	}
}

运行结果：

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

1.4 引用类方法

代码示例：

定义接口：

//1:定义一个接口(Converter)，里面定义一个抽象方法:
//int convert(String s);
public interface Converter {
	int convert(String s);
}

定义测试类：

//2:定义一一个测试类(ConverterDemo),在测试类中提供两个方法
//一个方法是: useConverter(Converter c)
//一个方法是主方法，在主方法中调用useConverter方法
public class ConverterDemo {
	private static void useConverter(Converter c) {
		int number = c.convert("666");
		System.out.println(number);
	}

	public static void main(String[] args) {
		// Lambda表达式
		// 带有返回值类型的也可以省略
		useConverter(s -> Integer.parseInt(s));

		// 引用类方法，采用引用类方法格式
		useConverter(Integer::parseInt);

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

	}
}

运行结果：

1.5 引用对象的实例方法

代码示例：

定义类：

//1:定义一个类(PrintString)，里面定义一个方法
//		public void printUpper(String s): 把字符串参数变成大写的数据，然后在控制台输出
public class PrintString {
	public void printUpper(String s) {
		String result = s.toUpperCase();
		System.out.println(result);
	}
}

定义接口：

//2:定义一个接口(Printer)，里面定义一个抽象方法
//void printUpperCase(String s);
public interface Printer {
	void printUpperCase(String s);
}

定义测试类：

//3:定义一个测试类(PrinterDemo)，在测试类中提供两个方法
//一个方法是: usePrinter(Printer p)
//一个方法是主方法，在主方法中调用usePrinter方法
public class PrinterDemo {
	private static void usePrinter(Printer p) {
		p.printUpperCase("HelloWordl");
	}

	public static void main(String[] args) {
		// Lambda表达式，最简化模式
		usePrinter(s -> System.out.println(s.toUpperCase()));

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

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

运行结果：

1.6 引用类的实例方法

代码示例：

定义接口：

//1:定义一个接口(MyString)，里面定义一个抽象方法: .
//String mySubString(String s,int x, int y);
public interface MyString {
	String mySubString(String s, int x, int y);
}

定义测试类：

//2:定义一个测试类(MyStringDemo),在测试类中提供两个方法
//一个方法是: useMyString(MyString my)
//一个方法是主方法，在主方法中调用useMyString方法
public class MyStringDemo {
	private static void useMyString(MyString my) {
		String s = my.mySubString("HelloWorld", 2, 5);
		System.out.println(s);
	}

	public static void main(String[] args) {
		// Lambda表达式，最简模式
		useMyString((s, x, y) -> s.substring(x, y));

		// 引用类的实例方法
		useMyString(String::substring);

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

	}
}

运行结果：

1.7 引用构造器（构造方法）

代码示例：

定义类Student

//1:定义一个类(Student)，里面有两个成员变量(name, age)
//并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
public class Student {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

定义接口：

//2:定义一个接口(StudentBuilder)，里面定义一个抽象方法
//Student build(String name, int age); 
public interface StudentBuilder {
	Student build(String name, int age);
}

定义测试类：

//3:定义一个测试类(StudentDemo),在测试类中提供两个方法
//一个方法是: useStudentBuilder(StudentBuilder s)
//一个方法是主方法，在主方法中调用useStudentBuilder方法
public class StudentDemo {

	private static void useStudentBuilder(StudentBuilder sb) {
		Student s = sb.build("林青霞", 20);
		System.out.println(s.getName() + "," + s.getAge());
	}

	public static void main(String[] args) {
		// Lambda表达式
		useStudentBuilder((name, age) -> new Student(name, age));

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

		// L ambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
	}

}

运行结果：