黑马程序员--JDK5.0 新特性

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

  JDK5.0中新增了很多新的java特性，利用这些新语法可以帮助开发人员编写出更加高效、清晰，安全的代码。

一、静态导入

·静态导入用于简化程序对类静态属性和方法的调用。

·语法：import static 包名.类名.静态属性|静态方法|*;

·例如：

import static java.lang.System.out;

import static java.util.Arrays.*;

 

public class Demo1{

public  static void main(String args[]){

out.print(“hehe”);

 

int arr[] = {1,2,3,4,5}

binarySearch(arr,3);

}

}

 

二、自动装箱/拆箱

装箱：指开发人员可以把一个基本数据类型直接赋给对应的包装类型。

拆箱：指开发人员可以把一个包装类对象直接赋给对应的基本数据类型。

例：

public  class Demo2{

public static void main(String args[]){

//装箱

Integer i = 12;  //相当于 Integer i=new Integer(12);

 

//拆箱

int  j = i;

}

}

三、增强for循环

增强for循环可以用在数组或实现Iterable接口的集合类上，使用它会使用你的代码短小而精练得多。

语法格式：

for(变量类型 变量 ：需迭代的数据或集合){

}

 

例：

import org.junit.Test;

import java.util.Map;

import java.util.List;

 

public class Demo3{

 @Test

 public void test1(){

int arr[]={1,2,3,4,5};

 

for( int i : arr){

System.out.println(i);

}

}

@Test

            public void test2(){

List list=new ArrayList();

list.add(1);

list.add(2);

list.add(3);

list.add(4);

 

for(Object obj : list){

int i=(Integer)obj;

System.out.println(i);

}

             }

@Test

            public void test3(){

Map map=new HashMap();

map.put(“1”,“aa”);

map.put(“2”,“bb”);

map.put(“3”,“cc”);

 

//方法1

for(Object obj : map.keySet){

String key=(String)obj;

String value=(String)map.get(key);

System.out.println(key+“=”+value);

}

 

//方法2

for(Map.Entry entry : map.entrySet){

String key=entry.getKey();

String value=entry.getValue();

System.out.println(key+”=”+value);

}

 

             }

}

使用增强for时需要注意的问题：

a,增强for只适合取数据。

b,如果需要修改数组或集合中的数据，要用传统for.

四、可变参数

可变参数就是为方法定义长度可变参数。

语法：public void demo(int ...nums){

          }

例：

import org.junit.Test;

public class Demo4{

@Test

public void testSum(){

sum(1,2,3,4,5,6);

}

 

public void sum(int...nums){//相当于数组

int sum=0;

for(int i : nums){

sum+=i;

}

System.out.println(sum);

}

 

       //可变参数需要注意的问题:public void test(int ...nums,int x){} 这样写不行

public void test(int x,int ...nums){

 

}

     }

五、枚举

一些程序在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，jdk5以前采用自定义类来解决，jdk5以后可以直接采用枚举解决。

·一个枚举也可以有构造函数、字段和方法。

例1：

public class Demo5{

@Test

public void test(){

println(Grade.B);

}

public void print(Grade g){//只接受Grade类型的A、B、C、D、E

String value=g.getValue();

System.out.println(value);

}

}

//jdk5以前的解决方法

/*class Grade{

private Grade(){}

public static final Grade A=new Grade();

public static final Grade B=new Grade();

public static final Grade C=new Grade();

public static final Grade D=new Grade();

public static final Grade E=new Grade();

 

}

*/

//jdk5以后用枚举解决

enum Grade{

A(“100-90”),B(“89-80”),C(“79-70”),D(“69-60”),E(“59-0”);

private String value;

private Grade(String value){

this.value=value;

}

public String getValue(){

return this.value;

}

}

 

例2：带抽象方法的枚举

