核心技术：接口、lambda表达式与内部类 - 版本历史

Eijux：/* 代理 */

2022-11-05T01:50:16Z

代理

←上一版本		2022年11月5日 (六) 09:50的版本
第765行：		第765行：

	== 代理 ==		== 代理 ==
			参考：<big>'''[[动态代理、CGLIB 与切面编程]]'''</big>

			如果要为一个没有实现接口的类生成动态代理类，那么可以使用 '''CGLIB''' 库。

	代理（Proxy）：利用代理可以在'''运行时，创建一个实现了一组给定接口的新类'''。（动态代理）		代理（Proxy）：利用代理可以在'''运行时，创建一个实现了一组给定接口的新类'''。（动态代理）
	*（静态代理：通过聚合、组合的方式，对需要的类或接口进行前后处理，提供新的调用）		*（静态代理：通过聚合、组合的方式，对需要的类或接口进行前后处理，提供新的调用）
	* 代理类可以在运行时创建全新的类；		* 代理类可以在运行时创建全新的类；
	* 只有在编译时无法确定需要实现那个接口时才有必要使用。		* 只有在编译时无法确定需要实现那个接口时才有必要使用。


	~~参考 Spring 的 AOP（Aspect Oriented Programming）~~

	=== 创建一个代理对象 ===		=== 创建一个代理对象 ===

Eijux：/* 创建一个代理对象 */

2022-11-05T01:48:28Z

创建一个代理对象

←上一版本		2022年11月5日 (六) 09:48的版本
第775行：		第775行：
	=== 创建一个代理对象 ===		=== 创建一个代理对象 ===
	要想创建一个代理对象，需要使用'''Proxy类'''的'''newProxylnstance'''方法。这个方法有三个参数：		要想创建一个代理对象，需要使用'''Proxy类'''的'''newProxylnstance'''方法。这个方法有三个参数：
	# ~~类加栽器（“ClassLoader”）：用~~ null 表示使用默认的类加载器；（有关类加载器，查阅：卷2第9章）		# 类加载器（“ClassLoader”）：用 null 表示使用默认的类加载器；（有关类加载器，查阅：卷2第9章）
	# ~~接口数组（“ClassLoader”）：一个Class对象数组，每个元素都是需要实现的接口。~~		# 接口数组（“Class[]”）：一个Class对象数组，每个元素都是需要实现的接口。
	# 调用处理器（“InvocationHandler”）：定义对代理类方法的处理。		# 调用处理器（“InvocationHandler”）：定义对代理类方法的处理。
	~~#: 调用处理器需要实现InvocationHandler接口（InvocationHandler 接口只有一个方法），在'''invoke'''对代理实例的方法进行处理；~~


	* ~~如果要为一个没有实现接口的类生成动态代理类，那么可以使用~~'''~~CGLIB~~'''库（'''~~[[动态代理、CGLIB 与切面编程]]~~'''）		* 调用处理器需要实现 InvocationHandler 接口：仅有一个方法 '''invoke'''，用于对代理实例的方法进行处理：
			*: <syntaxhighlight lang="Java" highlight="">
			Object invoke(Object proxy, Method method, Object[] args)
	~~代理类属于在运行时定义的类（名字如“$Proxy0”~~)，这个类实现了给定的接口（如“Comparable”），它的方法（如“compareTo”）调用了代理对象处理器的“invoke”方法。		</syntaxhighlight>
			* 代理类属于在运行时定义的类（名字如“'''$Proxy0'''”)，这个类实现了给定的接口（如“Comparable”），它的方法（如“compareTo”）调用了代理对象处理器的“invoke”方法。

	==== 示例 ====		==== 示例 ====

Eijux：/* 再谈 Comparator */

2022-04-22T16:55:44Z

再谈 Comparator

