泛型的定义及用法

package javaStudy;

import java.util.ArrayList;//导入集合中的ArrayList类包
import java.util.Iterator;//导入集合中的迭代器类包

/*
* 泛型：JDK1.5版本以后出现的新特性 。用于解决安全问题，是一个类型安全机制。
*
* 好处：
* 1.将运行时期出现问题ClassCastException,转移到了编译时期。
*   方便程序员解决问题。让运行事情问题减少，安全。
* 2.避免强制转换麻烦。
*
* 泛型格式：通过<>来定义要操作的引用数据类型。
* 在使用Java提供的对象时，什么时候要写泛型呢？
* 通常在集合框架中很常见，
* 只要见到<>就要定义泛型。
*
* 其实<>就是用来接受类型的。
* 当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
*
*/

public class GenericDemo {
public static void main(String[] args)
{
//定义一个集合容器，并指定泛型，当集合指定某一类型元素时，只能添加指定的元素类型
ArrayList<String> a1=new ArrayList<String>();
a1.add("abc01");//添加元素
a1.add("abc02");
a1.add("abc03");

//a1.add(4);
//a1.add(new Integer(4));
Iterator<String> it = a1.iterator();//通过迭代器获取集合中的元素
while (it.hasNext())
{
String s=(String)it.next();
System.out.println(s+":"+s.length());

}

}
}

package javaStudy;
/**
*
* @author zhaocx1
*
* @param <T>
*/
/*
* 泛型类定义的泛型，在整个类中有效。
* 如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

* 什么时候定义泛型类？当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。
* 为了让不同方法可以操作不同类型，而且类型还不确定。
* 那么可以将泛型定义在方法上。
*
*
* 特殊之处：
* 静态方法不可以访问类上定义的泛型。
* 如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
*/

class Demo<T> {//定义一个类指定泛型
/*
* public void show(T t) { System.out.println("show:"+t);}
*/
/*
* public void print(T q) { System.out.println("print:"+t); }
*/

public void show(T q) {//定义一个方法并指定参数类型
System.out.println("show:"+q);
}

public <T> void print(T q) {
System.out.println("print:"+q);
}
//泛型类型：泛型放在修饰符后面，返回值前面。静态方法不可以访问类上定义的泛型，可以在方法上指定泛型
public static <W> void method(W q)
{
System.out.println("method:"+q);
}
}

public class GenericDemo2 {
public static void main(String[] agrs) {
Demo<String> d = new Demo<String>();//new一个对象进行实例化并指定泛型
//d.show(4);
d.show("heihei"); //当方法上没有定义泛型，必须遵循所在对象指定的泛型

d.print("haha"); //当方法上定义泛型可以打印不同类型的内容
d.print(8);

d.method("hahahaha");
d.method(3);
}

}

package javaStudy;

/**
*
* @author zhaocx1
*
* @param <T>
*/
// 泛型定义在接口。
interface Inter<T> {// 定义一个借口并指定泛型
void show(T t);
}

/*
* class InterImpl implements Inter<String> { public void show(String t) {
* System.out.println("show:" + t); } }
*/
class Intermp1<T> implements Inter<T> {// 定义一个类实现泛型接口
public void show(T t) {// 覆写接口中的方法
System.out.println("show:" + t);// 输出打印内容
}
}

public class GenericInterface {
public static void main(String[] args) {
Intermp1<Integer> i = new Intermp1<Integer>();// new对象，对对象进行实例化

// erImpl i = new InterImpl();
i.show(4);// 调用类中的方法
}

}

package javaStudy;

import java.util.ArrayList;//导入集合中的ArrayList类包
import java.util.Collection;//导入集合中的Collection类包
import java.util.Iterator;//导入集合中的迭代器类包

/**
*
* @author zhaocx1
*
* @param <T>
*/
/*
* ?通配符，也可以理解为占位符。   泛型限定是用于泛型扩展用的。
* 泛型的限定：
* ？ extends E: 可以接受E类型或者E类型的子类型。为上限。  E固定，下面的子类有很多。
* ？ super E:可以接受E类型或者E类型的父类型。为下限。       E固定，上面的父类有很多。
*/

class Person {//定义一个类
private String name;//私有化name属性

Person(String name) {//对类进行构造函数，并将name属性作为参数传递进去
this.name = name;//调用本类对象
}

public String getName() {//定义获取name方法
return name;//返回本类对象
}
}

class Studentb extends Person {//定义一个类继承Person类
Studentb(String name) {//进行构造函数
super(name);//调用父类中的构造函数功能
}
}

public class GenericDemo3 {
public static void main(String[] args) {

ArrayList<Person> a1 = new ArrayList<Person>();//定义一个集合容器，用于存储元素
a1.add(new Person("abc1"));//添加元素
a1.add(new Person("abc2"));
a1.add(new Person("abc3"));
// printColl(a1);
ArrayList<Studentb> a12 = new ArrayList<Studentb>();
a12.add(new Studentb("abc--1"));
a12.add(new Studentb("abc--2"));
a12.add(new Studentb("abc--3"));
printColl(a12);// ArrayList<Person> a1=new ArrayList<Student>();

}
//定义一个静态打印方法参数类型为Collection类型，Collection的泛型是Person子类
public static void printColl(Collection<? extends Person> a1) {
Iterator<? extends Person> it = a1.iterator();//获取一个迭代器获取集合中的元素
while (it.hasNext()) {
System.out.println(it.next().getName());
}

}
}