enum Grade{

A(“100-90”){

public String localeValue(){

return “优”;

}

}

,B(“89-80”){

public String localeValue(){

return “良”;

}

}

,C(“79-70”){

public String localeValue(){

return “一般”;

}

}

,D(“69-60”){

public String localeValue(){

return “差”;

}

}

,E(“59-0”);{

public String localeValue(){

return “不及格”;

}

}

private String value;

private Grade(String value){

this.value=value;

}

public String getValue(){

return this.value;

}

 

public abstract String localeValue(){

}

}

 

枚举类具有如下特性：

1，枚举类也是一种特殊形式的java类。

2，枚举类中声明的每一个枚举值体表枚举类的一个实例对象。

3，与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数，但枚举类的构造函数必须为私有的。

4，枚举类也可以实现接口、或继承抽象类。

5，jdk5中扩展了switch语句，它除了可以接收int,byte,char,short外还可以接收一个枚举类型。

6，若枚举类只有一个枚举值，则可以当作单例设计模式使用。

六、反射（Reflect）

一个类有多个组成部分，例如：成员变量、方法、构造方法等。反射就是加载类，并解剖出类的各个组成部分。什么时候需要  用到反射呢？ 比如：做框架的时候。

·加载类，forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装。

  加载类的3种方式：1，Class claaz1=Class.forName(“cn.itcast.reflect.Person”);

2，Class clazz2=new Person.getClass();

3，Class clazz3=Person.class;

·解剖类(个人习惯这样叫，书面上叫反射)，解剖出类中的构造函数、方法和字段。解剖出的成员分别用Constructor、Method、 Field对象表示。

Class对象提供了如下常用方法：

                getConstructor(Class<?>... parameterTypes) 

getMethod(String name,Class<?>... parameterTypes)

getField(String name)

 

getDeclaredConstructor(Class<?>... parameterTypes) 

getDeclaredMethod(String name, Class<?>... parameterTypes) 

getDeclaredField(String name) 

 

例：

class Person{

String name=”aaaa”;

private int age=20;

public Person(){

System.out.println("person");

}

public Person(String name){

System.out.println(name);

}

public Person(String name,int age){

System.out.println(name+”:”+age);

}

private Person(List list){

System.out.println(“list”);

}

public Class []aa1(String name,int[] password){

return new Class[]{String.class};

}

public static void main(String args[]){

System.out.println(“main”);

}

} 

 

public class Demo6{

//反射类的构造函数1，创建类的对象

@Test

public void test1() throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Constructor c=clazz.getConstructor(null);

Person p=(Person) c.newInstance(null);

}

//反射类的构造函数2，创建类的对象

@Test

public void test2()throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Constructor c=clazz.getConstructor(String.class);

Person p=(Person) c.newInstance("hehe");

}

//反射类的构造函数3，创建类的对象

@Test

public void test3()throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Constructor c=clazz.getConstructor(String.class,int.class);

Person p=(Person) c.newInstance("hehe",20);

}

 

  //暴力反射,类私有的东西不能被外界访问，但通过反射可以做到。

@Test

public void test4() throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Constructor c=clazz.getDeclaredConstructor(List.class);

c.setAccessible(true);

Person p=(Person) c.newInstance(new ArrayList());

}

//反射类的方法1

@Test

public void test5() throws Exception{

  Class clazz=Class.forName("cn.itcast.pongo.Person");

  Person p=(Person) clazz.newInstance();

  Method m=clazz.getMethod("run", null);

  m.invoke(p, null);

}

//反射类的方法2

@Test

public void test6() throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Person p=(Person) clazz.newInstance();

Method m=clazz.getMethod("run", String.class);

m.invoke(p, "to");

}

//反射类的方法3

@Test

public void test7() throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Person p=(Person) clazz.newInstance();

Method m=clazz.getMethod("aa1", String.class,int[].class);

int arr[] = null;

Class c[]= (Class[]) m.invoke(p, "to",arr);

System.out.println(c[0]);

     }

//反射类的方法4, 反射main方法

@Test

public void test8() throws Exception{

Class clazz=Class.forName("cn.itcast.pongo.Person");

Method m=clazz.getMethod("main", String[].class);

m.invoke(null, (Object)new String[]{"ad","ac"});

}

