------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
一、java1.5新特性：
增强for循环
格式：
//增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器?
for(元素类型 变量名 : Collection集合 & 数组 ) { }
高级for循环和传统for循环的区别：?
高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，
在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。
如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。
高级for循环可以遍历map集合吗？
不可以。但是可以将map转成set后再使用foreach语句。
1)、作用：对存储对象的容器进行迭代： 数组 collection map
2)、增强for循环迭代数组：
String[] arr = {"a", "b", "c"};//数组的静态定义方式，只适用于数组首次定义的时候
for(String s : arr)
{
System.out.println(s);
}
3)、单列集合 Collection：
List list = new ArrayList();
list.add("aaa");
//增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？
能
for(Object obj : list)
{
String s = (String) obj;
System.out.println(s); }
4)、双列集合 Map：
Map map = new HashMap();
map.put("a", "aaa");
// 传统方式：必须掌握这种方式
Set entrys = map.entrySet();
//1.获得所有的键值对Entry对象
iter = entrys.iterator();
//2.迭代出所有的entry
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
String key = (String) entry.getKey();
//分别获得key和value
String value = (String) entry.getValue();
System.out.println(key + "=" + value); }
// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；
Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，
java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
for(Object obj : map.entrySet())
{
Map.Entry entry = (Entry) obj; // obj 依次表示Entry
System.out.println(entry.getKey() + "=" + entry.getValue()); }
5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；
可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
6)、增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；
int[] arr = {1,2,3};
for(int num : arr) {
num = 0; //不能改变数组的值
}
System.out.println(arr[1]);
可变参数： ...
用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。
和以前接收数组不一样的是：
以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。
现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。
所以简化了用户的书写，少了调用者定义数组的动作。
如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。
如果要获取多个int数的和呢？
可以使用将多个int数封装到数组中，直接对数组求和即可。
可变参数的特点：相当于一个可边长度的数组。
1.只能出现在参数列表的最后
2.位于变量类型和变量名之间，前后有无空格都可以。
3.调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。
静态导入：
当类名重名的时候，需要制定具体的包名
当方法重名时，指定具备所属的对象或者类
import static java.util.Collections.*; //导入了Collections类中的所有静态成员
二、自动装箱
自动拆装箱：
java中数据类型分为两种 ：
基本数据类型
引用数据类型(对象)
在 java程序中所有的数据都需要当做对象来处理，针对8种基本数据类型提供了包装类，如下：
int --> Integer
byte --> Byte
short --> Short
long --> Long
char --> Character
double --> Double
float --> Float
boolean --> Boolean
jdk5以前基本数据类型和包装类之间需要互转：
基本---引用 Integer x = new Integer(x);
引用---基本 int num = x.intValue();
1)、Integer x = 1;
x = x + 1;经历了什么过程 装箱----拆箱----装箱；
2)、为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小-128~127 一个字节的大小；
3)、String池：Java为了优化字符串操作 提供了一个缓冲池；
三、枚举
枚举：
关键字 enum
枚举就是要让某个类型的变量的取值只能为若干固定值之中的一个。
是一个特殊的类，其中的每一个元素都是该类的一个对象。
注意 : 因为不能New 枚举的实力，所以枚举不能继承其他类，也不能被其他类继承。
为什么要有枚举？
问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。
1、私有的构造方法。
2、每个元素分别用一个公有的静态成员变量表示。
可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类
enum TrafficLamp{
/**
* 对于这道题目而言，使用的其实是匿名对象内部类！
* 枚举最简单的创建对象方法：RED，YELLOW，GREEN
* 对于普通的类而言，创建对象：Person p = new Person();
*
*/
RED(30){
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},
YELLOW(40){
@Override
public TrafficLamp nextLamp() {
return GREEN;
}
},
GREEN(45){
@Override
public TrafficLamp nextLamp() {
return RED;
}
};
public abstract TrafficLamp nextLamp();
private int time;
private TrafficLamp(int time){
this.time = time;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
}
public class EnumDemo4 {
public static void main(String[] args) {
System.out.println(TrafficLamp.RED.nextLamp());
System.out.println(TrafficLamp.RED.nextLamp().getTime());
}
}
四、反射
反射是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都只能都调用它的任意一个
方法和属性，这种动态获取的信息一级动态调用对象的方法的功能呢个称为java 的反射机制。
反射其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，
并将字节码文件中的内容都封装成对象，这样便于操作这些成员。就是把JAVA类中的各种成分反射成为相应的JAVA类
简单说：反射技术可以对一个类进行解剖。
如果想要对指定名称的字节码文件进行加载
反射的好处：大大的增强了程序的扩展性。
反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。
得到类的字节码文件相同，这三种方式。
1.Class cls1=类名.class 相对简单，还是需要明确类名
2.cls1.getclass();必须要明确具体的类，并创建对象
3.class.forName("完整的类名（带包名）");
9个预定义的Class实例对象。
Integer.class包装类的字节码
Integer.TYPE Integer中基本类型的字节码
int.class==Integer.TYPE
数组
class.isPrimitive();
class.isArray();
只要在源程序中出现的类型，都有各自的Class实例对象，例如 int[] void 等等
创建类的对象
String name="com.dsa.类名";
寻找该名称类文件，并加载进内存，并非产生class对象
Class clazz=Class.forName(name);
产生该类的对象
Object obj=clazz.newInstance();
得到某一个指定构造方法
Constructor constructor= Class.forName("").getConstructor(String.class);
创建实例对象
Object obj=constructor.newInstance("abc");
Constructor 构造方法：代表某个类中的一个构造方法。
得到某个类中所有的构造方法
Constructor constructors[]= Class.forName("").getConstructors();;
得到某一个构造方法
Constructor constructor= Class.forName("").getConstructor(StringBuffer.class);
Constructor constructor= Class.getConstructor(StringBuffer.class);
创建实例对象
String str=(String) constructor.newInstance(new StringBUffer("abc"));
调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法：
String obj=（String）Class.forName("java.lang.String").newInstance();
先得到默认的构造方法，然后用该构造方法创建实例对象。
成员变量 Filed类 代表某个类中的一个成员变量
对一个类进行反射。
ReflectPoint pt1=new ReflectPoint(3,5);
Filed filedy=pt1.getclsss().getFiled("Y");//只代表哪个对象
Filed filedy=pt1.getclsss().getDeclaredField("x")//获取对象不管是私有还是被保护的
filedy.setAccessible(true);//设置可以访问，暴力反射
filedy.get(pt1)//取出Y的值
将字段中的b全变成a
Field[] fields=obj.getClass().getFields();//获取全部对象
for(Field field :fields){
if(field.getType()==String.class){//如果是字符串
String oldValue = (String)field.get(obj);//获取字符串内容
String newValue = oldValue.replace('b','a');将字符串内容替换
field.set(obj,newValue);将新值赋给对象
Method类 成员方法的反射。
获取成员方法
反射形式：
Method methodCharAt = String.class.getMethod("charAt"--方法名,int.class--这是参数类型，如果是空参函数则是 null);
Object obj=clazz.newInstance();
methodCharAt.invoke(str1,1);
数组的反射
Class clazz=obj.getClass();
if(clazz.isArray()){
int len=array.getLength(obj);
for(int i=0;i<len;I==){
sopArray.get(obj,i))
}
}
反射来获取泛型信息
通过指定对应的Class对象，程序可以获得该类里面所有的Field，不管该Field使用private 方法public。获得Field对象后都可以使用getType()来获取其类型。
Class<?> type = f.getType();//获得字段的类型
但此方法只对普通Field有效,若该Field有泛型修饰,则不能准确得到该Field的泛型参数,如Map<String,Integer>;
为了获得指定Field的泛型类型，我们采用：
Type gType = f.getGenericType();得到泛型类型
然后将Type对象强转为ParameterizedType,其表示增加泛型后的类型
Type getRawType()//返回被泛型限制的类型;
Type[] getActualTypeArguments()//返回泛型参数类型;
利用反射来获取泛型的类型（泛型信息）
步骤：
获取当前类
获取目标字段
获取包含泛型类型的类型 getGenericType()
强转至子类ParameterizedType 因为Type没有任何对应的方法
获得泛型真正的类型 getActualTypeArguments()
例子
package junereflect624;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
public class GetGenericTypeDemo14 {
Map<String,Integer> map = new HashMap<String,Integer>();
public static void main(String[] args) throws Exception {
Class c = GetGenericTypeDemo14.class;
Field f = c.getDeclaredField("map");
System.out.println(f);
System.out.println(f.getName());//map
// Class<?> getType() 返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
Class cl = f.getType();
System.out.println("获得其类型："+cl);
//获得其类型：interface java.util.Map
/**
* Type getGenericType() 返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。
* Type是Class的接口;
*/
Type t = f.getGenericType();//包含泛型的类型
System.out.println(t);
//java.util.Map<java.lang.String, java.lang.Integer>
/**
* Type这个类里面没有任何的方法，所以需要调用子类的方法，那么大的类型转到小的类型，需要强转！
*/
ParameterizedType pt = (ParameterizedType)t;//强转到其子类
/**
* Type[] getActualTypeArguments()
返回表示此类型实际类型参数的 Type对象的数组。
Type getOwnerType()
返回 Type 对象，表示此类型是其成员之一的类型。
Type getRawType()
返回 Type 对象，表示声明此类型的类或接口。
*/
t = pt.getRawType();//类型的类或接口
System.out.println(t);
Type[] ts = pt.getActualTypeArguments();
for (Type type : ts) {
System.out.println(type);
/**
* class java.lang.String
class java.lang.Integer
*/
}
}
}
打印：
java.util.Map junereflect624.GetGenericTypeDemo14.map
map
获得其类型：interface java.util.Map
java.util.Map<java.lang.String, java.lang.Integer>
interface java.util.Map
class java.lang.String
class java.lang.Integer
我的总结：多查找api，参考api中方法使用的限制，比如是否静态、返回值类型等。
五、JavaBean与内省
1初识JavaBean与内省
内省：IntroSpector
·JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。
·如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。
·JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，则不用管。如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，也不用管。去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。
例如：
setId()的属性名：id
isLast()的属性名：last
setCPU的属性名：CPU
getUPS的属性名：UPS
总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。
·一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！
好处如下：
1-在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作。
2-JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。
2. 对JavaBean的简单内省操作
通过内省的方式对ReflectPoint对象中的成员变量进行读写操作。
示例：
ReflectTest.java
package com.itheima.day1;
public class ReflectPoint {
private int x ;
private int y ;
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x ;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y ;
}
public void setY(int y) {
this.y = y;
}
}
ReflectTest.java
package com.itheima.day1;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPoint pt1 = new ReflectPoint(3, 5);
String propertyName = "x";
PropertyDescriptor pd1 = new PropertyDescriptor(propertyName, pt1.getClass());
Method readMethod = pd1.getReadMethod();
Object retVal = readMethod.invoke(pt1);
System. out.println(retVal);
//结果：3
PropertyDescriptor pd2 = new PropertyDescriptor(propertyName, pt1.getClass());
Method writeMethod = pd2.getWriteMethod();
Object value = 7;
writeMethod.invoke(pt1,value);
System. out.println(pt1.getX());
//结果：7
}
}
六、注解
注解是java 的一个新的类型（与接口很相似），它与类、接口、枚举是在同一个层次，它们都称作为java 的一个类型（TYPE）。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。它的作用非常的多，例如:进行编译检查、生成说明文档、代码分析等。
JDK提供的几个基本注解
a. @SuppressWarnings
该注解的作用是阻止编译器发出某些警告信息。
它可以有以下参数:
deprecation：过时的类或方法警告。
unchecked：执行了未检查的转换时警告。
fallthrough：当Switch 程序块直接通往下一种情况而没有Break 时的警告。
path：在类路径、源文件路径等中有不存在的路径时的警告。
serial：当在可序列化的类上缺少serialVersionUID 定义时的警告。
finally：任何finally 子句不能完成时的警告。
all：关于以上所有情况的警告。
b. @Deprecated
该注解的作用是标记某个过时的类或方法。
c. @Override
该注解用在方法前面，用来标识该方法是重写父类的某个方法。
元注解
a. @Retention
它是被定义在一个注解类的前面，用来说明该注解的生命周期。
它有以下参数：
RetentionPolicy.SOURCE：指定注解只保留在一个源文件当中。
RetentionPolicy.CLASS：指定注解只保留在一个class 文件中。
RetentionPolicy.RUNTIME：指定注解可以保留在程序运行期间。
b. @Target
它是被定义在一个注解类的前面，用来说明该注解可以被声明在哪些元素前。
它有以下参数：
ElementType.TYPE：说明该注解只能被声明在一个类前。
ElementType.FIELD：说明该注解只能被声明在一个类的字段前。
ElementType.METHOD：说明该注解只能被声明在一个类的方法前。
ElementType.PARAMETER：说明该注解只能被声明在一个方法参数前。
ElementType.CONSTRUCTOR：说明该注解只能声明在一个类的构造方法前。
ElementType.LOCAL_VARIABLE：说明该注解只能声明在一个局部变量前。
ElementType.ANNOTATION_TYPE：说明该注解只能声明在一个注解类型前。
ElementType.PACKAGE：说明该注解只能声明在一个包名前。
注解的生命周期
一个注解可以有三个生命周期，它默认的生命周期是保留在一个CLASS 文件，但它也可以由一个@Retetion 的元注解指定它的生命周期。
a. java 源文件
当在一个注解类前定义了一个@Retetion(RetentionPolicy.SOURCE)的注解，那么说明该注解只保留在一个源文件当中，当编译器将源文件编译成class 文件时，它不会将源文件中定义的注解保留在class 文件中。
b. class 文件中
当在一个注解类前定义了一个@Retetion(RetentionPolicy.CLASS)的注解，那么说明该注解只保留在一个class 文件当中，当加载class 文件到内存时，虚拟机会将注解去掉，从而在程序中不能访问。
c. 程序运行期间当在一个注解类前定义了一个@Retetion(RetentionPolicy.RUNTIME)的注解，那么说明该注解在程序运行期间都会存在内存当中。此时，我们可以通过反射来获得
定义在某个类上的所有注解。
注解的定义
一个简单的注解：
public @interface Annotation01 {
//定义公共的final静态属性
.....
//定以公共的抽象方法
......
}
a. 注解可以有哪些成员
注解和接口相似，它只能定义final 静态属性和公共抽象方法。
b. 注解的方法
1.方法前默认会加上public abstract
2.在声明方法时可以定义方法的默认返回值。
例如:
String color() default "blue";
String[] color() default {"blue", "red",......}
3.方法的返回值可以有哪些类型
8 种基本类型，String、Class、枚举、注解及这些类型的数组。
c. 使用注解（参照下面的注解使用）
注解的使用
注解的使用分为三个过程。
定义注解-->声明注解-->得到注解
a. 定义注解（参照上面的注解定义）
b. 声明注解
1. 在哪些元素上声明注解
如果定义注解时没有指定@Target 元注解来限制它的使用范围，那么该注解可以使用在ElementType 枚举指定的任何一个元素前。否则，只能声明在@Target 元注解指定的元素前。
一般形式：
@注解名()
2. 对注解的方法的返回值进行赋值
对于注解中定义的每一个没有默认返回值的方法，在声明注解时必须对它的每一个方法的返回值进行赋值。
一般形式:
@注解名(方法名=方法返回值，、、、、、、)
如果方法返回的是一个数组时，那么将方法返回值写在{}符号里
@注解名(方法名={返回值1，返回值2，、、、、、、}，、、、、、、、)
3. 对于只含有value 方法的注解，在声明注解时可以只写返回值。
c. 得到注解
对于生命周期为运行期间的注解，都可以通过反射获得该元素上的注解实例。
1、声明在一个类中的注解
可以通过该类Class 对象的getAnnotation 或getAnnotations 方法获得。
2、声明在一个字段中的注解
通过Field 对象的getAnnotation 或getAnnotations 方法获得
3、声明在一个方法中的注解
通过Method 对象的getAnnotation 或getAnnotations 方法获得
总结
注解可以看成是一个接口，注解实例就是一个实现了该接口的动态代理类。
注解大多是用做对某个类、方法、字段进行说明，标识的。以便在程序运行期间我们通过反射获得该字段或方法的注解的实例，来决定该做些什么处理或不该进行什么处理
七、泛型
泛型：1.5后出现的新特性，解决了安全问题，是一个类型安全机制。
好处：
1.将运行时期转移到编译时期，方便程序员解决问题。提高了安全性。
2.避免了强制转换的麻烦
ArrayList<String> 泛型语法
Iterator<String>
格式：通过<>来定义要操作的引用数据类型。
什么时候使用泛型?
在集合中很常见，只要见到<>就要定义泛型。
<>是用来接收数据类型的泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。?
为什么??因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。?
在运行时，如何知道获取的元素类型而不用强转呢？?
泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，
在内部进行一次转换即可，所以使用者不用再做转换动作了。
7.1泛型的应用
泛型类
什么时候定义泛型类？
当类中操作的引用数据类型不确定的时候，
早起定义Object来完成扩展。
现在定义泛型来完成扩展。
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q);
{
this.q=q;
}
public QQ gerobject()
{
return q;
}
}
泛型方法：
泛型类定义的反应，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
class Demo
{
public <T> void show(T t)
{
}
}
静态方法泛型：静态方法不可以访问类上定义的泛型，如果静态方法操作的数据类型不确定，可以将泛型定义在方法上。
public static <W> void menthod(W w){}
泛型接口：
interface Inter<T>
{
void show(T t);
}
class InterImpl<R> implements Inter<R>
{
public void show(R r)
{
System.out.println("show:"+r);
}
}
案例：给限定Integer类型的集合 添加 String类型
ArrayList<Integer> collection2 = new ArrayList<Integer>();
System.out.println(collection1.getClass()==collection2.getClass());
collection2.add（“真暴力”）；//这句会报错
collection2.getClass().getMethod("add", Object.class).invoke(collection2, "真暴力");
System.out.println(collection2.get(0)); //结果却为真暴力
//已经限制集合中元素的类型为Integer，可用反射却能将String存入，为什么？ 这是因为泛型是给编译器用的，运行时就没有这些泛型信息了，这叫做“去泛型化”，所以可以通过反射，获取集合字节码加入非指定的类型。
}
}
7.2泛型限定
泛型限定
通配符<?>,也可以理解为占位符号
? extends E:可以接受E类型或者E的子类型 上限 <? extends E>
? super E:可以接受E或E的父类型 下限 <? super E>
上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，
E类型既可以接收E类对象，又可以接收E的子类型对象。?
下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。
泛型的细节：
1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；
2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；
原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；
ArrayList<String> al = new ArrayList<Object>(); //错 //
要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。
ArrayList<? extends Object> al = new ArrayList<String>(); al.add("aa"); //错
//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。
？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？
public static void method(ArrayList<? extends Object> al) {
al.add("abc"); //错
//只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。
}
7.3泛型总结
泛型总结
类型参数的类型推断（花了张老师两天的时间总结）
l 编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。
l 根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
1．当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：
swap(new String[3],3,4) à static <E> void swap(E[] a, int i, int j)
2．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：
add(3,5) à static <T> T add(T a, T b)
3．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：
fill(new Integer[3],3.5f) à static <T> void fill(T[] a, T v)
4．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型， 并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
int x =(3,3.5f) à static <T> T add(T a, T b)
5．参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(new Integer[5],new String[5]) à static <T> void copy(T[] a,T[] b);
copy(new Vector<String>(), new Integer[5]) à static <T> void copy(Collection<T> a , T[] b);
定义泛型类型
如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getById(int id){}
}
类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：
GenericDao<String> dao = null;
new genericDao<String>();
注意：
在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。
八、类加载器
类加载器：就是加载类的工具。
JAVA虚拟机中可以安装多个类加载器，系统默认三个主要的类加载器，每个类负责加载特定位置的类。
BootStrap-------ExtClassLoader------AppClassLoader classpath指定的类加载器
父级 子集 子子集
类加载器也是JAVA类，因为其他是JAVA类的类加载器背身也要被类加载其加载。显然必须有第一个类加载器不是jAVA类，这正是BootStrap；所以类加载器
是用BootStrap加载的。
Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
类名.class.getClassLoader().getClass().getname();获取类加载器名称。
类加载器的委托机制：
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
首先当前线程的类加载器去加载线程中的第一个类。
如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
每个类加载器加载类时，又先委托给其上级类加载器。
类加载器是类的加载工具，主要有三种类加载器 一种是BootStrap 一种是ExtClassLoader 一种是 AppClassLoader
自定义类加载器：
首先，类加载器必须要继承ClassLoader。 覆盖findClss
九、代理类
代理类
程序中的代理：要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如:异常处理、日志、计算方法的运行时间、事务管理、等等。
代理类要调用目标类的功能。
目标类 doSomeThing(){
业务功能代码
}
代理类 doSomeThing(){
//前置系统功能代码
目标对象.doSomeThing()
//后置系统功能代码
}
动态代理的工作原理：
1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。
猜想分析动态生成的类的内部代码：
1、动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
2、构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：
因为代理类从Object上继承了许多方法，其中只对三个方法（hashCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是由Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。
自定义代理类的步骤：
方式1：
获得动态代理类的字节码文件
Class claz=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
//通过反射获得该动态代理类的构造方法
Constructor c=claz.getConstructor(InvocationHandler.class);
//编写一个InvocationHandler类
class myInvocationHandler implements InvocationHandler{
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
return null;
}
}
//创建实例，接受一个invocationhandler对象
c.newInstance(new myInvocationHandler());
方式2，newProxyInstance这个方法需要三个参数，可以直接创建target的代理对象
Object proxy3 = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
/*new Class[]{Collection.class},*/
//获取target上的接口
target.getClass().getInterfaces(),
new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
/*long beginTime = System.currentTimeMillis();
Object retVal = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + " running time of " + (endTime - beginTime));
return retVal;*/
//把上边的代码封装到一个类中，让后调用该类的方法，就实现了方法的封装
advice.beforeMethod(method);
Object retVal = method.invoke(target, args);
advice.afterMethod(method);
return retVal;
}
}
);
return proxy3;
}
}
3611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
