java简介以及了解java（三五）

处理自定义注释的类
例：

import java.lang.reflect.*;
public class TestFramework {
public static void main(String[] args) throws Exception {
Class c=Class.forName("MyClass2");//获取有注释的类的类对象
Method[] ms=c.getMethods();//获得该类中有的方法对象
Object o=c.newInstance();//获得该类的实例
for(Method m:ms){
boolean flag=m.isAnnotationPresent(Test.class);
/*
isAnnotationPresent(Class c)这个方法是判断这个方法是不是加上了注释注意这是方法对象的方法
*/
if (flag){
Test t=m.getAnnotation(Test.class);
/*
getAnnotation(Class c)方法是获得该方法的注释，得到注释对象t
可以通过注释对象”属性名()”也就是value()，获得注释的属性的值
*/
String value=t.value();
m.invoke(o,value);
}
flag=m.isAnnotationPresent(Author.class);
if (flag){
Author a=m.getAnnotation(Author.class);
Name[] ns=a.value();
for(Name n:ns){
String fn=n.firstName();
String ln=n.lastName();
System.out.println(fn+ " "+ ln);
}
}
}

}
}

 

例2:

定义注释
import java.lang.annotation.*;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
String name();
String sex();
}
使用注释
public class TestAnntion {
@Test(name="liucy",sex="man")
public void test(String name,String sex){
System.out.println(name+" "+sex);
}
}
处理注释
import java.lang.reflect.Method;
public class TestT {
public static void main(String[] args) throws Exception {
Class c=Class.forName(args[0]);
Method[] ms=c.getMethods();
Object o=c.newInstance();
for(Method m:ms){
boolean flag=m.isAnnotationPresent(Test.class);
if (flag){
Test t=m.getAnnotation(Test.class);
String name=t.name();
String sex=t.sex();
m.invoke(o, name,sex)
}
}
}

 
三个新加的多线程包
Java 5.0里新加入了三个多线程包：
java.util.concurrent, java.util.concurrent.atomic, java.util.concurrent.locks.
java.util.concurrent包含了常用的多线程工具，是新的多线程工具的主体。
java.util.concurrent.atomic包含了不用加锁情况下就能改变值的原子变量，比如说AtomicInteger提供
了addAndGet()方法。Add和Get是两个不同的操作，为了保证别的线程不干扰，以往的做法是先锁定共享的变量，然后在
锁定的范围内进行两步操作。但用AtomicInteger.addAndGet()就不用担心锁定的事了，其内部实现保证了这两步操作是
在原子量级发生的，不会被别的线程干扰。
java.util.concurrent.locks包包含锁定的工具。
Callable 和Future接口
Executor接口替代了Thread类，他可以创建定量的和动态以及周期性的线程池。
ExecutorService接口，线程池，用来存放线程来节省创建和销毁资源的消耗。
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Callable和Runnable有几点不同：
Callable规定的方法是call()，而Runnable规定的方法是run().
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
call（）方法可抛出异常，而run（）方法是不能抛出异常的。
Future对象可以获得线程运行的返回值
运行Callable任务可拿到一个Future对象，通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的
结果。
以下是Callable的一个例子：

public class DoCallStuff implements Callable{ // *1
private int aInt;
public DoCallStuff(int aInt) {
this.aInt = aInt;
}

public String call() throws Exception { //*2
boolean resultOk = false;
if(aInt == 0){
resultOk = true;
} else if(aInt == 1){
while(true){ //infinite loop
System.out.println("looping....");
Thread.sleep(3000);
}
} else {
throw new Exception("Callable terminated with Exception!"); //*3
}
if(resultOk){
return "Task done.";
} else {
return "Task failed";
}
}
}