java高新技术中《九》

一：注解

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

3.@Override

java.lang.Override

表示一个方法声明打算重写超类中的另一个方法声明。
如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
比如重写的方法名不是父类中要重写方法名，则系统会识别出来并报错。
toString 写成 tostring.

public class Person
{
@Override
public string toString ()
{
return null;
}
}

4.@Deprecated

不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。

@Deprecated //@Deprecated表示该方法过时

public static void sayHi()
{
System.out.println("hi,world");
}

5.@SuppressWarnings

用来忽略某种警告,使用方式@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;”

7.@Retention

用来表示其他注解的生命周期.

@Retention(RetentionPolicy.SOURCE)

public @interface AnnotationInter {

}

8.@Target

用来表示其他注解的使用范围，枚举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(Collection cols) {

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.定义泛型的方法

Java中的泛型类型（或者泛型）类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全是在编译器中实现，

用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）

Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译： <T> T add(T x,T y) { return (T) (x+y);

//return null; } 用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是

紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。

除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。

并且可以用&来指定多个边界，如<V extends Serializable & cloneable> void method(){}

只有引用类型才能作为泛型方法的实际参数，swap(new int[3],3,5);语句会报告编译错误。

普通方法、构造方法和静态方法中都可以使用泛型。

也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。

在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，

例如： 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 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

java.lang.reflect 接口 Type

所有已知子接口：GenericArrayType, ParameterizedType, TypeVariable<D>, WildcardType 所有已知实现类： Class
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.类加载器

类加载器是当程序运行时要使用某个类，则类加载器就加该类的字节码加载到内存里执行。

Java虚拟机可以安装多个类加载器，系统默认三个主要的类加载器，每个类加载器负责加载不同位置的类

Bootstrap，ExtClassLoader，AppClassLoader。

有的类加载器也是Java类，所以必须有一个非Java类的加载器加载其他Java类的类加载器，这个就是Boostrap。

Java虚拟机中的所有类加载器采用具有父子关系的树形结构进行组织。每个实例化类加载器对象时必须为其指定

一个父级的类加载器对象，或采用系统默认的类加载器作为父级。

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()

)去加载线程中的第一个类。

如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。