//反射类的字段1

@Test

public void test9() throws Exception{

Person p=new Person();

Class clazz=Class.forName("cn.itcast.pongo.Person");

Field f=clazz.getField("name");

String name=(String) f.get(p);

System.out.println(name);

}

//反射类的字段2

@Test

public void test10() throws Exception{

Person p=new Person();

Class clazz=Class.forName("cn.itcast.pongo.Person");

Field f=clazz.getField("age");

f.setAccessible(true);

int age=f.getInt(p);

System.out.println(age);

}

 

//操纵bean的指定属性:name

@Test

public void test2() throws Exception{

Book b=new Book();

//得到指定属性的写方法，为属性赋值

PropertyDescriptor pd=new PropertyDescriptor("name",Book.class);

Method m=pd.getWriteMethod();

m.invoke(b, "xiaoming");

//获取属性的值

m=pd.getReadMethod();

System.out.println(m.invoke(b, null));

}

//获取当前属性的类型

@Test

public void test3() throws Exception{

Book b=new Book();

PropertyDescriptor pd=new PropertyDescriptor("name",Book.class);

System.out.println(pd.getPropertyType());

                }

}

 

七、内省（Introspector）

为什么要学内省，经常需要使用java对象的属性来封装程序的数据，每次都使用反射技术完成此类操作过于麻烦，所以Sun公司开发了一套API，专门用于操作java对象的属性。

·内省访问JavaBean属性的两种方式：

1，通过PropertyDescriptor类操作Bean的属性。

2，通过Introspector类获得Bean对象的BeanInfo，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor）， 通过这个属性描述器可以获取某个属性对应的getter/setter方法，然后通过反射机制来调用这些方法。

    ·一个Bean的属性由它的get或set方法决定。

例：

public class Book {

private String name;

private String author;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getAuthor() {

return author;

}

public void setAuthor(String author) {

this.author = author;

}

}

 

import java.beans.BeanInfo;

import java.beans.IntrospectionException;

import java.beans.Introspector;

import java.beans.PropertyDescriptor;

  public class Demo7{

 //获取bean的所有属性

@Test

public void test1() throws Exception{

BeanInfo info=Introspector.getBeanInfo(Book.class,Object.class); //去掉父类属性,     PropertyDescriptor pds[]=info.getPropertyDescriptors();

for(PropertyDescriptor pd : pds){

System.out.println(pd.getName());

}

}

 

八、泛型（Generic）

·jdk5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型强制转换，这样不可以避免就会引发程    序的一些安全性问题。

例：

ArrayList list=new ArrayList();

list.add(“bcd”);

Integer a=(Integer)list.get(0); //编译通过，运行时会抛异常

·jdk5中的泛型允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生的问题，转变为编 译时的问题，以此提高程序的可读性和稳定性。

例：

public class Demo8(){

public static void main(String []args){

 

List<String> list=new ArrayList<String>();

list.add("123");

String s=list.get(0);

}

}

泛型类,什么时候定义泛型类？

当类中操作的引用数据类型不确定的时候，

早起定义Object来完成扩展。

现在定义泛型来完成扩展。

 

class Utils<QQ>

{

    private QQ q;

    public void setObject(QQ q);

     {

        this.q=q;

  

      }

    public QQ gerobject()

     {

       return q;

   

     }

 

}

 

泛型方法：

泛型类定义的反应，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

 

为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

 

class Demo

{  

    public <T> void show(T t)

   {

    

    }

}

 

静态方法泛型：静态方法不可以访问类上定义的泛型，如果静态方法操作的数据类型不确定，可以将泛型定义在方法上。

 

public static <W>  void menthod(W w){}

 

泛型接口：

 

interface Inter<T>

{

   void show(T t);

}

 

class InterImpl<R> implements Inter<R>

{

     public void show(R r) 

      { 

          System.out.println("show:"+r); 

      }

}

 

            该日志来自学习方立勋老师的《30天轻松掌握JavaWeb视频》过程中做的笔记， 未总结到的地方，还请补充！ 谢谢！