黑马程序员_JDK1.5的新特性

------- android培训、java培训、期待与您交流！ --------

JDK1.5的新特性：

              1）可变参数：一个方法接受的参数个数不固定就用可变参数。

                     特点：只能出现在参数列表的最后面，“...”位于类型和变量名之间，前后无空格

                          都可以，调用可变参数的方法时，编译器为该参数隐含创建一个数组在方法

                          体中以数组的形式访问可变参数

             2）增强for循环：

                          语法：

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

                         注意事项：

                         迭代变量必须在( )中定义！

                        集合变量可以是数组或实现了Iterable接口的集合类

             3）基本数据类型的装箱和拆箱：

                                       Integer i1=122；

                                       Integeri2=123；

                                       Integer  i3=128；

                                      Integer  i4=128;

                         System.out.println(i1==i2);   //true

                          System.out.println(i3==i4); //flase

小知识：享元模式：

            4）枚举：让某个类型的变量的取值只能为若个个固定值中的一个，否则编译器就报错。

             带构造方法的枚举

构造方法必须定义成私有的

如果有多个构造方法，该如何选择哪个构造方法？

枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。

带方法的枚举

定义枚举TrafficLamp

实现普通的next方法

实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。

增加上表示时间的构造方法

枚举只有一个成员时，就可以作为一种单例的实现方式。

            5）注解：

            6）泛型：

                   泛型的继承

继承时，对泛型父类的类型参数不实例化

 继承时，对泛型父类的类型参数实例化

              

反射

   反射就是把Java类中的各种成分映射成相应的java类

Constructor类  得到某个类所有的构造方法：

Field类代表某个类中的一个成员变量

Method类代表某个类中的一个成员方法

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

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

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

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

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

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

类型参数的类型推断

编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

        swap(newString[3],3,4)       static <E> void swap(E[] a, int i,int j)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

        add(3,5)    static <T> T add(T a, T b)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

        fill(newInteger[3],3.5f)    static <T> voidfill(T[] a, T v)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型， 并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

        int x =(3,3.5f)    static <T> T add(T a, T b)

参数类型的类型推断具有传递性

类加载器

简要介绍什么是类加载器和类加载器的作用

Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader

类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是不是java类，这正是BootStrap。

Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

动态代理技术

要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

4.在处理目标方法异常的catch块中

静态导入

import语句可以导入一个类或某个包中的所有类

import static语句导入一个类中的某个静态方法或所有静态方法

语法举例：

import static java.lang.Math.sin;

import static java.lang.Math.*;

可变参数

问题：一个方法接受的参数个数不固定，例如：

System.out.println(countScore(2,3,5));

System.out.println(countScore(1,2,3,5));    

可变参数的特点：

只能出现在参数列表的最后；

...位于变量类型和变量名之间，前后有无空格都可以;

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

 

增强for循环

语法：

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

注意事项：

迭代变量必须在( )中定义！

集合变量可以是数组或实现了Iterable接口的集合类

举例：

       publicstatic int add(int x,int ...args) {

              int sum = x;

              for(int arg:args) {

                     sum+= arg;

              }

              return sum;

       }

基本数据类型的自动拆箱与装箱

自动装箱：

Integer num1 = 12;

自动拆箱：

System.out.println(num1 + 12);

基本数据类型的对象缓存：

Integer num1 = 12;

Integer num2 = 12;

System.out.println(num1 == num2);

 

Integer num3 = 129;

Integer num4 = 129;

System.out.println(num3 == num4);

 

Integer num5 = Integer.valueOf(12);

Integer num6 = Integer.valueOf(12);

System.out.println(num5 == num6);

枚举

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。

私有的构造方法

每个元素分别用一个公有的静态成员变量表示

可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。

枚举的基本应用

举例：定义一个Weekday的枚举。

扩展：枚举类的values,valueOf,name,toString,ordinal等方法（记住，讲课时要先于自定义方法前介绍，讲课更流畅）

总结：枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。

枚举的高级应用

枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

带构造方法的枚举

构造方法必须定义成私有的

如果有多个构造方法，该如何选择哪个构造方法？

枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。

带方法的枚举

定义枚举TrafficLamp

实现普通的next方法

实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。

增加上表示时间的构造方法

枚举只有一个成员时，就可以作为一种单例的实现方式。

反射的基石Class类

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

Constructor类

Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法：

例子：Constructor[] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：

例子：       Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

       //获得方法时要用到类型

创建实例对象：

通常方式：Stringstr = new String(new StringBuffer("abc"));

反射方式： Stringstr = (String)constructor.newInstance(new StringBuffer("abc"));

       //调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法：

例子：String obj= (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

Field类

Field类代表某个类中的一个成员变量

演示用eclipse自动生成Java类的构造方法

问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。

示例代码：

       ReflectPointpoint = new ReflectPoint(1,7);

       Fieldy =Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");

       System.out.println(y.get(point));

       //Fieldx =Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");

       Fieldx = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");

       x.setAccessible(true);

       System.out.println(x.get(point));

Method类

Method类代表某个类中的一个成员方法

得到类中的某一个方法：

例子：       Method charAt =Class.forName("java.lang.String").getMethod("charAt",int.class);

调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式：System.out.println(charAt.invoke(str, 1));

如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

Jdk1.5：public Object invoke(Object obj,Object... args)

Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

反射的作用实现框架功能

框架与框架要解决的核心问题

我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架要解决的核心问题

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？

因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

综合案例

先直接用new  语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。

然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。

引入了elipse对资源文件的管理方式的讲解。

 

内省了解JavaBean

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

如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问，大家觉得这些方法的名称叫什么好呢？JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，用管吗？如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，用管吗？去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。

setId()的属性名id

isLast()的属性名last

setCPU的属性名是什么?CPU

getUPS的属性名是什么？UPS

总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。

一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！好处如下：

在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！

JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。

Beanutils工具包

演示用eclipse如何加入jar包，先只是引入beanutils包，等程序运行出错后再引入logging包。

在前面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值。

get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。

用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。

get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。

演示去掉JavaBean（ReflectPoint）的public修饰符时，BeanUtils工具包访问javabean属性时出现的问题。

每日心得与总结：通过这几天来的学习我认识到Java是个开发平台，也是个部署平台，同时也是一种计算机语言，我要学的话，首先要从基础学起 1、了解JVM的运行机制，学会JDK的安装配置掌握面向对象的编程思想（OOP的概念和思想不弄清楚的话，代码水平很难上去）Java的语言基础，如果是0基础的话，就从学会写一个简单的HelloWorld开始，再慢慢了解什么是常量，变量，关键字等等这些重要的概念，然后学会写方法，再到写类，了解清楚代码的运行顺序，再后来就是封装、多态、继承的概念和应用，重要的是学会看API文档要学Android手机开发，J2SE是基础，但也只是个调板，重要的是看J2ME，这个才是手机开发要学的最后才学会使用IDE（一般是Eclipse），要提醒的是如果基础还不是很扎实的时候千万不要胡乱用IDE，IDE虽然方便，但是原理还没吃透的时候还是多用手敲一下，IDE是把双刃剑，可以帮高手提升功力，也可以把初学者变成白痴。最后一点，如果你是要学Android开发的话，Java只是一个方面，多看XML方面的知识

 

 

--------- android培训、java培训、期待与您交流！ ----------