←上一版本		2022年4月23日 (六) 00:55的版本
第530行：		第530行：

	=== 再谈 Comparator ===		=== 再谈 Comparator ===
			Comparator 接口包含很多方便的静态方法来创建比较器。这些方法可以用于 lambda 表达式或方法引用。


			以下的 comparing()、thenComparing()、nullsFirst()、nullsLast()、naturalOrder()、reverseOrder() 等方法，返回的都是一个'''比较器'''（'''Comparator<T>'''）。

			# 静态 '''comparing''' 方法取一个“键提取器” 函数，它将类型 T 映射为一个可比较的类型（如 String）。对要比较的对象应用这个函数，然后对返回的键完成比较。
			#: 例如：假设有一个 Person 对象数组，可以如下按名字对这些对象排序：
			#: <syntaxhighlight lang="java" highlight="">
			Arrays.sort(peop1e, Comparator.comparing(Person::getName));
			</syntaxhighlight>
			# 可以把比较器与 '''thenComparing''' 方法串起来，如果第一次比较相同则使用下一个比较器。
			#: 例如：
			#: <syntaxhighlight lang="java" highlight="">
			Arrays.sort(peop1e,
			Comparator.comparing(Person::getLastName)
			.thenComparing(Person::ge FirstName));
			</syntaxhighlight>
			# 可以为 comparing 和 thenComparing 方法提取的键指定一个比较器。
			#: 例如：可以如下根据人名长度完成排序：
			#: <syntaxhighlight lang="java" highlight="">
			Arrays.sort(peop1e, Comparator.comparing(Person::getName,
			(s, t) -> Integer.compare(s.length(), t.length())));
			</syntaxhighlight>
			# comparing 和 thenComparing 方法都有变体形式，可以避免 int、long 或 double 值的装箱。
			#: 如上例：根据人名长度完成排序，还有一种更容易的做法：
			#: <syntaxhighlight lang="java" highlight="">
			Arrays.sort(people, Camparator.comparingInt (p -> p.getName().1ength()));
			</syntaxhighlight>
			# 如果键函数可以返回 null，可能就要用到 '''nullsFirst''' 和 '''nullsLast''' 适配器。这些静态方法会修改现有的比较器，从而在遇到 null 值时不会抛出异常，而是将这个值标记为小于或大于正常值。
			#* “nullsFirst”：null < non-null，从小到大时 null 在前；
			#* “nullsLast”：null > non-null，从小到大时 null 在后；
			#: 例如，假设一个人没有中名时 getMiddleName 会返回一个 null，就可以使用
			#: <syntaxhighlight lang="java" highlight="">
			Comparator.comparing(Person::getMiddleName(), Comparator.nullsFirst( ... ))
			</syntaxhighlight>
			#* nullsFirst、nullsLast 方法需要一个比较器，在这里就是比较两个字符串的比较器。
			# '''naturalOrder''' 方法可以为任何实现了 Comparable 的类建立一个比较器。【自然排序，实现 Comparable 接口时方法作为比较器】
			#* 注意 naturalOrder 的类型可以推导得出。
			#: 如上例：可以按可能为 null 的中名进行排序，下面是一个完整的调用：
			#: <syntaxhighlight lang="java" highlight="">
			Arrays.sort(peop1e, comparing(Person::getMiddleNarne, nullsFirst(naturalOrder())))；
			</syntaxhighlight>
			# 静态 '''reverseOrder''' 方法会提供自然顺序（naturalOrder）的逆序。
			#* 要让比较器逆序比较，可以使用 '''reversed''' 实例方法。
			#*: 例如：<syntaxhighlight lang="java" inline>naturalOrder().reversed()</syntaxhighlight> 等同于 <syntaxhighlight lang="java" inline>reverseOrder()</syntaxhighlight> 。

	== 内部类 ==		== 内部类 ==

Eijux：/* 函数式接口 */

2022-04-22T15:48:52Z

函数式接口

