核心技术：继承 - 版本历史

Eijux：/* 枚举类 */

2020-10-18T17:54:39Z

枚举类

←上一版本		2020年10月19日 (一) 01:54的版本
第182行：		第182行：
	# 所有枚举类都是“Enum”类（java.lang中）的子类；		# 所有枚举类都是“Enum”类（java.lang中）的子类；
	# 比较两个枚举类型的值时，应该用“==”而非“equals”；		# 比较两个枚举类型的值时，应该用“==”而非“equals”；
			#: （其值为 final 修饰，且“equals”方法使用“==”比较）
			#: <syntaxhighlight lang="java">
			public final boolean equals(Object other) {
			return this==other;
			}
			</syntaxhighlight>
	# “toString”方法用于返回枚举常量名；		# “toString”方法用于返回枚举常量名；
	# “toString”的逆方法为静态方法“valueOf”：用于获取枚举常量；		# “toString”的逆方法为静态方法“valueOf”：用于获取枚举常量；

Eijux：/* 枚举类 */

2020-10-18T17:43:51Z

枚举类

@@ 第180行： / 第180行： @@
 声明了一个枚举类（这是一个类！）
-# 所有枚举类都是“Enum”类的子类；
+# 所有枚举类都是“Enum”类（java.lang中）的子类；
 # 比较两个枚举类型的值时，应该用“==”而非“equals”；
 # “toString”方法用于返回枚举常量名；
 # “toString”的逆方法为静态方法“valueOf”：用于获取枚举常量；
 == 反射 ==

Eijux：/* 继承的设计技巧 */

2020-10-16T18:09:50Z

继承的设计技巧

←上一版本		2020年10月17日 (六) 02:09的版本
第404行：		第404行：

	== 继承的设计技巧 ==		== 继承的设计技巧 ==

			# 将公共操作和域放在超类
			# 不要使用受保护的域
			#: 子类集合是无限制的，任何一个人都能够由某个类派生一个子类，并编写代码以直接访问protected 的实例域，从而破坏了封装性；
			#: 同一个包中的所有类都可以访问proteced 域，而不管它是否为这个类的子类；
			# 使用继承实现“is-a” 关系
			# 除非所有继承的方法都有意义，否则不要使用继承
			# 在覆盖方法时，不要改变预期的行为
			#: 置换原则应用于行为
			# 使用多态，而非类型信息
			#: 使用多态性提供的动态分派机制执行相应的动作；
			#: 使用多态方法或接口编写的代码，比使用对多种类型进行检测的代码更加易于维护和扩展；
			# 不要过多地使用反射
			#: 对于编写系统程序极其实用，但是通常不适于编写应用程序

Eijux：/* 调用任意方法 */

2020-10-16T18:01:22Z

调用任意方法

←上一版本		2020年10月17日 (六) 02:01的版本
第360行：		第360行：

	=== 调用任意方法 ===		=== 调用任意方法 ===
			<pre>
			在C 和C++ 中，可以从函数指针执行任意函数。从表面上看，Java 没有提供方法指针，即：将一个方法的存储地址传给另外一个方法，以便第二个方法能够随后调用它。

			事实上，Java 的设计者曾说过：方法指针是很危险的，并且常常会带来隐患。
			他们认为 Java 提供的接口（interface ) 是一种更好的解决方案。
			然而，反射机制允许你调用任意方法。
			</pre>

			==== 调用方法 ====
			在Method 类中有一个'''invoke'''方法，它允许调用包装在当前Method 对象中的方法。invoke 方法的签名是：
			<syntaxhighlight lang="java">
			Object invoke(Object obj, Object... args)
			</syntaxhighlight>
			# 对于静态方法，第一个参数可以被忽略，即可以将它设置为null。
			#: <syntaxhighlight lang="java">
			// 假设用ml 代表Employee 类的getName 方法
			String n = (String) ml.invoke(harry);
			</syntaxhighlight>
			# 如果返回类型是基本类型， invoke 方法会返回其包装器类型。
			#: <syntaxhighlight lang="java">
			double s = (Double) m2,invoke(harry);
			</syntaxhighlight>

			==== 获取方法 ====
			# 可以通过调用“getDeclareMethods”方法，然后对返回的“Method”对象数组进行查找，直到发现想要的方法为止。
			# 也可以通过调用Class 类中的“getMethod”方法得到想要的方法：
			#: <syntaxhighlight lang="java">
			Method getMethod(String name, Class... parameterTypes)
			</syntaxhighlight>
			#: 提供想要的方法名称，及参数类型


			如：
			<syntaxhighlight lang="java">
			Method ml = Employee.class.getMethod("getName");
			Method m2 = Employee.class.getMethod("raiseSalary", double.class);
			</syntaxhighlight>


			==== java.Iang.reflect.Method ====
			# public Object invoke(Object implicitParameter, Object[] explicitParamenters)
			#: 调用这个对象所描述的方法，传递给定参数，并返回方法的返回值。对于静态方法，把 null 作为隐式参数传递。在使用包装器传递基本类型的值时，基本类型的返回值必须是未包装的。

	== 继承的设计技巧 ==		== 继承的设计技巧 ==

