黑马程序员_Java基础加强_1.5的新特性

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！---------------------- 

一、Eclipse工具使用

1、Eclipse常用快捷键：

    A：alt+/ 内容辅助键 这个功能很酷啊."酷就一个字，我只说一次"

    B：ctrl+/ 单行注释，在按一次，取消单行注释

    C：ctrl+shift+/ 对选中的区域进行多行注释的封装

    D：ctrl+shift+\ 用于取消多行注释，只要光标在多行注释中即可

    E：ctrl+shift+o 对使用了其他包中的类或者接口进行自动导入

    F：ctrl+shift+f 对代码进行格式化

    G：alt+上键 向上移动当前行或者选中行

    H：alt+下键 向下移动当前行或者选中行

    I：ctrl+d 删除当前行，或者删除选中行

    J：ctrl+shift+x 将选中部分的字母大写

    K：ctrl+shift+y 将选中部分的字母小写

    L：ctrl+1 光标放在编译中出现红色波浪线提示的内容上，

2、在Eclipse 中如何设置快捷键：

 

　　 Windows->Preferences->General -> Editors ->Key （Content Assist：内容助理） 这样的设置对一个工作台中的所有项目应用。

 

　　 注意：设置快捷键时，要解除原来的绑定关系。

 

3、设置代码模版：如输入syso,则可以自动补全System.out.println();

 

　　 Windows->Preferences->General -> Editors ->Templates

 

4、在MyEclipse如何调试：

 

　　右键->Debug as 便会跳到调试透视图。观看一个变量的值：右键->watch

 

　　 关于透视图：很多小窗口的集合。Eclipse 将很多功能小窗口集合成一个透视图，作用于相应的功能。

 

5、配置Eclipse 中的编译和运行环境：

　　Windows->Preferences->java ->Complier 配置Java程序编译版本

 

二、Java 5新特性：

 

1、自动装箱和拆箱

（1）自动装箱和拆箱是由编译器帮助完成从基本数据类型和基本数据类型的包装类之间的转换。

      ①基本数据类型：int，long，double，float，boolean，char，byte，short

 

      ②基本数据类型包装类：Integet，Long，Double，Float，Boolean，Character，Byte，Short

 

（2）自动装箱和拆箱的过程，例如：

  //这里编译器是这样编译的Integer i = new Integer(137);

  Integer i = 137;

  //这里的话是i.intValue();变成了int再和1相加

  int x = i +1;

（3）享元模式由小的具体共同属性的对象变成一个对象，例如：Integer 就从-128到127是同一个对象,也就是一个字节

  Integer i1 = 127;

  Integer i2 = 127;

  Integer i3 = 128;

  Integer i4 = 128;

  System.out.println(i1==i2);//此处是相等的

  System.out.println(i4==i3);//此处不相等

  2、可变参数
     当调用函数的时候不确定要使用多少个参数的时候使用可变参数，可变参数必须放在最后面写入。

     例如：

  getSome(1,2,3,11,1);

 

 //可变参数..这里接收了5个参数，一个是a的，剩下四个在args这个数组里面

 public static void getSome(int a ,Object...args)

 { 

      //以数组的形式存储，方便使用

      for(int x=0;x<args.length;x++)

   System.out.println(args[x]);

 }

 3、增强for循环 增强for循环，能对数组和实现了Iterator接口的集合类进行遍历。例如：

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

//对int数组进行遍历

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

  for(Integer i : arr1)

       System.out.println(i);

