黑马程序员_Java基础_前期准备02-1

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------

 前期准备02-1

 

一、Java高新技术

①MyEclipse

❶MyEclipse企业级工作平台(MyEclipse Enterprise Workbench，简称MyEclipse)是对EclipseIDE的扩展，使用它可以在数据库和JavaEE的开发、发布以及应用程序服务器的整合方面极大的提高工作效率。它是功能丰富的JavaEE集成开发环境，包括了完备的编码、调试、测试和发布功能，完整支持HTML、Struts、JSP、CSS、Javascript、Spring、SQL、Hibernate。

/*[i'klips]月食['entəpraiz]企业['wə:kbenʃ]工作台*/

❷一些英语缩写

CSS：Computer System Simulation

/*[kəm'pju:tə]计算机['sistəm]系统[simju'leiʃn]仿真*/

HTML：Hyper Text Markup Language

/*['haipə]大量传播[tekst]文本['ma:kʌp]标记['læŋgwidʒ]语言*/

IDE：Integrated DevelopmentEnvironment

/*['intigreitid]集成的[di'veləpmnt]开发[in'vairənmnt]环境*/

JavaEE：Java Platform EnterpriseEdition

/*['dʒa:və]['plætfɔ:m]平台['entəpraiz]企业[i'diʃn]版本*/

JSP：Java Server Page

/*['dʒa:və]['sə:və]服务端[peidʒ]页面*/

JMS：Java Message Service

/*['dʒa:və]['mesidʒ]消息['sə:vis]服务*/

JMX：Java Management Extensions

/*['dʒa:və]['mænidʒmnt]管理[ik'stenʃnz]扩展*/

JNDI：Java Naming DirectoryInterface

/*['dʒa:və]['neimiŋ]命名[di'rektri]目录['intəfeis]接口*/

SQL：Structured Query Language

/*['strʌktʃəd]结构化['kwiəri]查询['læŋgwidʒ]语言*/

Spring：Spring framework(一种提供简易开发方式的框架)

/*['spriŋ]['freimwə:k]框架*/

Hibernate/*['haibəneit]对象关系映射框架*/

Javascript/*['dʒa:və]['skript]脚本*/

Struts/*['strʌts]一种MVC框架*/

MVC：Model View Controller

/*['mɔdl]模型[vju:]视图[kən'trəulə]控制器*/

❸工程project/*['prɔdʒekt]工程*/

IDE(集成开发工具)都支持使用工程化的方式，管理一个项目的开发过程。

❹工作间workspace/*['wə:ksbeis]工作空间*/

一个工作间可以包含多个工程。工作间中的各种配置，会影响其中的所有工程。当然，工程也可以单独配置。这种模式类似于函数的继承和覆盖。

可以设置一个工作间的编译语言版本、运行环境版本、快捷键、模板代码等。

❺Perspective与view

Perspective：/*[pə'spektiv]透视图*/

View：/*[vju:]视图*/

视图是一个个的窗口，透视图就是某些窗口的集合。在实际操作过程中，会用到不同的视图窗口，每个透视图都集合了一些相关的视图窗口。这时只需要切换到不同的透视图模式下，就可以使用这些视图窗口，会很方便。

❻javac与jre

运行环境只能够向下兼容编译语言的版本，否则将会出现版本异常。

②JDK1.5新特性

❶静态导入(import static)：导入的是类中的静态成员。

❷可变参数(T...)：参数的长度是可变的，只能出现在参数列表的最后面。对于可变参数，是以数组的形式被使用的，可以通过对数组的遍历来获取它们。基本数据类型的数组，将被视为一个数组对象。

❸高级for循环：必须要有被迭代的对象，并且只有取出的功能。

❹自动装箱和自动拆箱：对基本数据类型和其包装类对象间的自动转换。对于在byte类型范围之内(-128~127)的数字，保持对象的唯一性。

❺枚举：对象的约束机制。

❻泛型：改善了代码的复用性，提高了程序的编译性能。

❼注解：一种特殊的接口，具备类的一些特性，能够提高程序的编译性能。

③一些知识点

❶重载和重写

重载(overload)：只注重参数列表/*[əuvə'ləud]*/

重写(override)：严格符合格式/*[əuvə'raid]*/

❷Flyweight Pattern(享元模式)/*['flaiweit]轻量级选手['pætn]模式*/

一种软件设计模式。它使用共享的事物，尽量减少对内存的使用量。当然也可以只是共享一部分属性。如系统图标，图案本身是共享的，名称和位置是变化的。如文字处理软件中的字符，字符本身是共享的，出现的位置是变化的。

可以将共享的事物当成一个方法，把变化的属性当做其参数。

❸如何理解面向对象

