泛型除了在集合中的运用，在我们的程序开发中是否还有其他的用处？
当我们定义了一个工具对对象（不确定）进行操作，比如：设置和获取。可以对任何的对象进行操作
package Collection;
//泛型在除了集合中，其他的作用——泛型类的使用
class Tool{
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
public class GenericDemo2_Fanxing {
public static void main(String[] agr){
Tool t = new Tool();
t.setObj("dhiwh");//存入字符串
System.out.println(t.getObj());
}
}
因为是对任意对象操作，所以定义为Object 就可以了，但是当我们需要使用这个元素自身特有的方法时，就需要进行类型强制转换（因为存储的时候类型被提升为 Object，使用特有方法时就需要向下转化，此时就容易引发异常：）
//没有异常的例子
package Collection;
//泛型在除了集合中，其他的作用——泛型类的使用
class Tool{
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
public class GenericDemo2_Fanxing {
public static void main(String[] agr){
Tool t = new Tool();
t.setObj("dhiwh");//存入字符串
//获取字符串的长度
String str = (String)t.getObj();
System.out.println(str.length());
}
}出现异常的例子：
package Collection;
//泛型在除了集合中，其他的作用——泛型类的使用
class Tool{
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
public class GenericDemo2_Fanxing {
public static void main(String[] agr){
Tool t = new Tool();
t.setObj(5);//存入整数对象（也是Object的子类)
//获取对象的长度
String str = (String)t.getObj();
System.out.println(str.length());
}
}
//编译不会出错，运行时会出现类型转换异常：java.lang.ClassCastException: java.base/java.lang.Integer cannot be cast to java.base/java.lang.String
//无法将整型数据强转成字符串类型。解决办法：使用泛型类
package Collection;
//泛型在除了集合中，其他的作用——泛型类的使用
class Tool<P>{//定义成泛型类
private P p;
public P getP() {
return p;
}
public void setP(P p) {
this.p = p;
}
}
public class GenericDemo2_Fanxing {
public static void main(String[] agr){
Tool<String> t = new Tool<String>();//规定操作的对象的类型
//当设置的不是字符串型的对象时，编译就会出错
t.setP("dhwhd");//存入字符串
//获取字符串的长度
String str =t.getP();//省去了强转的麻烦和避免出现类型转换的异常
System.out.println(str.length());
}
}
在开发程序的时候我们可以使用带有泛型的类（集合），根据需要我们也可以自己定义泛型类
泛型方法的使用：
当方法操作的对象不确定和类上的泛型不一致时，这是就可以将反省定义在方法上————泛型方法
package Collection;
//泛型在除了集合中，其他的作用——泛型类的使用
class Tool<P>{//定义成泛型类
private P p;
public P getP() {
return p;
}
public void setP(P p) {
this.p = p;
}
public <E> void print(E e){
//方法操作的对象不确定是否和类操作的对象一样，将泛型定义在方法上，泛型方法
System.out.println(e);
}
}
public class GenericDemo2_Fanxing {
public static void main(String[] agr){
Tool<String> t = new Tool<String>();//规定操作的对象的类型为*字符串*
t.setP("dhwhd");//存入*字符串*
t.print(t.getP());//输出*字符串*
t.print(5);//输出*整型*对象
}
}public static <R> void toString(R r){}//静态方法定义在方法上————————————————————————————————
泛型接口：
泛型定义在接口上
代码示例：
//泛型接口
interface Inter<E>{//其实这个E 相当于形参，只不过这个形参规定了操作的元素的类型
void show(E e);
}
//实现接口时，对类型是明确的
class InterImpl1 implements Inter<String>{
@Override
public void show(String s) {}
}
//实现接口时，对要操作的类型是不明确的，需要调用者来明确
class InterImpl2 <T> implements Inter<T>{
//类上定义泛型将这个泛型传给接口
@Override
public void show(T t){}
}
InterImpl2<String> i = new InterImpl2<String>();//调用者来明确操作的类型再次明确泛型的作用：避免类型转换时的安全问题，同时也增强了代码的复用性