黑马程序员-JDK1.5新特性

——-android培训java培训期待与您交流!———-

泛型

• 用于解决安全问题，是一个安全机制的升级。
• 定义：ArrayList<String> al = new ArrayList<String>();存储String类型的元素集合。<指定引用数据类型>指定的类型也就是泛型定义。
• 泛型带来的好处：
  
  1. 将运行时期出现的问题ClassCastException，转移到了编译时期，方便与解决问题。让运行时期问题减少，安全。
  2. 避免了强制类型转换的麻烦。
• 当使用集合的时候，常使用<>来限定类型。
  泛型的使用：

package com.sergio.JDK5;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
 * Created by Sergio on 2015/1/21.
 */
public class GenericsDemo {
    public static void main(String[] args) {
        Set<String> st = new TreeSet<String>(new StringLenCompare2());

        st.add("adfsfs");
        st.add("adfssdfs");
        st.add("adsdffs");
        st.add("asdfsdfsdf");

        //迭代器中也要指定引用数据类型，从集合中取到元素，迭代器也要指定相应的类型
        Iterator<String> it = st.iterator(); 
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}


//自定义比较器类
class StringLenCompare2 implements Comparator<String> {
    public int compare(String s1, String s2) {
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if (num == 0) {
            return s2.compareTo(s1); //对调两个对象引用，可以将结果倒置
        }
        return num;
    }
}

• 泛型类定义：当类中药操作的引用数据类型不确定的时候,可以定义泛型类来扩展，早期定义Object完成扩展，现在定义泛型完成扩展。

package com.sergio.JDK5;

/**
 * Created by Sergio on 2015/1/21.
 */
public class GenericDemo2 {
    public static void main(String[] args) {
        Utils<Workers> u = new Utils<Workers>();
        u.setObject(new Workers());
        Workers w = u.getObject();
    }
}

//泛型类定义
//当类中药操作的引用数据类型不确定的时候,可以定义泛型类来扩展，早期定义Object完成扩展，现在定义泛型完成扩展。
class Utils<Q>
{
    private Q q;
    public void setObject(Q q)
    {
        this.q = q;
    }
    public Q getObject()
    {
        return q;
    }
}

class Workers
{
}

• 泛型方法：泛型类定义的泛型，在整个类中有效，如果被方法是用。那么泛型类的对象明确要操作的具体类型后，所有要操作的类型都已经固定了。为了让不同方法可以操作不同类型，而且类型不确定，可以将泛型定义在方法上。

package com.sergio.JDK5;

/**
 * Created by Sergio on 2015/1/21.
 */
public class GenericDemo3 {
    public static void main(String[] args) {
        GenericMethod d = new GenericMethod();
        d.show("hahah");
        d.print(4);

        d.show(4);
        d.print("aaaa");
    }
}


//泛型方法定义
class GenericMethod {
    public <T> void show(T t) {
        System.out.println("show:" + t);
    }

    public <T> void print(T t) {
        System.out.println("print:" + t);
    }
} 

当泛型方法和泛型类定义在一起，方法中的引用类型是按照泛型方法定义的引用类型去限定的，而不是泛型类定义的引用类型限定。

class GenericMethod2<T>{
    public <T> void show(T t)
    {
        System.out.println("泛型方法");
    }
}

静态方法不可以访问类上定义的泛型，因为还不知道类上的明确的对象类型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

class GenericMethod3<T>{
    public static <W> void method(W t)
    {
        System.out.println("静态方法的泛型定义方式");
    }

• 泛型接口定义方式(两种方式)：

package com.sergio.JDK5;

/**
 * 泛型定义在接口上
 * Created by Sergio on 2015/1/21.
 */
interface Inter<T> {
    void show(T t);
}


//第一种方式：接口上指定了泛型类型。方法中限定使用这种类型
class InterImplement implements Inter<String> {
    public void show(String t) {
        System.out.println("接口泛型指定类型定义" + t);
    }
}


//第二种方式：接口上指定了泛型类型。实现类中也可以指定泛型类型
class InterImpl2<T> implements Inter<T> {
    public void show(T t) {
        System.out.println("接口实现类泛型指定方法定义方式");
    }
}

• 泛型占位符：

/**
     * 定义打印方法
     * ArrayList<?> a:其中的"？"问号为占位符，就是不确定是什麽引用类型，可以使用此符号替代。
     * @param a :sf
     */
    public static void printCollection(ArrayList<?> a)

• 泛型限定：
  