谁拥有数据，谁提供操作数据的方法。可以通过将数据私有，找出其所有者。此处可以理解为专家模式(Expert Mode)/*['ekspə:t]专家[məud]模式*/

实例：

1，小球在线上滚动。线提供移动的距离，并根据现在的位置给出下一个位置；小球拥有滚动的方法，可以通过给定的移动位置，实现滚动的动作。

2，人在黑板上画圆。圆提供圆心和半径，圆告诉人该怎样画，并在黑板上表现出来。

3，人关门。门拥有关闭的状态和功能，人只是调用了它的关闭动作。

❹HashSet

1，被此集合存储的对象，其所对应的类应重写hashCode方法和equals方法。

2，哈希算法，就是根据一个对象某些变量的取值，通过运算之后获取到一个值。将这个值，与内存中的某一区域相关联。这样就能够提高，寻找到这个对象的效率。

3，对于存储在使用哈希算法集合中的对象，不可以修改其参与哈希值运算的可变的值，否则会使得该对象被隐藏，将造成内存泄露，累积之后就会造成内存溢出。

4，内存泄露，就是内存应该被释放，却没有被释放，并且不可用。

❺Java1.7新特性

Map集合的定义方式可以为：

Map map = {name：“zhangsan”，age：20}；

BeanUtils.setProperty(map，“name”，“age”)；

❻模板设计模式

定义一个具备操作功能的算法骨架，而将这些步骤的实现延迟到其子类中。子类只需要定义被操作的内容，而不需要考虑算法，就可以实现特定的功能。

实例：

1，泡茶和冲咖啡，流程是相同的，操作的内容不同，得到的结果不同。

2，制作月饼，模子和流程是相同的，放的馅不同，月饼的口味不同。

④枚举(enum[enəm])

❶普通类的实例模拟

定义一个类用来描述一周中的天数，其中的天数是固定的、有限的。此类的构造方法是私有的，类常量是本类对象，成员方法是公有的。

如果在类中定义一个方法，用于获取nextDay，其中需要使用多条if语句来判断。这时可以定义一个抽象的方法，让该类的每个对象，通过匿名内部类的方式分别实现此方法。将大量的if语句，转换为多个独立的类。

❷枚举

枚举是一个类型修饰符，枚举类的对象是固定的、有限的。枚举是一种特殊的类，enum的用法同class、interface、@interface。

枚举的定义：

1，将被枚举的对象罗列在最前面，用逗号分开，以分号结尾。如果没有定义其它成员，最后可以没有分号。枚举对象可以通过类名直接调用。

2，枚举固有的非静态方法：toString，name，ordinal。/*['ɔ:dinl]序号*/

3，枚举固有的静态方法：values，valueOf。/*['vælju:z]值*/

其中的valueOf方法，可以将指定的相符合的字符串，转换为此类的对象。

其中的values方法，可以将该类的对象全部取出，存放在一个数组中。

4，枚举的成员，具备任何一般对象所具有的一切基本属性。

5，枚举的构造函数必是私有的。

6，枚举对象的后面可以加上小括号，通过参数来指定，在初始化时要调用哪一个构造函数。

7，枚举对象的后面加上大括号，在大括号中覆盖父类的抽象方法，就可以实现匿名内部类的功能。(交通灯：绿->黄->红->绿)

❸枚举与单例

当枚举中只有一个成员对象时，此时的枚举对象就可以当做单例。

⑤反射/*reflect[ri'flekt]*/

❶反射的原理

反射就是把Java类中的各种成分，映射成相应的Java类。

任何一个Java类中的所有成分，都是其所对应的Java类的一个实例。这些实例隶属于这个类，而不是隶属于该类的对象。

❷Class<T>类

public final class Class<T>

extends Object

implementsSerializable,GenericDeclaration,Type,AnnotatedElement

/*['siriəlaizəbl]序列化[dʒi'nerik]泛型[deklə'reiʃn]声明[taip]类型['ænəteitid]带注解的['elimnt]元素*/

1，此类的对象表示正在运行的Java应用程序中的类或接口，是一份字节码文件。

2，枚举是一种类，注释是一种接口。

3，每一个数组都属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象。只需维数相同，而不是元素个数相同。

4，Java基本数据类型的关键字修饰符和关键字void，也表示为Class对象。

5，Class没有公有的构造方法。Class对象是在加载类时，由JVM通过调用类加载器中的defineClass方法自动构造的。/*[di'fain]定义*/

6，可以通过一个类的Class对象，获取该类的一些基本的属性信息。

7，获取Class对象的三种方法：一是直接定义Class clazz = 类名.class；二是通过该类的对象返回Class clazz = 该类的对象.getClass()；三是通过Class中的静态方法返回Class clazz = Class.forName(类名)；

8，成员方法(部分)

