黑马程序员-----Java基础-----泛型

-----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

 泛型：Jdk1.5版本以后出现新特性，用于解决安全问题，是一个安全机制
 
 好处。
 1.将运行时期出现的问题ClassCastException，转移到了编译时期
 方便程序员解决问题，让运行时期问题减少，安全。
 2.避免了强制转换麻烦。
 
 泛型格式：通过<> 来定义要操作的引用数据类型
 在使用java提供的对象时，什么时候写泛型呢？
 通常在集合框架中很常见。
 只要见到<>就要定义泛型。
 
public class GenericTest
{
public static void main(String[] args) 
{
ArrayList<String> al = new ArrayList<String>();

al.add("qwe213");
al.add("qwe21334");
al.add("qwe2133677");
al.add("qwe2");
//al.add(545);

Iterator<String> it =al.iterator();
while(it.hasNext())
{
String s =it.next();
System.out.println(s.length());
}
}


}


public class GenericTest
{
public static void main(String[] args) 
{
TreeSet<String> al = new TreeSet<String>(new CompareTest());

al.add("qwe21321");
al.add("qwe21334");
al.add("qwe2133677");
al.add("qwe2");
//al.add(545);

Iterator<String> it =al.iterator();
while(it.hasNext())
{
String s =it.next();
System.out.println(s);
}
}


}
//泛型 避免强转 
class CompareTest implements Comparator<String>
{
public int compare(String o1,String o2)
{
//只要排序条件
int num =new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num == 0)
return o1.compareTo(o2);//次要条件
return num;
}
}


/*泛型类
当类中要操作的引用数据类型不确定的时候
早期定义Object来完成扩展
现在定义泛型来完成扩展*/




class Worker 
{

}
class Student
{

}
泛型之前做法
class Tool
{
private Object obj;
public void set(Object obj)
{
this.obj = obj;
}
public Object get()
{
return obj;
}
}
class GenericTest
{
public static void main(String [] args)
{
Tool t =new Tool();
t.set(new Worker());//这里Worker要是Student编译时不会报错
Worker w = (Worker)t.get();
}
}


//泛型类之后
class Utils<QQ>
{
private QQ q;
public void set(QQ q)
{
this.q = q;
}
public QQ get()
{
return q;
}
}
class GenericTest
{
public static void main(String [] args)
{
Utils<Worker> u = new Utils<Worker>();
u.set(new Worker());//这里Worker要是Student编译时就会报错。
Worker w = u.get();

}
}


//泛型类定义的泛型，在整个类中有效，如果被方法使用
//那么泛型类的对象明确要操作的具体类型后，所有操作的类型就已经固定了
//为了让不同方法可以操作不同泛型，而且泛型还不确定
//那么可以将泛型定义在方法上。
//定义在方法上：
class Demo10
{
public <T> void show(T t)
{
System.out.println("show--"+t);
}
public <Q> void print(Q q)
{
System.out.println("show--"+q);
}
}
class GenericTest
{
public static void main(String [] args)
{
Demo10 d =new Demo10();
d.show("haha");
d.show(123);
}
}
//定义在类上：
import java.util.*;
class Demo11<T>
{
public void show(T t)
{
System.out.println("show--"+t);
}
public void print(T t)
{
System.out.println("print--"+t);


}
}
class GenericTest
{
public static void main(String [] args)
{
Demo11<String> d = new Demo11<String>();

d.show("haha");
d.print("hehe");
Demo11<Integer> d1 = new Demo11<Integer>();

d1.show(123);
d1.print(new Integer(5));
}
}
//特殊：静态方法不可以访问类上的泛型，
//如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
class Demo12<T>
{
public void show(T t)
{
System.out.println("show--"+t);
}
public <Q> void print(Q q)
{
System.out.println("print--"+q);
}
public static <W> void print(W w)
{
System.out.println("print--"+w);
}
}
class GenericTest
{
public static void main(String [] args)
{
Demo12<String> d = new Demo12<String>();

d.show("haha");
d.print("hehe");
d1.show(123);
d1.print(2);
}
}


//泛型定义在接口上
interface Inter<T>
{
void show(T t);
}
//实现后知道类型
/*class InterTest implements Inter<String>
{
public void show(String t)
{
System.out.println("show--"+t);
}
}*/
//实现后不知道类型
class InterTest1<T> implements Inter<T>
{
public void show (T t)
{
System.out.println("show--"+t);


}
class GenericTest
{
public static void main(String [] args)
{
// InterTest i = new InterTest();
// i.show("haha");
Interest1<Integer> i = new InterTest1<Integer>();
i.show(5);
}

}
}
-----------------------
package Test1;
import java.util.*;
/*
 ? 通配符，也可以理解为占位符。
 ? extends E:可以接受E类型或者E的子类型，上限。
 ? super E： 可以接受E类型或者E的父类。下限。
 */
public class GenericT {
public static void main(String [] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("sdg1");
al.add("sdg2");
al.add("sdg3");
ArrayList<Integer> all = new ArrayList<Integer>();
all.add(4);
all.add(6);
all.add(2);
printColl(al);
printColl(all);
}
public static void printColl(ArrayList<?> al)
{
Iterator<?> it =al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}

}
}
--------------------------
package Test1;
import java.util.*;
public class GenericT2 {


public static void main(String[] args)
{
TreeSet<Student> ts =new TreeSet<Student>(new Comp());

ts.add(new Student("abc01"));
ts.add(new Student("abc04"));
ts.add(new Student("abc05"));
ts.add(new Student("abc02"));

Iterator<Student> it =ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Comp implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
return s1.getName().compareTo(s2.getName());

}
}
class Person
{
private String name;
Person (String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String toString()
{
return "person ;"+name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
//方便操作定义父类泛型
import java.util.*;
public class Test {


public static void main(String[] args)
{
TreeSet<Student> ts =new TreeSet<Student>(new Comp());

ts.add(new Student("abc01"));
ts.add(new Student("abc04"));
ts.add(new Student("abc05"));
ts.add(new Student("abc02"));
Iterator<Student> it =ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Worker> ts1 =new TreeSet<Worker>(new Comp());
ts1.add(new Worker("abc-----02"));
ts1.add(new Worker("abc=====06"));
ts1.add(new Worker("abc00000003"));
ts1.add(new Worker("abc0------9"));
Iterator<Worker> it1 =ts1.iterator();
while(it1.hasNext())
{
System.out.println(it1.next().getName());
}
}
}
class Comp implements Comparator<Person>
{
public int compare(Person s1,Person s2)
{
return s1.getName().compareTo(s2.getName());

}
}
class Person
{
private String name;
Person (String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String toString()
{
return "person ;"+name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}