——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——

一：java1.5新特性(1:提高安全性  2:提高效率  3:简化书写)

1.静态导入

import ：导入某个类或，某个包下的所有类。

import static : 导入某个类中的所有静态成员或某个静态成员

a.导入某个类的所有静态成员(方法和变量):  import static 包名.类名.*;

b.导入某个类的某个静态成员： import static 包名.类名.静态成员名称;

2.可变参数(方法的参数)

为了增强方法的重载，使得方法可以接收多个(不确定)参数，Java通过隐式的创建一个数组来存储

可变参数，在方法内可以以数组形式访问它。

注意：可变的参数只能在参数列表的后面。

用法：add(3);  //只传入x=3，   add(3,4,5,6); //x=3,后面的赋给数组args.

public static void add(int x,int ...args)
{int sum=x;for(int e:args){sum+=e;}System.out.println("add:"+sum);
}

3.自动拆装箱操作

   装箱：将基本数据类型包装为对应的包装类对象
   拆箱：将包装类对象转换成对应的基本数据类型

//JDK5.0之前：  Integer obj1 = Integer.valueOf(1);  //JDK5.0之后： Integer obj2 = 2;    //自动装箱：将基本数据类型转换成Integer对象 Integer    it=4;int     i=it+5;Integer   it2=i+4;   System.out.println(obj2 + 3);   //自动拆箱:将Integer对象转换成基本数据类型后相加  //-128~127的数字包装成Integer对象后，会缓存到一个对象池中，当要用到的时候会先到池中找  //提高效率：因为这些小整数会经常用到  Integer obj3 = 127;  Integer obj4 = 127;  System.out.println(obj3 == obj4);  Integer obj5 = 128;  Integer obj6 = 128;  System.out.println(obj5 == obj6);  Integer obj7 = Integer.valueOf(1);  System.out.println(obj1 == obj7);

运行结果：5
              true

false

true

4.增强性for循环

好处：适合用于遍历，提高了效率。

坏处：无法得知变量的下标。
   注意： 只能是数组或集合类型(实现了Iterator接口)

用法： for( type 变量名：变量集合名) ，如上

二：枚举

定义：枚举也是一种类，只是比较特别，它将所有的有限个实例对象放在它的内部，你可以通过“枚举名.枚举实例”来访问它的实例对象。

适用环境：当你用到某个类，而且它只有有限个实例对象，它的类型不确定很抽象的时候，你可以考虑将它定义成枚举类，如红绿灯，季节等。

枚举类的常用方法：

　　(1)  ordinal()方法: 返回枚举值在枚举类种的顺序。这个顺序根据枚举值声明的顺序而定。

　　(2) compareTo()方法: Enum实现了java.lang.Comparable接口，因此可以比较与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException()异常。

　　(3) values()方法： 静态方法，返回一个包含全部枚举值的数组。

　　(4) toString()方法： 返回枚举常量的名称。

　　(5) valueOf(Class<T> enumType, String name)方法： 这个方法和toString方法是相对应的，返回带指定名称的指定枚举类型的枚举常量。

　　(6)  equals()方法： 比较两个枚举类对象的引用。

1.枚举类

一个类的实例是有限且固定的，则这个类称为枚举类。比如季节类，只有四个对象（春、夏、秋、冬）。

//创建一个枚举类的/*（1）通过private将构造器隐藏起来（2）把这个类的所有可能实例都使用private static final修饰的类变量来保存。（3）如果有必要，可以提供一些静态方法。*/public class Demo{public static void main (String []args){System.out.println("spring:"+Season.SPRING.getName());}}class Season {   private   String name;private   Season (String name){this.name=name;}public static final Season SPRING=new Season ("春天") ;public static final Season SUMMER=new Season("夏天");public static final Season AUTUMN=new Season ("秋天");public static final Season WINTER=new Season ("冬天");public   String getName(){return this.name;}}

2.不可变类
   不可变类：创建该类的实例后，该实例的Field是不可改变的。
   如果要创建自定义的不可变类，需遵循如下规则：

1. 使用private和final修饰符来修饰该类的Field。

2. 提供带参数的构造函数，用于根据传入参数来初始化类里的Field。