public static Class<T> forName(String classname)

throws ClassNotFoundException

返回与拥有指定字符串名的类或接口，相关联的Class对象。

public ClassLoader getClassLoader()/*['ləudə]加载器*/

返回该类的类加载器。可以用来加载配置文件。

public Constructor<?>[] getDeclaredConstructors()

throws SecurityException

/*[kən'strʌktə]构造函数[di'kleəd]声明的[si'kjuərəti]安全*/

 返回一个构造方法的数组，包含此对象所表示的类，已声明的所有构造方法。

public Field[] getDeclaredFields()/*[fi:ld]字段*/

throws SecurityException

返回一个字段的数组，包含此对象所表示的类或接口，自己定义的所有字段。不包括继承的字段。

public Method[] DeclaredMethods()/*['meθəd]方法*/

throws SecurityException

返回一个成员方法的数组，包含此对象所表示的类或接口，自己定义的所有成员方法。不包括继承的方法。

public String getName()

返回此对象所表示的实体名称。

public Package getPackage()

返回此对象所属的包。

public boolean isArray()

判断此对象是否表示一个数组。

public T newInstance()

throws InstantiationException,IllegalAccessException

/*['instns]实例[in'stænʃieiʃn]实例化[i'li:gl]非法['ækses]访问*/

调用此对象所对应类的空参数构造函数，创建一个新实例。

public URL getResource(String name)/*[ri'sɔ:s]资源*/

返回带有指定名称资源的地址。一般用于加载配置文件。

URL：Uniform Resource Locator

/*['ju:nifɔ:m]统一[ri'sɔ:s]资源[ləu'keitə]定位器*/

public <A extends Annotation> AgetAnnotation(Class<A> annotationClass)

如果此类存在指定类型的注解，则返回这些注解。

public boolean isAnnotationPresent(Class<? extendsAnnotation> annotationClass)

/*[ænə'teiʃn]注解['preznt]现在的*/

判断此类是否带有指定类型的注解。

❸AccessibleObject/*['æksesiəbl]可访问*/类

public class AccessibleObject

extends Object

implements AnnotatedElement/*['ænəteitid]带注解的['elimnt]元素*/

1，此类是Field、Method、Constructor对象的基类。

2，成员方法(部分)

public void setAccessible(boolean flag)

throws SecurityException/*[si'kjuərəti]安全*/

设置Java语言是否取消此对象的访问检查。若取消检查则设为true，此时就称为暴力反射，可以进行强制访问。

❹Constructor<T>/*[kən'strʌktə]构造函数*/类

public final Class Constructor<T>

extends AccessiableObject

implements GenericDeclaration,Member

/*['æksesiəbl]可访问[dʒi'nerik]泛型[deklə'reiʃn]声明['membə]成员*/

1，此类用于描述构造方法。

2，每个构造方法，需要通过其参数列表来确定。

3，成员方法(部分)

public T newInstance(Object... Initargs)

throws InstantiationException,IllegalAccessException,

IllegalArgumentException,InvocationTargetException

/*['instns]实例[i'nit]初始化['a:gjumnts]参数[in'stænʃieiʃn]实例化[i'li:gl]非法['ækses]访问[invə'keiʃn]调用['ta:git]目标*/

使用此构造方法，创建一个其所属类的新实例。

❺Field/*[fi:ld]字段*/类

public final class Field

extends AccessibleObject

implements Member/*['membə]成员*/

1，此类用于描述字段。

2，每个字段的具体取值，需要从该类的具体对象上获取。静态除外。

3，成员方法(部分)

public Object get(Object obj)

throws IllegalArgumentException,IllegalAccessException

返回指定对象的此字段的取值。如果此字段为静态字段，obj可以为null。

public void set(Object obj,Object value)

throws IllegalArgumentException,IllegalAccessException

将指定的值，赋值给指定对象的这个字段。

❻Method/*['meθəd]方法*/类

public final class Method

extends AccessibleObject

implements GenericDeclaration,Member

/*['æksesiəbl]可访问[dʒi'nerik]泛型[deklə'reiʃn]声明['membə]成员*/

1，此类用于描述成员方法。

2，每一个方法，都要通过具体的对象来调用。静态除外。

3，成员方法(部分)

public Object invoke(Object obj,Object... args)

throws IllegalAccessException,IllegalArgumentException,

InvocationTargetException

/*[in'vəuk]调用[i'li:gl]非法['a:gjumnt]参数[invə'keiʃn]调用['ta:git]目标*/

调用指定对象的此方法，并传递相应的参数。如果则此方法为静态方法，第一个参数可以为null。

❼Array类

public final class Array

extends Object

1，此类提供了动态创建和访问Java数组的方法。