Eijux：/* 使用反射编写泛型数组代码 */

2020-10-16T17:45:40Z

使用反射编写泛型数组代码

←上一版本		2020年10月17日 (六) 01:45的版本
第342行：		第342行：

	=== 使用反射编写泛型数组代码 ===		=== 使用反射编写泛型数组代码 ===
			java.lang.reflect 包中的Array 类允许动态地创建数组。<br/>
			【？？？？】
			==== java.lang.reflect.Array ====
			# static Object get(Object array,int index)
			# static xxx get/xx(Object array,int index)
			#: ( xxx 是boolean、byte、char、double、float、int、long、short 之中的一种基本类M。）
			#: 这些方法将返回存储在给定位置上的给定数组的内容。
			# static void set(Object array,int index,Object newValue)
			# static setXxx(Object array,int index,xxx newValue)
			#: ( xxx 是boolean、byte、char、double、float、int、long、short 之中的一种基本类型。）
			#: 这些方法将一个新值存储到给定位置上的给定数组中。
			# static int getLength(Object array)
			#: 返回数组的长度。
			# static Object newInstance(Class componentType,int length)
			# static Object newInstance(Class componentType,int[]lengths)
			#: 返回一个具有给定类型、给定维数的新数组。

	=== 调用任意方法 ===		=== 调用任意方法 ===

	== 继承的设计技巧 ==		== 继承的设计技巧 ==

Eijux：/* 在运行时使用反射分析对象 */

2020-10-16T17:33:09Z

在运行时使用反射分析对象

←上一版本		2020年10月17日 (六) 01:33的版本
第319行：		第319行：

	=== 在运行时使用反射分析对象 ===		=== 在运行时使用反射分析对象 ===
			==== java.lang.reflect.AccessibleObject ====
			# void setAccessible(boolean flag)
			#: 为反射对象设置可访问标志。flag 为true 表明屏蔽Java 语言的访问检查，使得对象的私有属性也可以被査询和设置。
			# boolean isAccessible( )
			#: 返回反射对象的可访问标志的值。
			# static void setAccessible(AccessibleObject[ ] array,boolean flag)
			#: 是一种设置对象数组可访问标志的快捷方法。

			==== java.lang.Class ====
			# Field getField( String name )
			# Field[ ] getFieldO
			#: 返回指定名称的公有域，或包含所有域的数组
			# Field getDeclaredField( String name )
			# Field[ ] getDeclaredFields( )
			#: 返回类中声明的给定名称的域，或者包含声明的全部域的数组。

			==== java.lang.reflect.Field ====
			# Object get(Object obj )
			#: 返回obj 对象中用Field 对象表示的域值。
			# void set(Object obj ,Object newValue)
			#: 用一个新值设置Obj 对象中Field 对象表示的域。

	=== 使用反射编写泛型数组代码 ===		=== 使用反射编写泛型数组代码 ===

Eijux：/* 利用反射分析类的能力 */

2020-10-16T17:22:42Z

利用反射分析类的能力