3. 仅为该类的Field提供getter方法，不要为该类的Field提供setter方法。

4. 如果有必要，重写Object类的hashCode和equals方法。

3.Enum类(枚举)

1. 使用enum关键字定义枚举类。枚举类一样可以有自己的Field、方法，可以实现一个或多个接口，也可以有自己的构造器。

2. 使用eunm定义的枚举类默认继承了java.lang.Enum类，而不是继承Object类。

3. 使用enum定义、非抽象的枚举类默认会使用final修饰，因此枚举类不能派送子类。（并不是所有的枚举类都使用final修饰，如抽象枚举类）

4. 枚举类所有实例必须在枚举类的第一行显示列出，否则这个枚举类永远不能产生实例。

5. 所有枚举类都提供一个values方法，该方法可以方便地遍历所有枚举值。

enum的常用静态方法:

枚举类名.values() ;//以数组的形式返回该枚举的所有实例

Enum.valueOf(枚举类名.class,枚举实例名); //返回该枚举类下指定的枚举实例。

//访问枚举类的实例，或方法，以“枚举类名.实例”，“枚举类名.方法名”访问//使用enum定义一个简单的枚举类//使用enum的values()方法，遍历所有的枚举public class Demo1{public static void main(String []args) throws Exception{method(SeasonEnum.SUMMER);method2();}public static void method2(){ for ( SeasonEnum se: SeasonEnum.values() ){System.out.println("SeasonEnum:"+se);}}public static void method(SeasonEnum s){switch (s){default: System.out.println("null"); break;case SPRING: System.out.println("spring"); break;case SUMMER: System.out.println("summer"); break;case AUTUMN: System.out.println("autumn"); break;case WINTER: System.out.println("winter"); break;}}}enum SeasonEnum{SPRING ,SUMMER, AUTUMN ,WINTER ;}

