java 新特新

 一，静态导入：

  语法：

   import static 包名.类名.*;

 

 二，可变参数函数：

 语法：

  修饰符 返回值类型 方法名(参数类型...参数名){}

  public void Show(int x,int y,int...z){}

  System.out.print(Show(1,2,3,4,5,6));

 

 三，增强版for循环：

  for(type 变量名：集合变量名){}

  for(String s:lists){}

 

  四，基本数据的拆，装箱：

  Integer i1=new Integer(10); //实现int转换为对象的方式；

  Integer i2=Integer.valueOf(10); //实现int型转换对象的方式；

  Integer i3=10; //通过自动装箱方式事项int转换对象的方式；

  int sum=i1+20;//通过自动拆箱的方式转换int型；

 

  五,枚举：

  public enum Test{

  RED(10),GREEN,YELLEY;

  private Test(){}

  private Test(int z){}

}

 

  六，反射：

  1，Class 类：

  Data de;

  Class data=de.getClass();

  Class data=Class.forName("Data");

  Class data=Data.Class;

 

 2，集合的反射：

  InputStream is=new FileInputStream(java.txt);

  Properties ps=new Properties();//创建Properties对象

  ps.load(is);

  is.close();

  String className=ps.getProperty("className"); //获取相应的值

  Collection c=(Collection) Class.forName(className).newInstance();

  c.add("1");

  c.add("2");

  System.out.println(c);

 

  七，标注：

  JDK的内置标注：

@Override;//是方法标注，在覆盖父类方法却写错了方法名时发挥作用；

@Deprecated;//不仅可用在方法的前面还可用在参数和类的前面；为建议使用的；

@SuppressWarnings;//被用作标注类，属性，方法等成员，用于屏蔽警告；

 

  八，泛型：

  1，参数化类型与原始类型的兼容：

  Vector<String> v=new Vector();

  2,参数化类型无继承性：

  Vector<String> v=new Vector(String);

  Vector<Object> v1=v;

  v1.add(new Object());

  String s=v.get(0); //结果错误；

 

  九，类加载器视图：

 

 

  十，动态代理类：

 1，创建目标对象类：

   public interface IHello{

   public toHello(String name);

}

  public class HelloImp implements IHello(){

  public void toHello(String name){  //实现toHello();

        System.out.print("hello:"+name);

 }

}

  2，创建拦截方法类：

  public interface IAdvice{

public void beforMethed();

public void afterMethed();

}

  public class IAdvice implements IAdvice{

   public void beforMethed(){

     syso("....befor");

  public void afterMethed(){

    syso("....after");

}

}

}

  3，创建代理类：

 public class ProxyHand implements InvocationHandler{

  private Object target;   //目标对象

  private IAdvice advice;   //拦截方法对象

  public ProxyHand(IAdvice advice){

  super();

     this.advice=advice;

}

   public Object bind(Object target) { //获取动态地理类的实例对象

   this.target=target;   //对目标进行赋值

   return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);  // 通过Proxy类的静态方法newProxyInstance()获取实例对象

}

  public Object invoke(Object proxy,Methed methed,Object[] obj) throws Throwable{

   advice.beforMethed();

   Object result=methed.invoke(target,obj); //调用目标对象的相应方法

   advice.afterMethed();

  return result;

}

}

  public class ProxyDemo(){

   public static void  main(String[] args) throws Exception{

    //创建动态代理类对象

  ProxyHand ph=new ProxyHand(new AdviceImp());

  //实例化动态代理类对象

  IHello hello=(IHello) ph.bind(new HelloImp());

   hello.tohello("kankan");   //调用目标对象的相应方法

}

}