←上一版本		2020年10月17日 (六) 01:22的版本
第259行：		第259行：

	=== 利用反射分析类的能力 ===		=== 利用反射分析类的能力 ===
			<pre>
			在“java.lang.reflect”包中有三个类“Field”、“Method”和“Constructor”分别用于描述类的域、方法和构造器。

			这三个类都有一个叫做“getName”的方法，用来返回项目的名称。
			Field类有一个“getType”方法，用来返回描述域所属类型的Class对象。
			Method 和Constructor 类有能够报告参数类型的方法，Method 类还有一个可以报告返回类型的方法。
			这三个类还有一个叫做“getModifiers”的方法，它将返回一个整型数值，用不同的位开关描述public 和static 这样的修饰符使用状况。

			另外，还可以利用“java.lang.reflect”包中的“Modifier”类的静态方法分析“getModifiers”返回的整型数值。
			例如，可以使用Modifier 类中的“isPublic”、“isPrivate”或“isFinal”判断方法或构造器是否是public、private 或final。

			Class 类中的“getFields”、“getMethods”和“getConstructors”方法将分别返回类提供的 public域、方法和构造器数组，其中包括超类的公有成员。
			Class 类的“getDeclareFields”、“getDeclareMethods”和“getDeclaredConstructors”方法将分别返回类中声明的全部域、方法和构造器，其中包括私有和受保护成员，但不包括超类的成员。
			</pre>

			==== java.lang.Class ====
			# Field[] getFields() 1.1
			# Filed[] getDeclaredFie1ds() 1.1
			#: getFields 方法将返回一个包含 Field 对象的数组，这些对象记录了这个类或其超类的公有域。getDeclaredField 方法也将返回包含 Field 对象的数组，这些对象记录了这个类的全部域。如果类中没有域，或者Class 对象描述的是基本类型或数组类型，这些方法将返回一个长度为0 的数组。
			# Method[] getMethods() 1.1
			# Method[] getDeclareMethods() 1.1
			#: 返回包含Method 对象的数组：getMethods 将返回所有的公有方法，包括从超类继承来的公有方法；getDeclaredMethods 返回这个类或接口的全部方法，但不包括由超类继承了的方法。
			# Constructor[] getConstructors() 1.1
			# Constructor[] getDeclaredConstructors() 1.1
			#: 返回包含Constructor 对象的数组，其中包含了Class 对象所描述的类的所有公有构造器（getConstructors ) 或所有构造器（getDeclaredConstructors)。

			==== java.lang.reflect.Field ====
			==== java.lang.reflect.Method ====
			==== java.lang.reflect.Constructor ====
			# Class getDeclaringClass()
			#: 返冋一个用于描述类中定义的构造器、方法或域的Class 对象。
			# Class[] getExceptionTypes() ( 在Constructor 和Method 类中）
			#: 返回一个用于描述方法抛出的异常类型的Class 对象数组。
			# int getModifiers()
			返回一个用于描述构造器、方法或域的修饰符的整型数值。使用Modifier 类中的这个方法可以分析这个返回值。
			# String getName()
			#: 返冋一个用于描述构造器、方法或域名的字符串。
			# Class[] getParameterTypes() ( 在Constructor 和Method 类中）
			#: 返回一个用于描述参数类型的Class 对象数组。
			# Class getReturnType() ( 在Method 类中）
			#: 返回一个用于描述返H类型的Class 对象。

			==== java.lang.reflect.Modifier ====
			# static String toString( int modifiers )
			#: 返回对应modifiers中位设置的修饰符的字符串表示。
			# static boolean isAbstract ( int modifiers )
			# static boolean isFinal ( int modifiers )
			# static boolean islnterface( int modifiers )
			# static boolean isNative( int modifiers )
			# static boolean isPrivate( int modifiers )
			# static boolean isProtected( int modifiers )
			# static boolean isPublic( int modifiers )
			# static boolean isStatic( int modifiers )
			# static boolean isStrict( int modifiers )
			# static boolean isSynchronized( int modifiers )
			# static boolean isVolati 1e( int modifiers )

			这些方法将检测方法名中对应的修饰符在modffiers 值中的位。

	=== 在运行时使用反射分析对象 ===		=== 在运行时使用反射分析对象 ===

Eijux：/* 捕获异常 */

2020-10-16T17:01:10Z

捕获异常

←上一版本		2020年10月17日 (六) 01:01的版本
第257行：		第257行：
	</syntaxhighlight>		</syntaxhighlight>
	* newInstance方法调用默认的构造器（无参构造器）来初始化新创建的对象，如果这个类没有默认的构造器，则会抛出异常。		* newInstance方法调用默认的构造器（无参构造器）来初始化新创建的对象，如果这个类没有默认的构造器，则会抛出异常。

	~~=== 捕获异常 ===~~


	=== 利用反射分析类的能力 ===		=== 利用反射分析类的能力 ===

Eijux：/* 创建类的实例 */

2020-10-16T17:00:59Z

创建类的实例