  1. 上限：(ArrayList<? extends E> a)“?”继承自E，代表能接受E类型和E的子类型。这种方式也叫上限泛型限定。
  2. 下限：(ArrayList<? super E> a)“?”是”E”的父类，代表能接受E类型或者E的父类型。这种方式也叫下限泛型限定。

package com.sergio.JDK5;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
 * 泛型限定
 * Created by Sergio on 2015/1/22.
 */
public class GenericPractice {
    public static void main(String[] args) {
        printResult();
    }

    //泛型限定为Person，可以接受其子类型
    public static void printResult() {
        Set<Person> st = new TreeSet<Person>(new Compare());
        st.add(new Student("sav", 12));
        st.add(new Worker("wabc", 23));

        Iterator<Person> it = st.iterator();
        while (it.hasNext()) {
            Person p1 = it.next();
            System.out.println(p1.getName() + p1.getAge());
        }
    }
}


/**
 * 自定义比较器。比较器中限定的泛型类型为Person类型，也就是他们的祖父类型。(? extends Person).
 * 可以接受Person类型和及其自己的子类型
 */
class Compare implements Comparator<Person> {
    public int compare(Person p1, Person p2) {
        int num = new Integer(p1.getAge()).compareTo(p2.getAge());
        if (num == 0) {
            return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        }
        return num;
    }
}


//祖父类
class Person {
    private String name;
    private int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }
}


class Student extends Person {
    Student(String name, int age) {
        super(name, age);
    }
}


class Worker extends Person {
    Worker(String name, int age) {
        super(name, age);
    }
}

foreach循环

• 格式：
  for(数据类型 变量名:被遍历的集合(Collection)或者数组)
• 对集合进行遍历，只能获取元素，但是不能对集合进行操作。
• 迭代器除了遍历，还可以remove集合中元素的动作。如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
• 与基础for循环比较，高级for循环有一个局限性，必须有被遍历的目标。
• 建议在遍历数组的时候,使用基础性for循环，可以定义数组角标。

package com.sergio.JDK5;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * foreach循环
 * Created by Sergio on 2015-02-24.
 */
public class ForEach {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<>();
        al.add("abc");
        al.add("abc2");
        al.add("abc3");
        //集合foreach
        for (String s : al) {
            System.out.println(s);
        }
        System.out.println(al);
        //数组foreach
        int[] arr = {1, 2, 3};
        for (int s : arr) {
            System.out.println(s);
        }

        //map集合框架foreach。需要转换成Set集合在进行遍历
        HashMap<Integer, String> hm = new HashMap<>();
        hm.put(1, "a");
        hm.put(2, "b");
        hm.put(3, "c");
        //方式一
        Set<Integer> keySet = hm.keySet();
        for (Integer i : keySet) {
            System.out.println(i + "::" + hm.get(i));
        }
        //方式二
        //        Set<Map.Entry<Integer, String>> entrySet = hm.entrySet();
        //        for (Map.Entry<Integer, String> me : entrySet)
        for (Map.Entry<Integer, String> me : hm.entrySet()) {
            System.out.println(me.getKey() + ":::" + me.getValue());
        }
    }
}

可变参数

• 注意：可变参数一定要定义在参数列表最后面的位置上。

package com.sergio.JDK5;

/**
 * 可变参数：数组参数的简写形式，封装了数组对象建立的动作，只需要传递参数即可。
 * 简写前：int[] arr {3, 4, 5};
 *        show(arr);
 * 简写后：show(3, 4, 5);    
 * Created by Sergio on 2015-02-24.
 */
public class ParamMethod {
    public static void main(String[] args) {
        show("hahah", 1, 2, 4);
        show("hehe", 3, 5, 7);
        show("12", "23");
    }

    //两个数据类型的参数列表
    public static void show(String str, int... arr) {
        System.out.println(arr.length);
    }

    //单个数据类型参数列表
    public static void show(String... arr) {
        System.out.println(arr.length);
    }
}

静态导入

• 
  
• 静态导入是导入某个类中的所有静态成员。书写可以省略类名。
  import static java.util.Collecions.*;
  

1. 当类名重名的时候，需要指定具体的报名。
   
2. 当方法重名时，指定具备所属的对象或者类。