-------android培训java培训期待与您交流!----------
泛型
- 用于解决安全问题，是一个安全机制的升级。
- 定义：
ArrayList<String> al = new ArrayList<String>();存储String类型的元素集合。<指定引用数据类型>指定的类型也就是泛型定义。 - 泛型带来的好处：
- 将运行时期出现的问题ClassCastException，转移到了编译时期，方便与解决问题。让运行时期问题减少，安全。
- 避免了强制类型转换的麻烦。
- 当使用集合的时候，常使用<>来限定类型。
泛型的使用：
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)
- 泛型限定：
- 上限：
(ArrayList<? extends E> a)"?"继承自E，代表能接受E类型和E的子类型。这种方式也叫上限泛型限定。 - 下限：
(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.*;
- 当类名重名的时候，需要指定具体的报名。
- 当方法重名时，指定具备所属的对象或者类。
网友评论