【文件属性】：
文件名称：Java 高级特性.doc
文件大小：56KB
文件格式：DOC
更新时间：2012-06-19 05:47:40
Java 高级特性
JAVA高级特性
1.静态导入：先举个离例子 。
import java.lang.Integer.parseInt;
public class StaticImport {
int x = parseInt("123");
System.out.println(x);
}
这样的程序如果不在IDE 工具中输入，是很难看出这个程序代码会出现问题，可它偏偏就出问题了，这是为什么呢？因为程序里面有个静态方法，如果导入import static java.lang.Integer.parseInt;这样的程序就可以运行了。
2.可变参数与for循环增强
这个是一般的用法：
public static void loop(String[] args){
for(int i=0;i
。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName(java.lang.String);
例子:
a..使用?通配符可以引用其他各种参数化的类型，但不能调用与参数化有关的方法;
Collection c = new Vector();
c.add("abc");//报错
c.size();//正确
所以，?通配符定义的变量主要用作引用，调用与参数化无关的方法，如果要调用与参数化相关的方法，那么必须在使用?通配符引用之前调用，否则就与java 5提供泛型的目的背道而驰了。
b..向下限定通配符：
正确：Vector x = new Vector();
错误：Vector x = new Vector();
向上限定通配符：
正确：Vector x = new Vector();
错误：Vector x = new Vector();
7.代理
这里就直接先应用张老师写的代码然后再讲清其原理吧!
package cn.itcast.corejava;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
import java.util.Vector;
public class ProxyTest {
public static void main(String[] args) {
System.out.println(Integer.class.getClassLoader());
//System.out.println(ProxyTest.class.getClassLoader().getParent().getClass().getName());
System.out.println(ProxyTest.class.getClassLoader().getClass().getName());
//test1();
//test2();
}
private static void test3() {
Vector v = new Vector();
class MyInvocationHandler implements InvocationHandler
{
Collection target = null;
public Collection bind(Collection target)
{
this.target = target;
Collection proxy1 = (Collection)Proxy.newProxyInstance(
ProxyTest.class.getClassLoader(),
new Class[]{Collection.class} ,
this);
return proxy1;
}
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
// TODO Auto-generated method stub
System.out.println("begin " + method.getName());
Object retval = method.invoke(target, args);
System.out.println("end" + method.getName());
return retval;
}
}
MyInvocationHandler handler = new MyInvocationHandler();
Collection proxy1 = handler.bind(v);
System.out.println(proxy1.getClass().getName());
proxy1.add("abc");
proxy1.add("xyz");
System.out.println(proxy1.size());
}
private static void test2() {
Vector v = new Vector();
class MyInvocationHandler implements InvocationHandler
{
Collection target = null;
public MyInvocationHandler(){}
public MyInvocationHandler(Collection target){this.target = target;}
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
// TODO Auto-generated method stub
System.out.println("begin " + method.getName());
Object retval = method.invoke(target, args);
System.out.println("end" + method.getName());
return retval;
}
}
Collection proxy1 = (Collection)Proxy.newProxyInstance(
ProxyTest.class.getClassLoader(),
new Class[]{Collection.class} ,
new MyInvocationHandler(v));
System.out.println(proxy1.getClass().getName());
proxy1.add("abc");
proxy1.add("xyz");
System.out.println(proxy1.size());
}
private static void test1() {
Collection proxy = (Collection)Proxy.newProxyInstance(
ProxyTest.class.getClassLoader(),//first parameter
new Class[]{Collection.class} , //second parameter
new InvocationHandler(){ //third parameter
Vector target = new Vector();
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
// TODO Auto-generated method stub
System.out.println("begin " + method.getName());
Object retval = method.invoke(target, args);
System.out.println("end" + method.getName());
return retval;
}
}
);
System.out.println(proxy.getClass().getName());
proxy.add("abc");
proxy.add("xyz");
System.out.println(proxy.size());
}
}
以下是Proxy的API文档:
public class Proxyextends
extends Object
implements Serializable
Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the
superclass of all dynamic proxy classes created by those methods.
To create a proxy for some interface Foo:
InvocationHandler handler = new MyInvocationHandler(...); Class proxyClass = Proxy.getProxyClass( Foo.class.getClassLoader(), new Class[] { Foo.class }); Foo f = (Foo) proxyClass. getConstructor(new Class[] { InvocationHandler.class }). newInstance(new Object[] { handler }); or more simply:
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[] { Foo.class }, handler);从以上的程序中在方法中定义参数的时候总是三个参数,可这三个参数有分别代表什么意思呢!?现在以我自己个人的理解,比如我是买家,我要买本书,可是现在我有事,是不是需要别人代我买呢?那带我买的人是不是一定要到卖书的地方买呢?所以着中间产生了三个实体.说白了就是一种代理机制.需要三方一起运行!
代理其实很好理解的,而且会用固定的语法格式,很快会掌握这一原理的!