//对集合的迭代，迭代器多了一个删除的功能

  Set<String> set = new TreeSet<String>();

  set.add("add");

  set.add("asfasf");

  set.add("fasg");

  Iterator it = set.iterator();

  while(it.hasNext())

  {

       System.out.println(it.next());

  }

 //而这种增强for只能进行遍历

  for(String s : set)

       System.out.println(s);

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

  枚举可以让编译器在编译时就可以控制源程序中填写非法的值，因为普通变量在开发中无法实现这也目标。

  例如：定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法，红灯获取下一个灯是绿灯，

  绿灯获取下一个灯是黄灯。

   public enum enumerationLamp {

 

   //定义绿灯,实现下一个灯是黄灯

   GREED 

   {

        public enumerationLamp next() 

        {

             return YELLOW;

        }

   },

   //定义黄灯,实现下一个等是红灯

   YELLOW 

   {

        public enumerationLamp next() 

        {

             return RED;

        }

   },

   //定义红灯实现下一个等是绿灯

   RED 

   {

        public enumerationLamp next() 

        {

             return GREED;

        }

   };

 

   //定义一个抽象方法，让枚举成员去实现

   public abstract enumerationLamp next();

 

   //重写toString可以实现名字的显示

   public String toString()

   { 

        String name=null;

        switch(this)

        {

             case GREED :   name ="绿灯"; break;

             case RED :     name ="红灯"; break;

             case YELLOW :  name ="黄灯"; break;

        }

        return name; 

   }

}

 5、泛型

 （1）泛型的出现：集合的存放的数据类型不固定，往集合存放数据的时候就会出现安全隐患。

 在最初定义集合到时候就想规定这个集合存储一样数据类型，这样就可以解决此类的安全问题。1.5以后出现了泛型，

 用于解决集合框架的安全问题，让运行时候的ClassCastException异常问题在编译时期就能检测出来，避免了强转的麻烦。

 （2）泛型的格式：通过<>来定义要操作的引用数据类型。例如：

List<String> list = new ArrayList<String>();//声明这个集合只能存储String的数据类型

（3）泛型的形式：有泛型类，泛型方法，泛型接口。例如

 //这里调用的时候指定了Integer，后面的show就不能传递其他类型的数据了

  new genericClass<Integer>().show(1);

//这里print方法是接收任何的参数的

  new genericClass().print(2);

//这里look方法也是接收任何参数，只是调用不用new对象

  genericClass.look(3);

 

//定义一个泛型类

class genericClass<E>

{ 

     //泛型的方法,必须和指定的类的数据引用是一样的

     public void show(E e)

     {

  System.out.println(e+"这随着类的类型改变而改变");

     }

 

     public <T> void print(T t)

     {

  System.out.println(t+"可以接收任何类型的引用数据类型");

     }

 

     public static <W> void look(W w)

     {

  System.out.println(w+"这个是一个静态的方法，也可以定义泛型接收任何引用数据类型");

     }

}

  （4）泛型通配符、向上和向下限定 当定义两种泛型集合，则迭代的时候也要定义两种泛型，这时也可以用通配符？表示。

    在不知道具体的泛型类型的时候也可以用通配符表示<?>。泛型还可以接收该类的子类或父类。

    向上限定<？ extends E>即接收该类或子类。向上限定<？ super E>即接收该类或父类。 

   

   （5）泛型与原始数据类型兼容性，不支持继承关系。例如：

  //和老的版本兼容

  List list = new ArrayList<String>();

  List<String> list = new ArrayList();

  

  //不支持继续,变量声明能装任何类型但是实际只能装String

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

  //这里就是，只能持有String的引用但是装进来的确实object

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

 例如：定义一个Map对象（采用泛型），加入若干个对象，然后遍历并打印出各元素的key和value

 //map对泛型的应用,定义泛型,并添加元素

  HashMap<String, Integer> map = new HashMap<String,Integer>();

  map.put("zhangsan", 10);

  map.put("lisi", 12);

  map.put("wangwu", 12);

  

  //将map转为set再迭代

  Set<Map.Entry<String, Integer>> entrySet = map.entrySet();  

  //增强for遍历集合

  for(Entry<String, Integer> entry : entrySet)

  {

       System.out.println(entry.getKey()+"..."+entry.getValue());

  }

 （6）静态导入

//导入的是Arrays这个类中所有的静态方法 import static java.util.Arrays.* 

//当类名重名时，需要指定具体的包名

//当方法重名时，需要指定具体所属的对象或者类 

  (7)lock,condition和线程池 Lock代替了Synchrinozed的使用，一个Lock可以设置多个Condition监视器，

     可以实现灵活的线程间通信。例如：多线程中的生产者消费者可以优化成Lock和线程池书写