3.1一个规范化的枚举类(拥有自己不可变的Field)

  /*枚举类可以定义自己的Field和方法。 枚举类通常应该设计不可变类。其Field值不应该允许改变，这样会更安全。所以枚举类的Field都应该使用private final修饰。枚举实例名称一般都是大写字母Enum.valueOf()方法演示*/enum Gender{MALE("男"),FEMALE("女");private Gender(String sex){this.sex=sex;}private final String sex;public String getSex(){return sex;}}public class Demo2{public static void main (String []args){Gender g=Gender.MALE;System.out.println("Gender.MALE:"+g.getSex());//使用Enum.valueOf()方法访问枚举类下的某个实例Gender g2=Enum.valueOf(Gender.class,"FEMALE");System.out.println("Enum.valueOf(Gender.class,\"FEMALE\"):"+g2.getSex());}}

3.2枚举类实现一个或多个接口(且不同枚举实例有各自的接口实现方法)

//枚举类实现一个或多个接口(且不同枚举实例有各自的接口实现方法)public class Demo3{public static void main (String []args){Gender.MALE.info();}}

//以下代码需要放在GenderInter.java文件中
public interface GenderInter
{public void info();}enum Gender implements GenderInter
{MALE("男"){public void info(){System.out.println("我是男的");}},FEMALE("女"){public void info(){System.out.println("我是女的");}};private Gender(String sex){this.sex=sex;}private final String sex;public String getSex(){return sex;}
}

3.3 包含抽象方法的枚举类

含有抽象方法的枚举类，它的每一个枚举实例必须覆盖重写该抽象方法

//注意：含有抽象方法的枚举类，它的每一个枚举实例必须覆盖重写该抽象方法public class EnumAbstractDemo {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("plus:5+2="+Operation.PLUS.eval(5, 2));System.out.println("minus:5-2="+Operation.MINUS.eval(5, 2));System.out.println("times:5*2="+Operation.TIMES.eval(5, 2));System.out.println("divide:5/2="+Operation.DIVIDE.eval(5, 2));}}enum Operation{//定义四种加减乘除的枚举值PLUS {@Overridepublic double eval(double x, double y) {// TODO Auto-generated method stubreturn x+y;}},MINUS {@Overridepublic double eval(double x, double y) {// TODO Auto-generated method stubreturn x-y;}},TIMES {@Overridepublic double eval(double x, double y) {// TODO Auto-generated method stubreturn x*y;}},DIVIDE() {@Overridepublic double eval(double x, double y) {// TODO Auto-generated method stubreturn x/y;}};public abstract double eval(double x,double y);}

 三：反射

1.反射

反射库(Reflection Library)提供一个丰富的工具集，以便编写能够动态操作Java代码的程序。这项功能被

大量的应用在JavaBeans中，它是Java组件的体系结构。

能够分析类能力的程序称为反射(Reflection),即可以将一个类(或基本数据类型)，类成员当成一个对象来操作。

它是运行时检测和修改某个对象的结构及其行为，与内省(introspection)不同。内省是反射的一个子集。

反射：用于运行时检测和修改某个对象的结构及其行为。

内省：用于运行时检测某个对象的类型及其包含的属性。

注意：这里是指运行时期，即如果编译时期不可以做的事情，我在运行时期使用反射就可以做了，如向定义了ArrayList <String>的集合里，运用反射加入int型数据

内省实例： 对象名  instanceof  类名/接口名;//检测某个对象是否属于某个类或接口

反射实例：Class.forName()方法可以获取某个类。

2.Class类

一个Class对象实际上表示的是一个类型，这个类型不一定是一种类，因为它也可以表示基本数据类型。

它可以将Java里的所有东西(类，接口，数组，基本数据类型，void)当成一个对象来对它的属性进行访问。

3.反射包(java.lang.reflect)下的Constructor类，Field类(成员变量)，Method类(成员方法)

总结:

1,创建Class实例对象的三种方法：

a,Class<?> c=Class.forName(String name);

b,Class<?> c=p.getClass();//对象名.getClass()

c,Class<?> c=Person.Class ;//类名.Class;

2,获取构造方法(Constructor)，成员变量(Field)，成员方法(Method)，接口(interface)

Class类： getDeclaredXxxx();// 获取本类中的所有Xxxx,不包括继承父类中xxx

getXxxx();//获取本类中的public权限的Xxxx。

package hq.com.ClassDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassDemo {/*** class类的演示*/public static void main(String[] args) throws Exception {// TODO Auto-generated method stubDemo1();System.out.println("---------------------");Demo2();System.out.println("---------------------");Demo3();System.out.println("---------------------");Demo4();System.out.println("---------------------");Demo5();System.out.println("---------------------");Demo6();System.out.println("---------------------");Demo7();System.out.println("---------------------");Demo8();}//1.任何所有东西都是Class类的实例对象//创建Class实例的三种方法，Class.forName(),类名.class,对象名.getClass().public static void Demo1() throws ClassNotFoundException{Class<?> c1=null;Class<?> c2=null;Class<?> c3=null;//1,Class.forName()方法，推荐c1=Class.forName("hq.com.ClassDemo.Person");System.out.println("Demo1(写法1：forName()):类名="+c1.getName());//2,类名.class。在java中，每个class都有一个相应的Class对象，当编写好一个类，// 编译完成后，在生成的.class文件中，就产生一个class对象c2=Person.class;System.out.println("Demo1(写法2：类名.class)：类名="+c2.getName());//3，object类的getClass()方法Person p=new Person();c3=p.getClass();System.out.println("Demo2(写法3:getClass()):类名="+c3.getName());}// 2，Object的getClass()方法，Class的getName()，getPackage().// 演示反射机制获取类的包名和类名public static void Demo2() {Person p = new Person("hq", 22);System.out.println("person的类名：" + p.getClass().getName());System.out.println("person的包名：" + p.getClass().getPackage().getName());}//3,class的newInstance()方法//  通过反射，用class来创建类对象(这是反射的意义所在)public static void Demo3() throws  Exception{Class c=Class.forName("hq.com.ClassDemo.Person");Person p= (Person) c.newInstance();//要强转，默认是Object类p.setName("hq");System.out.println("Demo3(class的newInstance()方法)：name="+p.getName());}//4,class的getConstructors();以数组形式返回该类的所有公共构造方法//   java.lang.reflect.Constructor;构造方法类public static void Demo4() throws  Exception{//用构造方法类创建该类的实例对象。//注意必须按顺序获取Constructor,即ct[0]在ct[1]之前，不能反过来Class   c = null;Person p1 = null;Person p2 = null;c = Class.forName("hq.com.ClassDemo.Person");Constructor<?> [] ct=c.getConstructors();p1=(Person) ct[0].newInstance();p1.setName("hh");p2=(Person) ct[1].newInstance("hq",22);System.out.println("Demo4(getConstructors()构造方法类创建实例对象):p1:name="+p1.getName());System.out.println("Demo4(getConstructors()构造方法类创建实例对象):p2:name="+p2.getName());}//5,class:  getDeclaredField(String name);获取该类的成员变量//  Field类:操作类对象的成员变量，set，get方法public static void Demo5() throws Exception {//class的getDeclaredField(String name)方法获取类中的某个成员变量//Field类的set(Object obj,Object value)，修改该字段上某个对象对应的值Class  c=Class.forName("hq.com.ClassDemo.Person");Person p=(Person)c.newInstance();Field f=c.getDeclaredField("age");f.setAccessible(true);f.set(p, 11);System.out.println("Demo5(Field的set(对象,值))：person:age="+p.getAge());System.out.println("Field.get():"+f.get(p));}//6,获取该类的父类信息，成员方法，接口，成员变量(字段)public static void Demo6() throws  Exception{   //注意：getDeclaredFields()和getFields()区别是，//前者是所有声明的字段,后者是仅为public权限的字段//注意：两者获取的字段均为该类内部中定义的，不包括继承父类的字段Class<?> c=Class.forName("hq.com.ClassDemo.SuperMan");Class<?> superClass=c.getSuperclass();System.out.println("Demo6:superman的父类是："+superClass.getName());//获取类中所有字段Field [] fs=c.getDeclaredFields();int i=0;for(Field f:fs){   i++;System.out.println("superman的第"+i+"个成员："+f.getName());}//获取类中所有方法Method [] ms=c.getDeclaredMethods();for(Method m:ms){    i++;System.out.println("superman的第"+i+"个成员方法："+m.getName());}//获取类实现的接口Class<?>[] is=c.getInterfaces();for(Class<?> j:is){System.out.println("superman的第"+i+"个接口："+j.getName());}}//7,调用类的方法，Method类的invoke()方法public static void Demo7() throws Exception{Class<?> c=Class.forName("hq.com.ClassDemo.SuperMan");//调用类中的无参数方法Method  m1=c.getMethod("fly");System.out.print("Demo7:superman中的无参数方法fly():");m1.invoke(c.newInstance());//调用类中的参数方法，先取出该方法，再放入参数（实例，方法参数）Method m2=c.getMethod("walk",int.class);System.out.print("Demo7:superman中的有参数方法walk():");m2.invoke(c.newInstance(),4);}/** * Demo8: 通过Java反射机制得到类加载器信息 *  * 在java中有三种类类加载器。[这段资料网上截取] 1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。 2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类 3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。   */ public static void Demo8() throws ClassNotFoundException  {  Class<?> class1 = null;  class1 = Class.forName("hq.com.ClassDemo.SuperMan");  String nameString = class1.getClassLoader().getClass().getName();  System.out.println("Demo8: 类加载器类名: " + nameString);  }
}
class SuperMan extends Person implements ActionInterface
{private boolean BlueBriefs;public boolean isBuleBriefs(){return this.BlueBriefs;}public void setBuleBriefs(boolean BlueBriefs){this.BlueBriefs=BlueBriefs;}public void fly(){System.out.println("超人会飞哦～～");}@Overridepublic void walk(int m) {// TODO Auto-generated method stubSystem.out.println("超人也会走耶～～走了"+m+"米后走不动了");}}
interface ActionInterface
{public void walk(int m);
}
class Person {private int age;private String name;public Person() {}public Person(String name, int age) {this.age = age;this.name = name;}public void setAge(int age) {this.age = age;}public int getAge() {return this.age;}public void setName(String name) {this.name = name;}public String getName() {return this.name;}
}

 总结：

数组的反射：

1.具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

2.代表数组的Class实例对象的getSuperclass()方法返回的父类为Object类对应的Class.

3.基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用;非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

4.Arrays.asList()方法处理int[]和String[]时的差异。

Arrays工具类用于完成对数组的反射操作。