Java高新技术（一）

1.    静态导入：当静态导入了某个类时就可以直接用它的方法import static java lang.System.out时，代码中就可以直接用out.println(“静态导入”)

2.       可变参数和for循环加强：

   public static void main(String[] args) {    System.out.println(add(21, 35));    System.out.println(add(2, 35, 52));  } // 必须是三个点且在参数列表的最后,可变参数是当作数组的形式来用  public static int add(int x, int... args) {    int sum = x;    // for循环加强,一一取出集合或数组的元素经常用很强大    for (int arg : args) {      sum += arg;    }    return sum;  }

 

3. 基本数据类型的自动拆箱装箱：

 public static void main(String[] args) {    //自动装obj对象拆箱成基本数据类型    Integer obj = 5;    System.out.println(obj + 23);    //-128~127之间的数据自动装箱后用的是同一个对象,这种叫享元模式：对象很小，使用频率高       //操作系统中的图标就采用了这种模式    Integer i1 = 137;    Integer i2 = 137;            //结果为false    System.out.println(i1 == i2);        Integer i3 = 23;    Integer i4 = 23;    //结果为true    System.out.println(i3==i4);      }

4. 枚举

   public enum TrafficLamp{    //该类有三个元素，每一个元素都是由它的子类来写的并且调用的是父类的有参构造方法    //还可以利用枚举的方法实现单例    RED(60){      public  TrafficLamp nextLamp(){         return GREEN;      }    },    GREEN(60){      public  TrafficLamp nextLamp(){         return YELLOW;      }         },    YELLOW(6){      public  TrafficLamp nextLamp(){         return RED;      }         };    public abstract TrafficLamp nextLamp();    private int time;    private TrafficLamp(int time){this.time = time;}  }

这段代码包括了枚举大部分的知识，受益匪浅啊！

5. class类

描述所有的java类的这个类叫作class(代表内存中的一份字节码)，能过class可以得到这个类各个方面的信息

得到各个字节码对应的实例对象的方法：

类.class()  对象.getClass()

Class.forName(“类名”)

有九个预定义Class实例对象：八个基本数据类型加一个void类型

Integer.TYPE表示的是被包装的那个基本类型的字节码

System.out.println(int.class==Integer.TYPE);

判定一个class是否是数组类型

System.out.println(int[].class.isArray());

注意：在源文件中出现的类型都有各自的class实例对象

6. 反射

 将一个java类身上的各种成分都映射成相应的java类

Constructor类:

得到所有的构造方法：

Constructor[] constructors=Class.forName(“类名”).getConstructors()

得到某一个构造方法：

Constructor constructor=Class.forName(“类名”).getConstructor(参数类型列表)

创建实例：constructor.newInstance(参数);

例如：

Constructor constructor = String.class.getConstructor(StringBuffer.class);

Stringstr=(String)constructor.newInstance(new StringBuffer("abc"));

Field类：

用于反射的类:

public class ReflectPoint {  private int x;  public int y;  public String str1 = "yes";  public String str2 = "hema";  public String str3 = "coming";    public ReflectPoint(int x, int y) {    this.x = x;    this.y = y;  }  public ReflectPoint(int x) {    this.x = x;  }  public ReflectPoint() {  }

反射代码1：

       ReflectPoint pt = ReflectPoint.class .getConstructor(int.class,int.class).newInstance(74,52);    Field fieldY = pt.getClass().getField("y")；//fieldY代表类上的一个变量，也就是所有实例对象Y字段的集合    System.out.println(fieldY.get(pt));    Field fieldX = pt.getClass().getDeclaredField("x");//暴力反射得到私有成员getField()找不到私有的// getDeclaredField()只要声明过的变量都可以找到    fieldX.setAccessible(true);    System.out.println("私有的也可以改了！");    fieldX.set(pt, 22);

反射代码2：

private static void changeStringValue(Object obj) throws Exception {    Field[]fields = obj.getClass().getFields();    for(Field field : fields){      //字节码的比较用==,因为字节码只有一份      if(field.getType() == String.class){         String oldValue = (String)field.get(obj);         String newValue = oldValue.replace('m', 'o');         field.set(obj, newValue);      }    }}

Method类：

String className = args[0];    Method mainMethod = Class.forName(className).getMethod("main", String[].class);    //静态方法不用传对象所以是null    mainMethod.invoke(null, (Object)new String[]{"111","222","333"});//数组也是一个对象，元素类型和维度一样时，它们共用一//个字节码数组的反射：private static void printObject(Object obj) {  //是数组就拆包，一个一个打印，不是数组直接打印    Class clazz = obj.getClass();    if(clazz.isArray()){      int len = Array.getLength(obj);      for(int i=0;i<len;i++){         System.out.println(Array.get(obj, i));      }    }else{      System.out.println(obj);    }      }

加载配置文件的方法：

方法一：InputStream ips = ReflectTest.class.getResourceAsStream("cn/hema/config.properties");方法二：InputStream ips = ReflectTest.class.getClassLoader().getResourceAsStream("cn/hema/config.properties");方法三：InputStream ips = new FileInputStream("config.properties");   Properties props = new Properties();props.load(ips);ips.close();//释放操作系统资源String className = props.getProperty("className");Collection collections = (Collection)Class.forName(className).newInstance();    //ArrayList按顺序插入对象的引用，多个引用可指向同一个对象    //HashSet会检查是否有对象和它相等，如果有就不再放进去    ReflectPoint pt1 = new ReflectPoint(3,3);    ReflectPoint pt2 = new ReflectPoint(5,5);    ReflectPoint pt3 = new ReflectPoint(3,3);       collections.add(pt1);    collections.add(pt2);    collections.add(pt3);    collections.add(pt1);         //pt1.y = 7; 改变了参与hashCode计算的值，被放在了另一个区域，删除时找不到了,出现内存泄漏      //collections.remove(pt1);如果两个对象的equals相等，应该让它们的hashCode相等，如果不存在hash集合中，就不必考虑hashCode        System.out.println(collections.size());  } }

 

JavaBean:一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则

public static void main(String[] args) throws Exception {  ReflectPoint pt1 = new ReflectPoint(3,5);   String propertyName = "x";  //通过内省API可以非常方便的得到某个属性  Object retVal = getProperty(pt1, propertyName);  System.out.println(retVal);    Object value = 9;  //重构抽取方法，优化代码  setProperties(pt1, propertyName, value);  System.out.println(pt1.getX());   } private static void setProperties(Object pt1, String propertyName,   Object value) throws IntrospectionException,   IllegalAccessException, InvocationTargetException {  PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());  Method methodSetX = pd2.getWriteMethod();  methodSetX.invoke(pt1,value); } private static Object getProperty(Object pt1, String propertyName)   throws IntrospectionException, IllegalAccessException,   InvocationTargetException {  PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());  Method methodGetX = pd.getReadMethod();  Object retVal = methodGetX.invoke(pt1);    return retVal; }

反射的知识主要用做框架，框架调用我们自己写的类，我们自己写的类可以调用工具类。