public class lockDemo 

{

   public static void main(String[] args) 

   { 

//新建资源

res r = new res();

//新建线程池，设置4个线程

ExecutorService pool = Executors.newFixedThreadPool(4);

//让线程池执行线程命令

pool.execute(r.inRun);

pool.execute(r.inRun);

pool.execute(r.outRun);

pool.execute(r.outRun); 

   }

}

class res 

{

   private int cont;

   private boolean flag = false;

   //定义锁和2个condition监视器

   Lock lock = new ReentrantLock();

   Condition in = lock.newCondition();

   Condition out = lock.newCondition();

 

   //定义Runnable执行命令

   Runnable inRun = new Runnable()

   { 

//复写run方法

public void run()

{

     while(true)

     {

  //加锁

  lock.lock();

  try 

  { 

       while(flag)

       in.await();//执行一次后等待

       cont++;

       Thread.sleep(500);//方便观看设置了sleep

       System.out.println(Thread.currentThread().getName()+" 进账-"+cont);

       flag = true;//执行一次后改变标记

       out.signal();//唤醒对方的线程

  }

  catch(Exception e){}

  finally

  { 

       //释放资源

       lock.unlock();

  }

     }

}

   };

 

   //定义出账Runnable执行命令

   Runnable outRun = new Runnable()

   { 

//复写run方法

public void run()

{

     while(true)

     {

  //加锁

  lock.lock();

  try 

  { 

       while(!flag)

       out.await();//执行一次后等待

       Thread.sleep(500);//方便观看设置了sleep

       System.out.println(Thread.currentThread().getName()+" 出账--->"+cont);

       flag = false;//执行一次后改变标记

       in.signal();//唤醒对方的线程

  }

  catch(Exception e){}

  finally

  {

       //释放资源

       lock.unlock();

  }

     }

}

   };

}

 8、注解

 （1）注解相当于一种标记，加了注解就等于打上了某种标记。

    以后可以用反射来了解类上面的各种元素上有无任何标记。标记可以加在包，类，字段，方法，和方法的参数，

    以及局部变量上。

（2）注解的生命周期：Java源文件（SOURCE）--class文件（CLASS）---内存中的字节码（RUNTIME）

//@Override//重写的注解，生命周期是源文件,编译完就没用了

 @Deprecated //过时的注解，生命周期是RUNTIME

 @SuppressWarnings("")//废除警告的注解,生命周期是源文件,编译完就没用了

 public static void show()

 {

      System.out.println("I love java");

 }

（3）注解类

//默认生命周期在是Retentionpolicy.class,改变保留这个注解到Runtime生命周期

@Retention(RetentionPolicy.RUNTIME)

//这是元注解指定这注解在什么地方, method 表示可以注解在方法上 ,type是类上等等。。。

@Target({ElementType.METHOD,ElementType.TYPE})

//建立注解类

public @interface AnnotationClass 

{

     String color() default "defaultColor";//default指定默认值

     String value() default "value";//只有一个value可以不用写value=

    int a();//这样定义的话a就代表变量可以在注解的时候赋值

     int a=11;//这样定义的话a就是一个常量

     int[] arr() ;//定义数组

     enumeration.TrafficLamp trafficLamp() default enumeration.TrafficLamp.RED;//也可以定义枚举属性

}

//添加注解类并赋值，没有默认值的一定要赋值

@AnnotationClass(color ="red",value="a",arr = {1,1,1},a=1)

public class annotation 

{

 

     //1.5的新特性注解

     public static void main(String[] args) 

     { 

  //判断此类中是否有注解@AnnotationClass在

  if(annotation.class.isAnnotationPresent(AnnotationClass.class))

  { 

       //获取这个注解的对象

       AnnotationClass atc = (AnnotationClass)annotation.class.getAnnotation(AnnotationClass.class);

       //调用注解注解中的属性,并可参与运算

       System.out.println(atc.color());

       System.out.println(atc.trafficLamp());

       System.out.println(atc.a()+1);

       System.out.println(atc.a+10);

  }  

     }

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！----------------------