←上一版本		2022年4月22日 (五) 23:48的版本
第289行：		第289行：


	~~设计函数式接口时，可以使用“~~'''@FunctionalInterface'''~~”注解来标记这个接口。这样做：~~		设计函数式接口时，可以使用<big>“'''<span style="color: green">@FunctionalInterface</span>'''”</big>注解来标记这个接口。这样做：
	# 当接口不符合函数式接口定义时（如：无意中增加了另一个抽象方法），编译器会报错；		# 当接口不符合函数式接口定义时（如：无意中增加了另一个抽象方法），编译器会报错；
	# javaDoc 页中会指示该接口是一个函数式接口；		# javaDoc 页中会指示该接口是一个函数式接口；

Eijux：/* 处理lambda表达式 */

2022-04-22T15:43:39Z

处理lambda表达式

←上一版本		2022年4月22日 (五) 23:43的版本
第466行：		第466行：

	=== 处理lambda表达式 ===		=== 处理lambda表达式 ===
	使用lambda ~~表达式的重点是延迟执行（deferred~~ execution），如以下情况：		使用lambda 表达式的重点是'''延迟执行'''（deferred execution），如以下情况：
	# 在一个单独的线程中运行代码；		# 在一个单独的线程中运行代码；
	# 多次运行代码；		# 多次运行代码；
第474行：		第474行：


	~~使用lambda~~ 表达式，需要选择（偶尔可能需要提供）一个函数式接口：		使用 lambda 表达式，需要选择（偶尔可能需要提供）一个函数式接口：
	{\| class="wikitable"		{\| class="wikitable"
	\|+ 常用函数式接口		\|+ 常用函数式接口
第507行：		第507行：
	\| BooleanSupplier \|\| none \|\| boolean \|\| getAsBoolean		\| BooleanSupplier \|\| none \|\| boolean \|\| getAsBoolean
	\|-		\|-
	\| Supplier \|\| none \|\| + \|\| ~~etAs~~		\| Supplier \|\| none \|\| + \|\| getAs
	\|-		\|-
	\| *Consumer \|\| + \|\| void \|\| accept		\| *Consumer \|\| + \|\| void \|\| accept
第527行：		第527行：
	\| *Pedicate \|\| + \|\| boolean \|\| test		\| *Pedicate \|\| + \|\| boolean \|\| test
	\|}		\|}
	* “+-” 为 int, long, double; “*,#” ~~为Integer~~, Long, Double		* “+-” 为 int, long, double; “*,#” 为 Integer, Long, Double

	=== 再谈 Comparator ===		=== 再谈 Comparator ===

Eijux：/* lambda表达式语法 */

2022-04-22T15:31:39Z

lambda表达式语法

←上一版本		2022年4月22日 (五) 23:31的版本
第227行：		第227行：
	* Java 是面向对象的语言，所以必须构造一个对象，用对象的类的方法来包含所需的代码块；		* Java 是面向对象的语言，所以必须构造一个对象，用对象的类的方法来包含所需的代码块；

	=== ~~lambda表达式语法~~ ===		=== lambda表达式的语法 ===
	lambda 表达式形式：		lambda 表达式形式：
	'''<syntaxhighlight lang="xml">		'''<syntaxhighlight lang="xml">
	参数 -> 表达式		参数 -> 表达式
	</syntaxhighlight>'''		</syntaxhighlight>'''

	如：		如：
	<syntaxhighlight lang="java">		: <syntaxhighlight lang="java">
	(String first, String second) ->		(String first, String second) ->
	{		{
	if (first.~~lengthO~~ < second.~~lengthO~~) return -1;		if (first.length() < second.length()) return -1;
	else if (first.~~lengthO~~ > second.~~lengthO~~) return 1;		else if (first.length() > second.length()) return 1;
	else return 0;		else return 0;
	}		}
