黑马程序员——泛型
package com.yang.exspe01;
import java.util.Iterator;
import java.util.TreeSet;
import com.yang.ex.TreeSetDemo.Student;
/*/**
* 泛型：1.5版本之后出现的新特性，用于解决安全问题，是一个安全机制。
* 好处：
* 1.将运行时期出现的问题，转移到了编译时期。
* 方便程序员解决问题，让运行事情问题减少，安全
*
* 2.避免了强制转换的麻烦。
*
* 泛型的格式：通过<>来定义要操作的引用的数据类型
* 在java提供对象时，通常在集合框架中很常见。
* 只要见到<>就是要定义泛型
* 其实<>就是用来接收类型
* 当使用集合时，将集合中要储存的数据类型作为参数传到容器当中
* */
public class Treeset {
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet<String> treeset=new TreeSet<String>();
treeset.add("aaa");
treeset.add("sdf");
Iterator<String> iterator=treeset.iterator();
while (iterator.hasNext()) {
String string=iterator.next();
System.out.println(string);
}
}
}
class MyCompare implements Comparable
{
public int compare(String object1,String object2) {
int num=new Integer(object1.length()).compareTo(new Integer(object2.length()));
if (num==0) {
return object1.compareTo(object2);
return num;
}
}
}
package com.yang.exspe01;
//泛型类
/*当类中要操作引用数据类型不确定时候
* 早期定义Object来完成扩展
* 现在定义泛型来完成扩展。
* */
public class Demo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Utils<Worker> utils = new Utils<Worker>();
utils.setObject();
Worker worker = utils.getObejct();
}
}
class Worker {
}
class Student {
}
/*
* class Tool { private Worker worker; public void setWoker(Worker worker) {
* this.worker=worker; } public Worker getWorker() { return worker; } }
*/
// 泛型类
class Utils<qq> {
private qq q;
public void setObject() {
this.q = q;
}
public qq getObejct() {
return q;
}
}
package com.yang.exspe01;
//泛型类定义的泛型，在整个类中有效，如果被方法是用
//那么泛型类的对象明确遥操作的具体类型后，所有要操作的类型就已经固定了
//为了让不同的方法可以操作不同的类型，而且类型还不确定
//那么可以将泛型定义在方法上
//特殊之处，静态方法不可以访问类上定义的泛型
//如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
//public static<T> void method(T t),放在修饰符的后面 返回值得前面
public class Demo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
yang<String> demo = new yang<String>();
demo.show("hah1");
demo.print("hehe");
demo.show("new");
yang<Integer> demo2 = new yang<Integer>();
demo2.show(new Integer(4));
}
}
class yang<T>
{
public void show(T t) {
System.out.println(t);
}
public void print(T t)
{
System.out.println(t);
}
public static<T> void method(T t)
{
System.out.println(t);
}
}
package com.yang.exspe01;
//泛型定义在接口上
public class Demo3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
InterImpl impl=new InterImpl();
impl.show("haha");
}
}
interface Inter<T>
{
void show(T t);
}
class InterImpl implements Inter<String>
{
public void show(String tString) {
System.out.println("show"+tString);
}
}
package com.yang.exspe01;
/*
* ?通配符，也可以理解为占位符
* 泛型的限定：
* ？ extends E：可以接收E类型或者E类型的子类型。上限
* ？ super E：可以接收E类型或者E的父类型，下限
* 泛型限定 是用来泛型扩展用的
*
* */
import java.awt.print.Printable;
import java.security.AlgorithmConstraints;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> arrayList=new ArrayList<String>();
arrayList.add("adf");
arrayList.add("bdf");
arrayList.add("ertt");
ArrayList<Integer> arrayList2=new ArrayList<Integer>();
arrayList2.add(4);
arrayList2.add(7);
arrayList2.add(3);
printColl(arrayList);
printColl(arrayList2);
}
public static void printColl(ArrayList<?> arrayList){
Iterator<?>iterator=arrayList.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
