java_1.5版本新特性和5个常用类

黑马程序员_java_1.5版本新特性

泛型：

JDK1.5版本以后出现的新特性。用于解决安全问题，是一个安全机制。

好处：

       1、将运行时出现问题ClassCastException，转移到了编译时期。方便解决问题，让运行问题减少，安全。

       2、避免了强制转换麻烦。

  泛型类：

什么时候定义泛型类：当类中要操作的引用数据类型不确定的时候。

泛型出现之前定义Object来完成扩展，现在定义泛型来扩展。

例如：

class Tool<T>{

   private T t;

   public void setTt(T t){

      this.t = t;

   }

   public TgetTt(T t){

      return t;

   }

}

泛型定义在类上，在操作此类时，整个类中只能操作同一种指定类型。如果被方法使用，方法就只能使用固定类型号。

  泛型方法：

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

例如：

class Tool{

   public <T>void setTt(T t){

       

   }

   public <Q> Q getTt(Q q){

      return q;

   }

}

静态方法泛型：

静态方法不可以访问类上定义的泛型。

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

例如：

class Tool<T>{

   public <T>void setTt(T t){

       

   }

   public static <W> void get(W w){

     

   }

}  注意：静态方法泛型定义在static后面，返回值前面。

泛型接口：

       1、泛型定义在接口上，实现类指定类型。

       2、泛型定义在接口上，实现类不指定类型，实例化时指定类型。

泛型的限定：

       通配符？：可以理解为占位符。

例如：

public static void printColl(ArrayList<?> al){

      Iterator<?> it = al.iterator();

      while(it.hasNext()){

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

      }

}

此方法的<?>代表着此方法可以迭代ArrayList集合中存的任何类的的元素。

也可以定义成：

public static void printColl(ArrayList<T> al){

      Iterator<T> it = al.iterator();

      while(it.hasNext()){

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

      }

}

此时定义成<T>，可以对迭代的元素进行操作，比如：T t = it.next(); t.getName();之类的。

泛型的限定：

       <？ extends  E>：可以接收E类型或者E的子类型，上限。

       <？ super  E>：可以接收E类型或者E的父类型，下限。

练习：

/*

 * 建立父类的比较器，传给子类对象存入的TreeSet集合中。

 * */

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

 

public class GennericTest {

   public static void main(String[] args) {

      //创建TreeSet集合，并泛型限定存入Student对象。将父类Person的比较器传入。

      TreeSet< Student > ts1 = new TreeSet< Student >(new Comp());

      ts1.add(new Student ("xianbo",20));

      ts1.add(new Student ("fanbo",25));

      ts1.add(new Student ("fanyin",27));

      ts1.add(new Student ("zhou yifei",25));

      ts1.add(new Student ("huangquan",29));

      //打印出排序后的Student对象。

      Iterator< Student > it = ts1.iterator();

      while(it.hasNext()){

         Student p = it.next();

         System.out.println(p.getName()+"  "+p.getAge());

      }

      //创建TreeSet集合，并泛型限定存入Worker对象。将父类Person的比较器传入。

      TreeSet<Worker> ts2 = new TreeSet<Worker>(new Comp());

      ts2.add(new Worker("樊波",20));

      ts2.add(new Worker("向波",24));

      ts2.add(new Worker("黄权",55));

      ts2.add(new Worker("除曼",15));

      //打印出排序后Worker对象。

      Iterator<Worker> it1 = ts2.iterator();

      while(it1.hasNext()){

         Worker p = it1.next();

         System.out.println(p.getName()+"  "+p.getAge());

      }    

   }

}

//Person父类

class Person{

   private Stringname;

   private int age;

   Person(String name,int age){

      this.name = name;

      this.age = age;

   }

   public String getName(){

      return name;

   }

   public int getAge(){

      return age;

   }

}

//Student子类。

class Studentextends Person{

   Student(String name, int age){

      super(name,age);

   }

}

//Worker子类。

class Worker extends Person{

   Worker(String name,int age){

      super(name,age);

   }

}

//父类泛型的比较器。

class Comp implements Comparator<Person>{

   public int compare(Person p1,Person p2){

      int num = p1.getAge()-p2.getAge();

      if(num == 0)

         return p1.getName().compareTo(p2.getName());

      return num;

   }

}

 

高级for循环：

对集合进行遍历时，只能获取元素，不能对集合进行操作。

迭代器：除了遍历，还可以进行remove集合中元素的动作。

如果使用ListIterator，还可以在遍历过程中进行增删改查的动作。

传统for和高级for有什么区别？

高级for有一个局限性，必须有被遍历的目标。

建议在遍历数组的时候，还是用传统for，因为传统for可以定义脚标。

如何用高级for遍历一个Map集合？

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

      hm.put("fanbo", 30);

      hm.put("huangquan", 20);

      hm.put("xiangbo", 44);

      hm.put("linlin", 32);

      for(Map.Entry<String, Integer> me : hm.entrySet()){

         System.out.println(me.getKey()+"----"+me.getValue());

      }