第243行：		第244行：


	参数：		'''参数：'''
	# ~~如果没有参数，仍然要保留括号：~~		# 如果没有参数，仍然要保留括号。
			#: 比如：
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	() -> { for (int i = 100; i >= 0;i ) System.out.println(i); }		() -> { for (int i = 100; i >= 0;i ) System.out.println(i); }
	</syntaxhighlight>		</syntaxhighlight>
	# ~~如果可以推导出参数类型，可以忽略参数类型：~~		# 如果可以推导出参数类型，可以忽略参数类型。
			#: 比如：
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	Comparator<String> comp		Comparator<String> comp
第254行：		第257行：
	-> first.length() - second.length();		-> first.length() - second.length();
	</syntaxhighlight>		</syntaxhighlight>
	# ~~如果方法只有一个参数，且参数类型可以推导，可以只保留参数名：~~		# 如果方法只有一个参数，且参数类型可以推导，可以只保留参数名。
			#: 比如：
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	ActionListener listener = event ->		ActionListener listener = event ->
第261行：		第265行：
	</syntaxhighlight>		</syntaxhighlight>

			'''表达式：'''
	~~表达式：~~		# 无需指定 lambda 表达式的返回类型。【lambda 表达式的返回类型总是会由上下文推导得出】
	# ~~如果返回值可以由上下文推导得出，可以省略返回类型：~~		#: 比如：如下表达式可以在 int 类型结果的上下文使用：
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	(String first, String second) -> first.length() - second.length()		(String first, String second) -> first.length() - second.length()
	</syntaxhighlight>		</syntaxhighlight>
	#: ~~可以在 int 类型结果的上下文使用；~~		# lambda 表达式不能只在某些分支返回值，而存在分支不返回值。
			#: 如下，是不合法的：
			#: <syntaxhighlight lang="java">
	* lambda 表达式不能只在某些分支返回值，而存在分支不返回值。如下，是不合法的：
	*: <syntaxhighlight lang="java">
	(int x)-> { if (x >= 0) return 1; }		(int x)-> { if (x >= 0) return 1; }
	</syntaxhighlight>		</syntaxhighlight>

Eijux：/* Comparator 接口 */

2022-04-22T15:25:36Z

Comparator 接口

←上一版本		2022年4月22日 (五) 23:25的版本
第101行：		第101行：

	=== Comparator 接口 ===		=== Comparator 接口 ===
	* 若需要将对象数组排序，则必须数组的每一个元素都实现了'''Comparable'''~~接口：~~		* 若需要将对象数组排序，则必须数组的每一个元素都实现了'''Comparable 接口'''，并实现其 compareTo 方法：
	*: <syntaxhighlight lang="java">		*: <syntaxhighlight lang="java">
	package java.lang;		package java.lang;