2，对数组的操作，仅可以进行扩展转换，不可以发生收缩转换。

3，成员方法(部分)

public static Object get(Object array,int index)

throwsIllegalArgumentException,ArrayIndexOutOfBoundsException

返回指定数组，指定角标处的值。此方法有基本数据类型数组的重载形式。

public static int getLength(Object array)

throws IllegalArgumentException

返回指定数组的长度。

public static void set(Object array,int index,Objectvalue)

throwsIllegalArgumentException,ArrayIndexOutOfBoundsException

将指定数组，指定角标处的值，更改为指定的值。此方法有基本数据类型数组的重载形式。

❽反射的弊端和好处

弊端：

反射需要缓存一些数据，比较占用资源，会造成性能的下降。

好处：

1，可以实现对被操作对象的动态修改。

2，可以通过暴力反射，获取最大访问权。

3，可以优化可变参数。

4，反射的主要作用就是实现框架功能。

❾框架/*Framework['freimwə:k]*/

1，框架的概念

类比：对于房子而言，要先建造出毛坯房，然后再做装修，并且可以通过不同的装修风格，获得不同的使用体验。毛坯房就是一个框架，所有的装修材料都要附着在毛坯房上。从面向对象的角度来看，是毛坯房接收了这些装修材料，让自己具备更适宜的居住环境。

概念：框架就是一个可复用的设计构件，同时规定了应用的体系结构，并且具备可扩充性。它具备了某一应用领域的底层服务，是一种半成品，可以按照制定好的规则，被不断地完善和改善。

2，框架与工具类

工具类是被使用者调用，框架是调用使用者提供的类。

3，框架要解决的核心问题

先有框架，而后才会补充某些并不确定内容。这时就只能够通过反射，调用后来提供的数据内容。

4，反射中的配置文件

文件一定要使用完整的路径。完整的路径并不是硬编码，而是运算出来的。

在使用Eclipse时，其会自动将源文件目录下的被使用的非java文件，复制一份到字节码文件的目录中。这时，可以将配置文件直接放在源文件下即可。

❿内省/*Introspector[intrə'spektə]*/

1，主要用来对JavaBean进行操作。在JavaEE开发中，经常要使用JavaBean。

2，JavaBean是一种特殊的Java类，该类中的field必拥有两个方法：getField()和setField(Type value)。

3，JavaBean的field：

JavaBean的field是通过其方法名推断出来的，其field的命名规则为：当方法名中的field首字母为小写时，保持原样；当其中的field首字母为大写，并且第二个字母为小写时，将首字母改为小写；当其中的field首字母为大写，并且第二个字母也为大写时，依然保持首字母为大写。

4，JavaBean的两个方法：

getField方法是公有的，并且有返回值但没有参数，方便于调用者获取相应字段的值。

setField方法是公有的，并且有参数但没有返回值，方便于调用者修改相应字段的值。

5，如果要在两个模块之间传递多个信息，就可以将这些信息封装到一个JavaBean中，这种JavaBean的实例通常称之为值对象(Value-Object，简称VO)。JavaBean中的字段都是私有的，通过getter和setter方法访问该字段，并不在意该字段的访问权限和实现方式，这一点同暴力反射类似。

6，PropertyDescriptor/*['prɔpəti]属性[di'skriptə]描述符*/类

public class PropertyDescriptor

extends FeatureDescriptor/*['fi:tʃə]特征*/

构造方法(部分)：

public PropertyDescriptor(StringpropertyName,Class<?> beanClass)

throws IntrospectionException/*[intrə'spekʃn]内省*/

跟据指定的类，创建该类指定名称字段的属性描述对象。

成员方法(部分)：

public Method getReadMethod()

获取此属性的getter方法。

public Method getWriterMethod()

获取此属性的setter方法。

7，Introspector/*[intrə'spektə]内省*/类

public class Introspector

extends Object

此类是一个工具类，用于构建目标类的BeanInfo对象。

成员方法(部分)：

public static BeanInfo getBeanInfo(Class<?>beanClass)

throws IntrospectionException

/*[bi:n]特殊的类['infəu]信息[intrə'spektə]内省*/

构建并返回指定类的BeanInfo对象。

8，BeanInfo接口

public Interface BeanInfo

此接口用于描述一个类的方法、属性、事件等显式信息。

public PropertyDescriptor[] getPropertyDescriptor()

/*['prɔpəti]属性[di'skriptə]描述符*/

获得此对象所代表的类的，所有属性的描述信息。

9，FeatureDescriptor/*['fi:tʃə]特征*/类

public class FeatureDescriptor

extends Object

此类是PropertyDescriptor、EventSetDescriptor、MethodDescriptor等的公共基类。它支持一些可以设置和检索任意的内省描述符的公共信息。

成员方法(部分)：

