标签：
一：注解
1.注解(Annotation)
注解相当一个类或接口，每一个注解都是一个实例对象
注解的使用形式：@interface即@注解类名
定义注解类：
@interface A
{…}
使用了“注解类”的类：
@A
class B｛｝
对“使用了注解类的类”进行反射操作：
class C {
B.class.isAnnotationPresent(A.class);
A a=(A)B.class.getAnnotation(A.class); }
2.注解类的生命周期
源文件(.java),字节码文件(.class),内存中的字节码(运行时期被加载到内存当中).
可用枚举类：RetentionPolicy下的常量表示
RetetionPolicy.SOURCE、RetetionPolicy.CLASS、RetetionPolicy.RUNTIME
java.lang.Override
表示一个方法声明打算重写超类中的另一个方法声明。
如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
比如重写的方法名不是父类中要重写方法名，则系统会识别出来并报错。
toString 写成 tostring.
public class Person
{
@Override
public string toString ()
{
return null;
}
}
不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。
@Deprecated //@Deprecated表示该方法过时
public static void sayHi()
{
System.out.println("hi,world");
}
用来忽略某种警告,使用方式@SuppressWarnings(value=
{TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
eg:@SuppressWarnings(value={"deprecation"});//忽略“deprecation”类型的警告
@SuppressWarnings(value={"deprecation"})
public class Demo
{
public static void main (String []args)
{
A a=new A();
a.ma();
class A
{
@Deprecated
public void ma()
{
System.out.println("ma方法");
}
}
}}
6.归档
jdk提供的一种可以将多个文件或目录合并/压缩成单个文件(.jar)的归档工具。
jar –cvf mytest.jar A.class B.class ;//将这两个class文件打包成mytest.jar文件
打包命令,对于package xxx的xx.java文件打包
javac -d 打包后文件的路径 打包的Java文件
javac -d . Person.java ;//Person.java文件下“package hq.packag;”
用来表示其他注解的生命周期.
@Retention(RetentionPolicy.SOURCE)
public @interface AnnotationInter {
}
用来表示其他注解的使用范围，枚举ElementType下的不同常量规定了范围
TYPE(类，接口(包括注释类型)，枚举)，FIElD(字段)，METHOD(方法)，
ANNOTATION_TYPE(注释类型)，CONSTRUCTOR(构造方法)，PACKAGE(包)等。
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface AnnotationInter {
}
二：泛型
泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，
使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，
只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。
总结:泛型只在编译器时期有效，在运行时期无效，在运行时期，它指明的“类型”信息会去掉如：
1.泛型(只针对引用类型)使用规则
ArrayList类定义和ArrayList类引用中涉及如下术语：整个称为ArrayList泛型类型
ArrayList中的E称为类型变量或类型参数整个ArrayList称为参数化的类型
ArrayList中的Integer称为类型参数的实例或实际类型参数
ArrayList中的<>念着typeof
ArrayList称为原始类型
参数化类型与原始类型的兼容性：
参数化类型可以引用一个原始类型的对象，编译报告警告，
例如， Collection<String> c = new Vector();//可以
原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vecto<String>r();//可以。
第三种情况：
Vector v1=new Vector<String> ();//符合最上面的情况
Vector<Object> v=v1; //也可以，符合上面第二种情况
参数化类型不考虑类型参数的继承关系：
Vector<String> v = new Vector<Object>();//错误
Vector<Object> v=new Vector<String>();//错误
2.泛型中的？通配符
问题：定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？
错误方式：
public static void printCollection(Collectioncols) {
for(Object obj:cols) { System.out.println(obj); }
/* cols.add("string");//没错 cols = new HashSet();//会报告错误！*/ }
正确方式：
public static void printCollection(Collection<?> cols) {
for(Object obj:cols) { System.out.println(obj); }
//cols.add("string");//错误，因为它不知自己未来匹配就一定是String
cols.size();//没错，此方法与类型参数没有关系
cols = new HashSet<Date>(); }
总结： 使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，
不能调用与参数化类型有关的方法。
3.泛型中的？通配符的扩展
限定通配符的上边界：
正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();
限定通配符的下边界：
正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();
<?>与<E>
class<?> c=new class<E> ();//正确
class<E> c=new class<?>();//错误，即？可以“=”任意参数，但是特定参数化类型“=”？错误。
总结：限定通配符总是包括自己。 ?只能用作引用，不能用它去给其他变量赋值
Vector<? extends Number> y = new Vector<Integer>();
Vector<Number> x = y;
上面的代码错误，原理与Vector<Object > x11 = new Vector<String>();相似，
只能通过强制类型转换方式来赋值。
4.定义泛型的方法
在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，
例如： public static <K,V> V getValue(K key) { return map.get(key);}
//<T>必须声明，这是对你使用“T”的解析，<T extends U&V>也可以,<T super U>不可以
public <T> T method1(T x,T y) {
return y;
}
public <T extends Number> void method2(T x) {
}
//多个参数的T
public static <K,V> V getValue(K key) {
V map = null;
return (V) ((ArrayList<Integer>) map).get((int) key);
}
//异常如何采用泛型
private static <T extends Exception> void sayHello() throws T {
try{
}catch(Exception e)
{
throw (T)e;
}
}
5.定义泛型的类
public class GenericDao<E> {
//多个方法使用的E类，放在该类上面声明<E>
public void add(E e) {
}
//静态方法使用的E，必须用自己方法上声明的<E>,不能使用类上面声明的<E>
public static<E> void method(E e) {
}
public void update (E e) {
} }
注意： 在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。 当一个变量被声明为泛型时，
只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类
所共享的，所以静态成员不应该有类级别的类型参数
6.Type(接口)
Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
7.反射，泛型的高级应用
public class GenericTest {
public static void main(String[] args) throws Exception {
//如何获取某个方法上声明的特定泛型类型
//如：public void applyVector(Vector<Date> v);如何得知该Vector是Date,即如何获取<T>里的泛型类型
//解决：使用反射的Method类里的getGenericParameterTypes()获取该方法上的泛型类型
Method applyMethod=GenericTest.class.getMethod("applyVector", Vector.class,Set.class);
Type [] tp= applyMethod.getGenericParameterTypes();
System.out.println(tp[0]);
ParameterizedType p=(ParameterizedType) tp[1];
System.out.println(p.getActualTypeArguments()[0]);
}
public void applyVector (Vector<Date> v,Set<HashSet> s) {
}
}
三：类加载器
1.类加载器
2.ClassLoader
构造方法：
ClassLoader();//使用方法 getSystemClassLoader() 返回的 ClassLoader 创建一个新的类加载器，将该加载器作为父类加载器。
ClassLoader(ClassLoader parent);//指定父类加载器，父类可能最终调用Bootstrap作为最后的父级。
成员方法：
ClassLoader getParent();//返回委托的父类加载器。
static ClassLoader getSystemClassLoader();//返回系统的类加载器
Class<?> loadClass(String name);//使用指定的二进制名称来加载类。
Class<?> findClass(String name);//使用指定的二进制名称查找类.
Class<?> defineClass(byte [] b,int off ,int len);//读取byte数组转成类实例
3.三大类加载器的关系及加载类的范围
BootStrap(启动类加载器)：
常用的Java类，如System，util下的集合类等等。
ExtClassLoader(扩展类加载器):
遵循双亲委派模型，即两种加载类的方式，一是loadClass方法，二是findClass方法。 它重写了findClass方法
当父类的loadClass方法找不到类，且它也找不到时，就会使用findClass方法加载类，还不行就会报异常错误。
我们可以通过右键该类export，将我们自定义的类导出到该类加载器的文件夹下，
AppClassLoader(应用程序类加载器):
没有遵循双亲委派模型，即一种加载类的方式，即loadClass方法，它重写了loadClass方法，
class NetworkClassLoader extends ClassLoader {
String host;
int port;
public Class findClass(String name) {
byte[] b = loadClassData(name);
return defineClass(name, b, 0, b.length);
}
private byte[] loadClassData(String name) {
// load the class data from the connection
. . .
}
}
遵循双亲委派模型的意义：它保证了相同全限定名的类是不会被重复加载到JVM中，即没有重名的类加载上了。
不遵循双亲委派模型的意义：有可能有大量相同名的类，被不同的自定义类加载器加载到JVM中，即有同名不同功能的类都加载上来了
4.类加载器的(双亲)委托机制
类加载器加载类的时候，会委托父级加载器去找该类并加载该类，父类又委托给父类，直到祖宗加载该类，
祖宗没加载到该类的话，会让下一级找，直到最初委托的加载器(如果重写了findClass方法，则使用该方法加载类)。
还不行的话就会报异常ClassNotFoundException
getContextClassLoader())去加载线程中的第一个类。
标签：
原文地址：http://www.cnblogs.com/beyondbycyx/p/4646655.html