可变参数：

   public static void main(String[] args) {   

      method(2,43,5,6,66);

      method(2,66);

   }

   //定义有可变参数的方法。参数是任意长度的数组。

   public static void method(int... arr){ 

      System.out.println("参数数组长度："+arr.length);//打印出可变参数的长度。

      //遍历打印出可变参数里的值。

      for(int a : arr){

         int aa= a;

         System.out.println(aa);

      }

   }

注意：可变参数一定要定义在参数列表最后面。前面可以传其它参数。

例：method(Stringstr,int...arr)

静态导入：

Array.sort();

Array.binarySearch();

Arrays.toString();

import staticjava.util.Arrays.*;  //导静态。

静态导入后，可以这样写：

sort();

binarySearch();

Arrays.toString()：这个方法不能省Arrays.原因：当类名重名时，需要指定具体的包名，当方法重名时，指定具备所属的对象或者类。

示例：import static java.lang.System.*;

          out.println("abc");

 

 

System：

获取系统属性信息：Propertise getProperties()；

Properties p = System.getProperties();

      for(Object obj : p.entrySet()){

         String value = (String)p.get(obj);

         System.out.println(obj+":--:"+value);

      }    

      String value = System.getProperty("os.name");//获取当前操作系统。

      System.out.println("os:"+value);

 

Runtime：

该类并没有提供构造函数，说明不可以new对象。那么多会直接想到该类中的方法静态的。发现该类中还有非静态方法，说明该类肯定会提供了方法获取本类对象有，而且该方法是静态的，并返回值类型是本类类型。该方法是getRuntime()。

由这个特点可以看出该类使用了单列设计模式完成。

exec()方法，可以打开windows中任何一个可执行文件，返回类型为进程Process。

示例：

       Runtime r = Runtime.getRuntime();

      Process p1 =r.exec("notepad.exe");//创建一进程p，打开notepad.exe文件。

      Process p2 = r.exec("notepad.exe  SystemTest.java");//创建一进程p，用notepad打开SystemTest.java文件。

      Thread.sleep(5000);//停5秒。

      p2.destroy();//杀掉p进程。

Date：

       示例：

Date d = new Date();//定义日期类。

      SimpleDateFormat sfm = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss");//按指定格式格式化。

      String date= sfm.format(d);//将当前日期按指定格式格式化。

      System.out.println(date);//打印格式化后的日期。

日期和时间模式：

字母

日期或时间元素

表示

示例

G

Era 标志符

Text

AD

y

年

Year

1996; 96

M

年中的月份

Month

July; Jul; 07

w

年中的周数

Number

27

W

月份中的周数

Number

2

D

年中的天数

Number

189

d

月份中的天数

Number

10

F

月份中的星期

Number

2

E

星期中的天数

Text

Tuesday; Tue

a

Am/pm 标记

Text

PM

H

一天中的小时数（0-23）

Number

0

k

一天中的小时数（1-24）

Number

24

K

am/pm 中的小时数（0-11）

Number

0

h

am/pm 中的小时数（1-12）

Number

12

m

小时中的分钟数

Number

30

s

分钟中的秒数

Number

55

S

毫秒数

Number

978

z

时区

General time zone

Pacific Standard Time; PST; GMT-08:00

Z

时区

RFC 822 time zone

-0800

 

Calendar：

       set()：

add()：

package OtherObjectTest;

import java.util.Calendar;

public class CalendarTest {

   public static void main(String[] args) {

      //获取当前默认时间。

      Calendarnow = Calendar.getInstance();

      now.set(2015, 3, 15);//设置日期。

      now.add(Calendar.YEAR, 5);//在当前日期的基本上加5年。

      now.add(Calendar.DAY_OF_MONTH, -5);//在当前日期的基本上减5天。

      //封装12个月。

      String[] months = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};

      //封装一个礼拜天数。

      String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

      int dex1 = now.get(Calendar.MONTH);

      int dex2 = now.get(Calendar.DAY_OF_WEEK);

      sop(now.get(Calendar.YEAR)+"年");//取年份。

      sop(months[dex1]);//取月份。

      sop(now.get(Calendar.DAY_OF_MONTH)+"日");//取号数。

      sop(weeks[dex2]);//取星期几。

   }

   public static void sop(Object obj){

      System.out.println(obj);

   }

}

Math：

abs(double d)：返回d的绝对值。

ceil(double d)：返回大于d的最小整数。

floor(double d)：返回小于d的最大整数。

round(double d)：返回一个四舍五入后的整数。

pow(double a,int b)：返回a的b次方。

randow()：随机数。返回0～1之间。大于或等于0.0，小于1.0。

int d =(int)Math.random()*10+1;随机生成1~10之间的整数。

Util包下有一个Random类。可以随机生成整数的方法。

例： Random r =new Random();

       for(int x =0; x<10;x++){

         int d = r.nextInt(10);//随机生成0~10的数，包含0不包含10。

         System.out.println(d);

      }