public String getName()

获取此特性的编程名称。

10，内省工具类(BeanUtils)/*[bi:n]特殊的类[ju'tilz]工具*/

此工具包是阿帕奇(Apache[ə'pæʃ])提供的，可以简化对JavaBean的操作。

需要安装beanutils和logging。/*['lɔgiŋ]日志*/

此工具类支持对属性链的操作。

BeanUtils以字符串的形式操作属性的值，PropertyUtils以字段的原始类型操作属性的值。

⑥注解(annotation[ænə'teiʃn])

❶注解简介

1，注解是开发人员和开发工具的一种交流方式。

2，注解是一种特殊的接口。每使用一个注解，就会创建一个对应接口的实例。

3，注解在使用时以@开头。

4，注解可以加在包、类、字段、方法、方法的参数以及局部变量上。

5，注解作为一种标记，在被标记为RUNTIME状态时，可以通过反射被外部获得。

6，注解的注解，就是元注解。

❷简单注解实例

1，@SuppressWarnings(“deprecation”)

/*[sə'pres]废止['wɔ:niŋs]警告[depri'keiʃn]反对*/

将被注解的对象标记为，在编译时不再做出风险提示。

2，@Deprecated/*['deprəkeitid]弃用*/

将被注解的对象标记为已过时。

3，@Override/*[əuvə'raid]重写*/

将方法标记为重写。

❸注解的应用

1，定义格式：

@Retention(RetentionPolicy.RUNTIME)

/*[ri'tenʃn]保持['pɔləsi]策略['rʌntaim]运行时间*/

public @Interface A{}

2，使用格式：

@A

class B{}

3，反射操作：

class C{

if(B.class.isAnnotationPresent(A.class))/*[ænə'teiʃn]注解['preznt]现在的*/

{A a = (A)B.class.getAnnotation(A.class)；}}

❹一些注解

1，ElementType枚举

public enum ElementType

extends Enum<ElementType>

此枚举的对象与Target/*['ta:git]目标*/元注解一起使用，以指定在什么情况下，使用某一注解类型是合法的。

枚举对象：

ANNOTATION TYPE(注解类型)/*[ænə'teiʃn]注解[taip]类型*/

CONSTRUCTOR(构造方法)/*[kən'strʌktə]构造方法*/

FIELD(字段，包括枚举对象)/*[fi:ld]字段*/

LOCAL VARIABLE(局部变量)/*['ləukl]局部['veəriəbl]变量*/

METHOD(方法)/*['meθəd]方法*/

PACKAGE(包)/*['pækidʒ]包*/

PARAMETER(参数)/*[pə'ræmitə]参数*/

TYPE(类、接口、枚举或注解)/*[taip]类型*/

成员方法：

public static ElementType valueOf(String name)

返回带有指定名称的该类型的枚举对象。字符串要与Type名字严格相同。

public static final ElementType[] values()

按顺序，返回该枚举类型的，包含其所有枚举对象的数组。

2，RetentionPolicy/*[ri'tenʃn]保留['pɔləsi]策略*/枚举

public enum RetentionPolicy

extends Enum<RetentionPolicy>

此枚举的对象，表示保留注解的不同策略，与Retention元注解一起使用。

枚举对象：

CLASS(存在于类文件中，运行时丢弃，默认的策略)

RUNTIME(保持存在至运行时期，通过反射可以读取)

SOURCE(存在于源文件中，编译后丢弃)/*[sɔ:s]源*/

成员方法：

public static RetentionPolicy valueOf(String name)

返回带有指定名称的该类型的枚举对象。字符串要与Type名字严格相同。

public static final RetentionPolicy[] values()/*[ri'tenʃn]保留['pɔləsi]策略*/

按顺序，返回该枚举类型的，包含其所有枚举对象的数组。

3，Documented/*['dɔkjuməntid]记录*/注解

@Documented

@Retention(value=RUNTIME)

@Target(value=ANNOTATION TYPE)

public @interface Documented

使用此注解后，被注解的内容将允许被文档化。注解提取。

4，Inherited/*[in'heritid]继承*/注解

@Documented

@Retention(value=RUNTIME)

@Target(value=ANNOTATION TYPE)

public @interface Inherited

使用此注解后，查询被注解的内容时，将可以溯源到Object。注解继承。

5，Retention/*[ri'tenʃn]保留*/注解

@Documented

@Retention(value=RUNTIME)

@Target(value=ANNOTATION TYPE)

public @interface Retention

使用此注解后，能够标识被注解内容的保留策略。注解策略。

成员方法：

public abstract RetentionPolicy value()；

6，Target/*['ta:git]目标*/注解

@Documented

@Retention(value=RUNTIME)

@Target(value=ANNOTATION TYPE)

public @interface Target

使用此注解后，可以限定被注解的类型。注解限定。

成员方法：

public abstract ElementType[] value()；

❺注解的属性

1，注解的属性，通过抽象方法来设置，该方法有返回值类型。使用注解时，在其后面加一个小括号，为该方法赋值。

2，如果属性的名字是value，并且只有一个属性，这时可以在小括号中只是写出该值即可，不必再加上属性的名字。

3，可以给属性设置默认值，在抽象方法的小括号和分号之间，通过default+值来指定。

4，在使用注解时，所有的属性都要有值才可以，相当于所有的抽象方法都被重写。

5，在使用反射来取出注解的属性时，可以通过注解对象，直接调用其相对应的方法即可。

6，对于注解的属性，其取值是一个数组。当该注解的属性只取一个值时，可以直接赋值，不必再加上大括号。

7，属性的类型，可以是基本数据类型、String、Class、Class的属性、enum、annotation以及之前这些类型的数组类型。

⑦泛型(generic[dʒi'nerik])

❶泛型的特性

1，泛型可以将运行期的异常，提前到编译期，提高了程序的编译性能。

2，泛型的使用，可以省去大部分的类型转换操作。

3，泛型只是出现在源文件中，在被编译器编译过之后，就会被去掉，这时就称为去类型化。

4，参数化类型(带泛型)与原始类型(没有泛型)可以互相兼容。

5，参数化类型不考虑继承关系，要严格相等才可以赋值。

6，创建数组实例时，不可以使用参数化类型。

7，只有引用数据类型，才可以充当泛型的参数。

❷问号通配符

1，？可以表示任意类型的参数。以？为参数类型的对象，只可以调用与参数类型无关的方法，不能够调用与参数类型有关的方法。

2，向上限定符extends，指定上边界。

3，向下限定符super，指定下边界。

4，限定符总是包含自己。

❸泛型使用

1，泛型为T的方法，可以通过return (T)obj，将参数obj的类型还原。

2，泛型方法的返回值可以为void。

3，泛型方法允许使用，与元素类型相关的操作，这一点优于通配符。除此之外，在相同情形下，通配符的方式更有效。

4，定义泛型方法时，对返回值的呼应优先于参数列表。

5，集合的泛型，具有限定性。

6，类上的泛型应用于整个类，方法上的泛型应用于单个方法。当两者存在冲突时，方法的泛型优先于类的泛型。

7，静态方法只能使用方法的泛型。静态优先于对象存在，而类的泛型由对象确定。

❹泛型与反射

1，泛型经过编译之后，就会被擦除，不能够通过其对象来获取。

2，找到一个使用其对象的方法，该方法的参数应该具有需要的泛型。

3，通过反射获取该方法的参数列表。Java1.5的新特性，可以返回带泛型的参数列表。

4，将需要的参数强转为ParameterizedType类型，通过该接口的方法getActualTypeArguments，可以获得该参数的泛型列表。

⑧类加载器(ClassLoader[kla:s]['ləudə]加载器)

❶类加载器，就是加载类的一种工具。加载的是该类的字节码文件。

❷JVM中可以安装多个类加载器，系统默认三个主要的类加载器，每个类加载器负责加载特定位置的类：BootStrap、ExtClassLoader、AppClassLoader。

/*[bu:t]引导[stræp]带exterior[ik'stiəriə]外部[kla:s]类['ləudə]加载器application[æpli'keiʃn]应用程序*/

❸由于类加载器也是Java类，其它Java类的类加载器本身，也要被类加载器所加载，这显然必须要让第一个类加载器并不属于Java类，它就是BootStrap。Java系统提供的类都使用这个类加载器。

BootStrap被内置在JVM的内核中，JVM一旦被启动，就会运行它。BootStrap是用C++语言编写的二进制代码。

❹JVM中的所有类加载器，使用具有继承关系的树形结构进行组织。在实例化每个类加载器对象时，需要为其指定一个父类加载器对象，或者使用默认的系统类加载器作为其父类加载器。

❺类加载器的关系和功能

类加载器(由下向上继承)

可以加载的目录及文件

BootStrap(加载系统类)

JRE/lib/rt.jar

ExtClassLoader(加载扩展类)

JRE/lib/ext/*.jar

AppClassLoader(加载应用类)

classpath指定的所有.jar或.class

自定义

自定义

自定义目录下的*.class

❻委托机制

1，当前线程的类加载器，先去加载线程中的第一个类。一个线程可以通过setContextClassLoader(classLoader)方法，来设置本线程的类加载器。

/*['kɔntekst]上下文[kla:s]类['ləudə]加载器*/

2，如果将要被加载的类引用了另一个类，则JVM将使用此类的加载器，来加载被其引用的那个类。此处并不属于委托机制。

3，也可以单独使用一个类加载器，来加载指定的类。使用的方法为classloader.loadClass(className)，此时的className必须是带包名的类名。

4，在加载一个类时，类加载器会先向上委托其父类去加载，此时将会层级递延至最顶端；如果顶层的类加载器没有找到相关的类文件，则将加载的任务退回其子类，若顶层的子类依然找不到相关的文件，则会顺延至下一级去加载，一直重复此动作直到加载的发起者，若发起者也找不到相关的文件，就会抛出无此文件异常(ClassNotFoundException)。此处的加载方式就是委托机制。

5，委托机制的优势：可以实现集中管理，并优化加载动作，不会再次加载已经被加载过的类。

6，委托机制的缺陷：顶层的类加载器很繁忙。

❼ClassLoader类

public abstract class ClassLoader

extends Object

1，类加载器是负责加载类的对象。其加载原理是，将指定类名转换成一个类文件路径，然后从文件系统中读取该字节码文件。

2，数组的class对象不是由类加载器创建的，而是由JVM运行时根据需要自动创建的。数组的类加载器，与其元素类型的类加载器是相同的；如果该元素属于基本数据类型，则该数组没有类加载器。

3，自己定义的类加载器必须继承此类，让其具备可加载性。此处类似于继承Throwable具备可抛性，继承Thread或实现Runnable具备可独立执行性。

4，自定义类加载器时，只需重写findClass方法。

5，成员方法(部分)

protected Class<?> findClass(String name)

throws ClassNotFoundException

使用此加载器，查找拥有指定类名的类。当父类的加载器不能实现加载动作时，此方法将在当前加载器所指定的目录中，寻找目标文件。

public Class<?> loadClass(String name)

throws ClassNotFoundException

使用此加载器，加载拥有指定类名的类。此方法履行委托机制。

public final ClassLoader getParent()

返回被此加载器所委托的父类加载器。

protected final Class<?> defineClass(Stringname,byte[] b,int off,int length)

throws ClassFormatError/*[di'fain]定义*/

将指定的字节数组转换为，表示指定类名的Class类的实例。

❽自定义类加载器

1，继承ClassLoader。

2，重写findClass方法。

3，调用defineClass方法，实现字节码数据与二进制数据的转换。

4，类加载器的指定查找目录，可以过构造方法进行传递。

5，如果该类的.class文件已被加密，还要编写解密的方法。

6，对于被加密过其字节码文件的类，其类名不能够出现在程序中。这时可以通过让它继承一个类，使用多态的方式，指向该类的对象。

7，若要让自定义的加载器，实现定向加载，则必须保证被加载的文件，只存在于该加载器的加载目录中，要确保文件的唯一性。这是因为自定义的加载器，处于加载的最后序列。

❾Web开发中的加载器使用

在做Web开发时，加载器的数量比较多，如果出现了加载失败的情况，则应该是被加载的类被前置了。解决方法是，将类恢复到后置状态，或者将所有相关联的类一起前置。前置，即被父类的加载器所加载。

❿JAR与EAR

JAR：Java Archive/*['dʒa:və]['a:kaiv]归档文件*/

此文件格式是与平台无关的文件格式，它允许将许多文件组合成一个压缩文件。

EAR：Enterprise Archive/*['entəpraiz]企业['a:kaiv]归档文件*/

为JavaEE应用程序创建的JAR文件，就称为EAR文件，即企业JAR文件。

JAR文件格式以ZIP文件格式为基础。其不仅可以用于压缩和发布，还用于部署和封装库、组件以及插件程序，并可以被编译器和JVM这样的工具直接使用。在JAR中包含有特殊的文件，如manifests/*['mænifest]货物清单*/和部署描述符，用于指示工具应该如何处理特定的JAR文件。

JAR文件格式的特点：拥有更高的安全性、可以减少下载的时间、提供压缩功能、可以用于Java平台的扩展、提供密封包的功能、可以提取版本信息、依随Java执行的可移植性。

⑨代理(Proxy['prɔksi])

❶概念

类比：从总经销商那里买商品，和从分销商那里买商品，都能实现同样的目的，就是得到了想要的商品。这时的分销商就是总经销商的代理。

对于一个实现了接口的类，如果想扩充它的功能，就可以再创建一个新的类同样实现这个接口，其中的方法调用的是旧类的同名方法，新类的方法中还可以定义一些需要的系统功能，从而实现对旧类功能的扩展。这时的新类就是旧类的代理。在程序中使用的是多态的方式，来调用目标类的对象，从而可以实现对被调用者的自由切换，切换行为通过修改配置文件的方式实现。

❷AOP

AOP：Aspect Oriented Programming(面向方面编程)

/*['æspekt]方面['ɔ:rientid]面向['prəugræmiŋ]编程*/

1，交叉业务

在一个类的多个方法中，都存在一部分相同的功能，每个相同的功能与这些方法是交叉存在的。将这些相同的功能看做是业务，就称之为交叉业务。

2，模块

把交叉业务进行封装，就变成了一个模块。AOP的目标，就是将交叉业务模块化。

3，实现原理

把交叉业务从方法中提取出来，放在方法的前面或后面执行，得到的执行效果将是一样的。对交叉业务的模块化封装，可以通过代理来实现。

4，AOP就是以代理为基础的。

❸动态代理

1，系统中有大量的类需要实现代理功能，完全通过静态代理来实现是不可能的。

2，JVM在运行时期，可以动态的生成类的字节码。这种动态生成的类往往被用作代理类，即动态代理。

3，JVM生成的动态类，必须实现一个或多个接口。所以，JVM生成的动态类，只能用作具有相同接口的目标类的代理。

4，CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理。所以，如果要为一个没有实现接口的类，生成动态代理类，就可以使用CGLIB库。

5，对于代理类中的方法，除了要调用目标的相应方法，并返回和目标相同的结果之外，还可以在代理方法中加上系统功能代码。

6，在代理类方法中添加系统功能的四种位置：在调用目标方法之前；在调用目标方法之后；在调用目标方法的前后；在处理目标方法异常的catch块中。

❹Proxy/*['prɔksi]代理*/类

public class Proxy

extends Object

implements Serializable

成员变量：

protected InvocationHandler h/*[invəu'keiʃn]调用['hædlə]处理者*/

此代理实例的调用处理程序。

构造方法：

protected Proxy(InvocationHandler h)

使用指定的调用处理程序，构造一个动态代理类实例。

成员方法(部分)：

public static Class<?> getProxyClass(ClassLoaderloader,Class<?>... interfaces)

throws IllegalArgumentException

使用指定的类加载器和接口数组，构造一个动态代理类，并返回它的字节码对象。根据接口组合不同的排列顺序，会创建出不同的动态代理类。

public static Object newProxyInstance(ClassLoaderloader,Class<?>[] interfaces,InvocationHandler h)

throws IllegalArgumentException

创建并返回一个动态代理实例。

❺InvocationHandler/*[invəu'keiʃn]调用['hædlə]处理者*/接口

public Interface InvocationHandler

1，成员方法

public Object invoke(Object proxy,Method method,Object[]args)

throws Throwable

在代理实例上，处理方法的调用并返回其结果。在调用代理实例的方法时，大部分都是在调用此方法。Object中公共的非最终方法，理论上在所有的代理接口之前，但是其中的hashCode、equals和toString方法，将传递给被代理对象。

2，使用方式

共享数据：定义在方法的外面。方法中的变量是局部变量，每次调用都将被独享。此处一般定义被代理的实例，即目标对象。

返回值：使用反射的方式，返回目标方法的返回值。

添加系统功能：将返回值封装在一个变量中，在该变量的前面或后面添加需要的功能，再return该变量。

过滤功能：在使用反射的方式，调用目标方法之前，可以过滤或修改传递的参数；调用目标方法之后，可以过滤或修改返回值。

❻动态代理的应用

1，使用动态代理的目的，就是为随机的目标类，添加并不确定的系统功能。

2，把创建代理对象的方式封装成一个方法。

3，将invoke方法中的目标抽取出来，再以参数的形式传递给该方法。

4，将invoke方法中需要添加的系统功能，封装成一个对象的方法，将这个对象作为一个参数传递给它。

5，封装对象的时候，要让对象的所属类实现一个接口，用接口来定义需要传递的参数类型。使用多态的特性，可以随时替换传入的具体对象。接口名一般定义为Advice/*[əd'vais]建议*/。

6，将系统功能封装进对象的好处是，可以随时替换对象，实现功能的切换。

❼Spring

1，一种AOP框架。

2，原理

一个类加工厂(BeanFactory)，可以按照指定的类名，创建该类的对象(getBean)。创建的方式有两种，通过对名称的判断，一是直接创建该类的对象；一是创建该类的代理对象。

3，实现方式

定义两个类，BeanFactory和ProxyBeanFactory。

对于BeanFactory，通过构造方法接收一个输入流，获取配置文件的内容。该类的方法，可以根据被传递的字符串参数，创建一个Bean对象。通过对Bean对象的判断，决定是返回该Bean对象，还是返回该对象的代理对象。

对于ProxyBeanFactory，用于创建代理对象。该类中有两个成员变量，分别表示代理的目标和封装系统功能的对象，它们都可以被动态设置。该类中的方法，可以使用这两个成员变量，创建并返回目标的代理对象。

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------