←上一版本		2020年10月17日 (六) 01:00的版本
第256行：		第256行：
	Object m = Class.forName(s).newInstance();		Object m = Class.forName(s).newInstance();
	</syntaxhighlight>		</syntaxhighlight>
			* newInstance方法调用默认的构造器（无参构造器）来初始化新创建的对象，如果这个类没有默认的构造器，则会抛出异常。

	=== 捕获异常 ===		=== 捕获异常 ===

Eijux：/* Class类 */

2020-10-16T16:33:58Z

Class类

←上一版本		2020年10月17日 (六) 00:33的版本
第197行：		第197行：

	=== Class类 ===		=== Class类 ===
			<pre>
			在程序运行期间，Java运行时系统始终为所有的对象维护一个被称作“运行时”的类型标识。
			这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行。

			然而，可以通过专门的Java类访问这些信息。保存这些新欻的类被称为“Class”。

			如同一个Employee对象表示某个的雇员一样，一个Class对象将表示某个类的属性。
			</pre>

			==== 获取“Class类”对象 ====
			# Java对象的“getClass()”方法：【普通对象的方法】
			#: <syntaxhighlight lang="java" highlight="2">
			Employee e = new Employee();
			Class c1 = e.getClass();
			System.out.println(c1.getName()); // 结果:Employee
			</syntaxhighlight>
			#: 如果类在包里，则包名也作为类名的一部分，如“java.util.Random”
			# “Class”类的静态方法“forName()”：【Class类的静态方法】
			#: <syntaxhighlight lang="java" highlight="2">
			String className = "java.util.Random";
			Class c2 = Class.forName(className);
			System.out.println(c2.getName()); // 结果:Random
			</syntaxhighlight>
			#: 只有在className时类名或接口名时才能执行，否则抛出“checked exception”
			#: 无论何时使用此方法，都应该提供一个异常处理器（exception handler）
			# “Java类名.class”【类字面量】
			#: <syntaxhighlight lang="java" highlight="1,5,9">
			Class c3 = Employee.class;
			System.out.println(c3.getName()); // 结果:Employee

			// 运用.calss的方式获取Class实例(基本类型)
			Class c4 = Random.class;
			System.out.println(c4.getName()); // 结果:int

			// 运用.class的方式获取Class实例(基本数据类型的封装类)
			Class c5 = Integer.TYPE;
			System.out.println(c5.getName()); // 结果:int
			</syntaxhighlight>


			* 一个“Class”对象实际上表示的时一个类型，而这个类型未必一定是一种类；
			*: 如：int不是一个类，但int.Class是一个Class类型的对象；
			* Class类实际上是一个泛型类，如：“Employee.class”的类型是“Class<Employee>”
			* 虚拟机为每个类型管理一个Class对象，因此可以利用“==”实现两个类对象的比较：
			*: <syntaxhighlight lang="java">
			if(e.getClass() == Employee.class)
			</syntaxhighlight>

			==== 创建类的实例 ====
			“newInstance()”方法用于动态地创建一个类的实例：
			<syntaxhighlight lang="java">
			e.getClass().newInstance(); // e 是一个Employee对象
			</syntaxhighlight>

			* 将 forName 与 newInstance 配合使用，可以根据存储在字符串中的类名创建一个对象：
			*: <syntaxhighlight lang="java">
			String s = "java.util.Random";
			Object m = Class.forName(s).newInstance();
			</syntaxhighlight>

	=== 捕获异常 ===		=== 捕获异常 ===

核心技术：继承 - 版本历史

Eijux：​/* 枚举类 */

Eijux：​/* 枚举类 */

Eijux：​/* 继承的设计技巧 */

Eijux：​/* 调用任意方法 */

Eijux：​/* 使用反射编写泛型数组代码 */

Eijux：​/* 在运行时使用反射分析对象 */

Eijux：​/* 利用反射分析类的能力 */

Eijux：​/* 捕获异常 */

Eijux：​/* 创建类的实例 */

Eijux：​/* Class类 */

Eijux：/* 枚举类 */

Eijux：/* 枚举类 */

Eijux：/* 继承的设计技巧 */

Eijux：/* 调用任意方法 */

Eijux：/* 使用反射编写泛型数组代码 */

Eijux：/* 在运行时使用反射分析对象 */

Eijux：/* 利用反射分析类的能力 */

Eijux：/* 捕获异常 */

Eijux：/* 创建类的实例 */

Eijux：/* Class类 */