第112行：		第112行：


	~~然而，如果需要对String数组排序（已经实现了Comparable~~<String>接口），但又不想按照字典顺序排序（String.~~compareTo的实现是按字典顺序比较）：~~		然而，如果需要对 String 数组排序（已经实现了 Comparable<String> 接口），但又不想按照字典顺序排序（String.compareTo 的实现是按字典顺序比较）：
	~~:首先我们不能使String类实现两种不同的compareTo方法，~~		# 首先我们不能使 String 类实现两种不同的 compareTo 方法，
	~~:其次String类也不应该由我们修改。~~		# 其次 String 类也不应该由我们修改。
	即：'''~~如何使用Comparable~~.~~compareTo方法之外的比较方法，来进行对象数组的排序？~~'''		即：'''如何使用 Comparable.compareTo 方法之外的比较方法，来进行对象数组的排序？'''【如何自定义排序】


	~~所以，我们需要用到：~~		所以，需要用到：'''Comparator<T> 接口'''（不同于 Comparable）：
	~~# '''Arrays.sort''' 方法~~
	~~#: <syntaxhighlight lang="java">~~
	~~public static <T> void sort(T[] a, Comparator<? super T> c) {~~
	~~if (c == null) {~~
	~~sort(a);~~
	~~} else {~~
	~~if (LegacyMergeSort.userRequested)~~
	~~legacyMergeSort(a, c);~~
	~~else~~
	~~TimSort.sort(a, 0, a.length, c, null, 0, 0);~~
	}
	}
	~~</syntaxhighlight>~~
	~~# 以及，~~'''Comparator<T>'''接口
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	package java.util;		package java.util;
第141行：		第127行：
	}		}
	</syntaxhighlight>		</syntaxhighlight>
			* Comparator<T> 接口的方法很多，但并不用全部实现，因为一部分方法有实现，一部分为默认方法；


	如：		示例一：对 String 数组自定义排序：
	# 定义一个 Comparator<String> 接口的实现类：		# 定义一个 Comparator<String> 接口的实现类：
	~~#: Comparator<T> 接口的方法很多，但并不用全部实现，因为一部分方法有实现，一部分为默认方法；~~
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	class LengthComparator implements Comparator<String>		class LengthComparator implements Comparator<String>
	{		{
	public int compare(String first, String second) {		public int compare(String first, String second) {
	return first.~~lengthO~~ - second.~~lengthO；~~		return first.length() - second.length()；
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	# ~~使用Arrays~~.~~sort进入数组比较：~~		# 使用 Arrays.sort 进入数组比较：
	#: <syntaxhighlight lang="java">		#: <syntaxhighlight lang="java">
	String[] friends = { "Peter", "Paul", "Mary" };		String[] friends = { "Peter", "Paul", "Mary" };
	Arrays,sort(friends, new ~~LengthComparatorO~~):		Arrays.sort(friends, new LengthComparator()):
			</syntaxhighlight>
			#* Arrays.sort 是静态方法，可以类名直接调用；
			* <syntaxhighlight lang="java" highlight="">
			// 对 Arrays 默认排序
			public static <T> void sort(T[] a)

			// 对 Arrays 使用自定义排序（Comparator）
			public static <T> void sort(T[] a, Comparator<? super T> c)
	</syntaxhighlight>		</syntaxhighlight>
	~~# 也可以，单独对两个对象或两个数组元素进行比较：~~
	#: <syntaxhighlight lang="java">		示例二：单独对两个对象或两个数组元素进行比较：
	Comparator<String> comp = new ~~LengthComparator。；~~		: <syntaxhighlight lang="java">
			Comparator<String> comp = new LengthComparator()；
	if (conp.compare(words[i], words[j]) > 0)		if (conp.compare(words[i], words[j]) > 0)
			...
	</syntaxhighlight>		</syntaxhighlight>
	* Comparator.compare 并非静态方法，所以使用时需要 ~~Comparator实例；~~		* Comparator.compare 并非静态方法，所以使用时需要 Comparator 实例；


			'''利用lambda 表达式可以更容易地使用 Comparator'''

	=== 对象克隆 ===		=== 对象克隆 ===

Eijux：/* 变量作用域 */

2022-04-18T03:53:55Z

变量作用域

←上一版本		2022年4月18日 (一) 11:53的版本
第398行：		第398行：
	{		{
	ActionListener listener = event ->		ActionListener listener = event ->
	{		{
	System.out.println(text):		System.out.println(text):
	Toolkit.~~getDefaultToolkitO~~.beep() :		Toolkit.getDefaultToolkit().beep() :
	}；		}；
	new Timer(delay, listener) .~~start0~~;		new Timer(delay, listener).start();
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	*: 调用 repeatMessage("Hello", 1000); ~~则会每秒打印一个Hello；~~		*: 调用 repeatMessage("Hello", 1000); 则会每秒打印一个 Hello；


第414行：		第414行：
	ActionListener listener = event ->		ActionListener listener = event ->
	{		{
	start--; // Error: Can't mutate captured variable		start--; // Error: Can't mutate captured variable
	System.out.println(start);		System.out.println(start);
	}；		}；
	new Timer(~~del ay~~, listener) ,start();		new Timer(delay, listener).start();
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	*: ~~如上，在lambda内改变变量start的值，是不合法的；~~		*: 如上，在 lambda 内改变变量 start 的值，是不合法的；
	*: <syntaxhighlight lang="java">		*: <syntaxhighlight lang="java">
	public static void repeat(String text , int count)		public static void repeat(String text , int count)
第428行：		第428行：
	ActionListener listener = event ->		ActionListener listener = event ->
	{		{
	System.out.~~pn'nt1n~~(i + ": " + text) ;		System.out.print1n(i + ": " + text) ; // Error: Cannot refer to changing i
	// Error: Cannot refer to changing i
	}；		}；
	new Timer(1000, listener) .start();		new Timer(1000, listener).start();
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	*: ~~以上同样不合法：lambda捕获的变量~~ i，也不能在外部被改变；		*: 以上同样不合法：lambda 捕获的变量 i，也不能在外部被改变；


第442行：		第441行：
	Path first = Paths.get("usr/Mn");		Path first = Paths.get("usr/Mn");
	Couparator<String> comp =		Couparator<String> comp =
	(first , second) -> first.length() - second.~~lengthO~~ ;		(first, second) -> first.length() - second.length();
	// Error: Variable first already defined		// Error: Variable first already defined
	</syntaxhighlight>		</syntaxhighlight>
第448行：		第447行：


	* '''lambda 中的 this ~~关键字是指创建这个lambda表达式的方法的this参数~~'''；		* '''lambda 中的 this 关键字是指创建这个 lambda 表达式的方法的 this 参数'''；
	*: <syntaxhighlight lang="java">		*: <syntaxhighlight lang="java">
	public class ~~ApplicationO~~		public class Application()
	{		{
	public void init ()		public void init()
	{		{
	ActionListener listener * event ->		ActionListener listener = event ->
	{		{
	System.out.~~print n~~(~~thi s~~.toString());		System.out.println(this.toString());
	...		...
	}		}
第463行：		第462行：
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	*: ~~如上，表达式this~~.toString()~~会调用Application对象的toString方法，而不是ActionListener实例的方法；~~		*: 如上，表达式 this.toString() 会调用 Application 对象的 toString 方法，而不是 ActionListener 实例的方法；

	=== 处理lambda表达式 ===		=== 处理lambda表达式 ===

Eijux：/* 构造器引用 */

2022-04-18T03:46:16Z

构造器引用

←上一版本		2022年4月18日 (一) 11:46的版本
第359行：		第359行：
	</syntaxhighlight>'''		</syntaxhighlight>'''
	* 可以用数组类型建立构造器引用。		* 可以用数组类型建立构造器引用。
	*: ~~例如，“int~~[]::~~new”是一个构造器引用，它有一个参数（即数组的长度）。等价于lambda 表达式“x~~-> new int[x]”；		*: 例如，“<syntaxhighlight lang="java" inline>int[]::new</syntaxhighlight>”是一个构造器引用，它有一个参数（即数组的长度）。等价于lambda 表达式“<syntaxhighlight lang="java" inline>x-> new int[x]</syntaxhighlight>”；


第368行：		第368行：
	List<Person> people = stream.col1ect(Col1ectors.toList());		List<Person> people = stream.col1ect(Col1ectors.toList());
	</syntaxhighlight>		</syntaxhighlight>
	map ~~方法会为各个列表元素调用Person~~(String) ~~构造器。如果有多个Person 构造器，编译器会选择有一个String~~ 参数的构造器，因为它从上下文推导出这是在对一个字符串调用构造器。		map 方法会为各个列表元素调用 Person(String) 构造器。如果有多个 Person 构造器，编译器会选择有一个 String 参数的构造器，因为它从上下文推导出这是在对一个字符串调用构造器。


	关于Java中创建泛型数组：（泛型是Java的语法糖，在编译时会被替换为实际类型）		关于Java中创建泛型数组：（泛型是Java的语法糖，在编译时会被替换为实际类型）
	<pre>		<pre>
	Java 有一个限制，无法构造泛型类型 T 的数组。数组构造器引用对于克服这个限制很有用。表达式“new T[n]”会产生错误，因为这会改为“new Object[n]”。 ~~对于开发类库的人来说，这~~		Java 有一个限制，无法构造泛型类型 T 的数组。数组构造器引用对于克服这个限制很有用。表达式“new T[n]”会产生错误，因为这会改为“new Object[n]”。对于开发类库的人来说，这是一个问题。例如，假设我们需要一个 Person 对象数组。
	~~是一个问题。例如，假设我们需要一个Person 对象数组。Stream 接口有一个toArray 方法可以返回Object~~ 数组：		Stream 接口有一个 toArray 方法可以返回 Object 数组：
	Object[] people = stream.toArray()；		Object[] people = stream.toArray()；
	~~不过，这并不让人满意。用户希望得到一个Person 引用数组，而不是Object 引用数组。流库利用构造器引用解决了这个问题。可以把Person~~[]::new ~~传人toArray~~ 方法：		不过，这并不让人满意。用户希望得到一个 Person 引用数组，而不是 Object 引用数组。流库利用构造器引用解决了这个问题。可以把 Person[]::new 传人 toArray 方法：
	Person[] people = stream.toArray(~~PersonD~~::new);		Person[] people = stream.toArray(Person::new);
	toArray 方法调用这个构造器来得到一个正确类型的数组。然后填充这个数组并返回。		toArray 方法调用这个构造器来得到一个正确类型的数组。然后填充这个数组并返回。
	</pre>		</pre>

Eijux：/* 方法引用 */

2022-04-18T03:43:31Z

方法引用

←上一版本		2022年4月18日 (一) 11:43的版本
第333行：		第333行：
	主要有三种情况：		主要有三种情况：
	'''<syntaxhighlight lang="xml">		'''<syntaxhighlight lang="xml">
	object::instanceMethod		object::instanceMethod
	Class::staticMethod		Class::staticMethod
	Class::instanceMethod		Class::instanceMethod
	</syntaxhighlight>'''		</syntaxhighlight>'''
	* 对于前两种，方法引用等价于提供方法参数的 lambda 表达式：		* 对于前两种，方法引用等价于提供方法参数的 lambda 表达式：
	*: <syntaxhighlight lang="java" inline>System.out::println</syntaxhighlight>等价于<syntaxhighlight lang="java"inline>x -> System.out.println(x);</syntaxhighlight>		*: <syntaxhighlight lang="java" inline>System.out::println</syntaxhighlight> 等价于 <syntaxhighlight lang="java"inline>x -> System.out.println(x);</syntaxhighlight>
	*: <syntaxhighlight lang="java"inline>Math::pow</syntaxhighlight>等价于<syntaxhighlight lang="java"inline>(x, y) -> Math.pow(x, y)</syntaxhighlight>		*: <syntaxhighlight lang="java"inline>Math::pow</syntaxhighlight> 等价于 <syntaxhighlight lang="java"inline>(x, y) -> Math.pow(x, y)</syntaxhighlight>
	* 对于第三种：第一个参数会成为方法的目标【？即：“para1.instanceMethod(para2)”】：		* 对于第三种：第一个参数会成为方法的目标【？即：“para1.instanceMethod(para2)”】：
	*: <syntaxhighlight lang="java"inline>String::compareToIgnoreCase</syntaxhighlight>等价于<syntaxhighlight lang="java"inline>(x, y) -> x.compareToIgnoreCase(y)</syntaxhighlight>		*: <syntaxhighlight lang="java"inline>String::compareToIgnoreCase</syntaxhighlight> 等价于 <syntaxhighlight lang="java"inline>(x, y) -> x.compareToIgnoreCase(y)</syntaxhighlight>

核心技术：接口、lambda表达式与内部类 - 版本历史

Eijux：​/* 代理 */

Eijux：​/* 创建一个代理对象 */

Eijux：​/* 再谈 Comparator */

Eijux：​/* 函数式接口 */

Eijux：​/* 处理lambda表达式 */

Eijux：​/* lambda表达式语法 */

Eijux：​/* Comparator 接口 */

Eijux：​/* 变量作用域 */

Eijux：​/* 构造器引用 */

Eijux：​/* 方法引用 */