集合框架---泛型

集合框架—泛型
泛型

1.集合中存储的元素类型叫做泛型；一种未知的数据类型
*
E：Element元素
*
创建集合的时候就会确定集合的数据类型 例：ArrayList L=new ArrayList(); 会把数据类型作为参数进行传递，赋值给泛型E
*
不使用泛型
*
优点：默认Object类型，可以存储任意类型的数据
*
缺点：不安全会引发异常，想使用特定类型的方法向下转型的时候有可能报错
*
使用泛型
*
优点：1.避免数据类型转换的麻烦，存储的是什么类型，取出就是什么类型； 2.把运行期异常（运行之后抛出的异常）提升到了编译期异常；
*
缺点：泛型是什么类型，只能存储什么类型的数据

2.泛型的使用
*
含有泛型的类
*
泛型可以接受任何数据类型，创建对象的时候确定对象的数据类型
*
格式：访问修饰符 class 类名<泛型>{ }
*
例：
*
*
packagecn.com.Abner.generic;
*
//定义一个含有泛型的类，泛型可以接受任何数据类型，创建对象的时候确定对象的数据类型
*
public class GenericDemo { //泛型
*
private E name;
*
public E getName() {
*
return name;
*
}
*
public void setName(E name) {
*
this.name = name;
*
}
*
}
*
--------删除线格式 ----------------------------------------------------------------------------------

* 
 packagecn.com.Abner.generic;
	* 
public class GenericTest {
	* 
     public static void main(String[] args) {
	* 
          //不写泛型默认为Object类型
	* 
          GenericDemo peron=new GenericDemo();
	* 
          peron.setName("Abner");
	* 
             Object obj=peron.getName();  //取出的也是Object类型
	* 
          System.out.println(obj);
	* //创建GenericDemo对象，确定泛型为Integer类型
	* 
          GenericDemo<Integer> peron1=new GenericDemo();
   peron1.setName(17);
 Integer obj1=peron1.getName();
	* 
          System.out.println(obj1);

   //创建GenericDemo对象，确定泛型为String类型
	* 
          GenericDemo<String> peron2=new GenericDemo();
 peron2.setName("Abner");
  Object obj2=peron2.getName();
	* 
          System.out.println(obj2);
     }
	* 
}
* 

含有泛型的方法
*
含有泛型的方法，在调用方法时确定泛型的类型 传递什么参数，泛型就是什么类型
*
格式：访问修饰符 <泛型> 返回值类型 方法名（ ）{ }
*
packagecn.com.Abner.generic;
*
/*
*
含有泛型的方法，泛型定义在访问修饰符和返回值之间
*
格式：访问修饰符 <泛型> 返回值类型 方法名（ ）{ }
*
含有泛型的方法，在调用方法时确定泛型的类型
*
传递什么参数，泛型就是什么类型
*
*/
*
public class GenericDome1 {
*
//含有泛型的一个方法
*
public void showname(E name) {
*
System.out.println(name);
*
}
*
*
//含有泛型的静态方法
*
public static void showname1(E name) {
*
System.out.println(name);
*
}
*
}
*
----------------删除线格式 ------------------------------------------------------------
*

   packagecn.com.Abner.generic;
    	* 
    public class GenericDemo1Test {
    	* 
         public static void main(String[] args) {
    	* 
              GenericDome1 S=new GenericDome1();
    	* 
              S.showname("Abner");
    	* 
              S.showname(1);
    	* 
              GenericDome1.showname1("Abner.静态");
    	* 
              GenericDome1.showname1(1);
    	* 
         }
    	* 
    }
* 

含有泛型的接口
*
1.接口的实现类中，指定接口的泛型
*
public interface Iterator{ }
*
public final class Scanner implements Iterator{ }
*
接口
*
packagecn.com.Abner.generic;
*
//含有泛型的接口
*
public interface GenericInterface {
*

public abstract void method(E e);
*
}

---

packagecn.com.Abner.generic;
*
/*
*
含有泛型的接口，
*
1.接口的实现类中，指定接口的泛型
*
public interface Iterator{
*
E next();
*
}
*
public final class Scanner implements Iterator{
*
public String next(){ }
*
}
*
*/
*
public class GenericInterfaceImplm implements GenericInterface{
*
@Override
*
public void method(String e) { //实现类指定String
*
System.out.println(e);

}

}

---

packagecn.com.Abner.generic;
	* 
public class test {
	* 
     public static void main(String[] args) {
	* 
          GenericInterfaceImplm W=new GenericInterfaceImplm();     //方法一，接口的实现类中，指定接口的泛型
   W.method("接口中泛类");
 }

}
* 
* 

2.接口使用什么泛型，实现类就用什么类型
*
public interface GenericInterface { }
*
public class GenericInterfaceImplm2 implements GenericInterface { }
*
packagecn.com.Abner.generic;
*
/*
*
接口中的泛型第二种使用：接口使用什么泛型，实现类就用什么类型
*
相当于含有泛型的类，创建对象确认泛型类型
*
*/
*
public class GenericInterfaceImplm2 implements GenericInterface {
*
@Override
*
public void method(Integer e) {
*
System.out.println(e);
*
}

}

---

packagecn.com.Abner.generic;
	* 
public class test {
	* 
     public static void main(String[] args) {       
	* 
          GenericInterfaceImplm2<Integer> R=new GenericInterfaceImplm2();         //方法二，接口使用什么泛型，实现类就用什么类型
	* 
          R.method(1);
	* 
     }
	* 
     
}

3.泛型通配符<?>
*
不知道使用什么类型接收数据的时候，使用<?>;只能接收数据，不能在该集合中存储数据
*
使用方式：不能创建对象使用，只能作为方法的参数使用
*
packagecn.com.Abner.generic;
*
import java.util.ArrayList;
*
import java.util.Iterator;
*
/*
*
泛型的通配符：？代表任意数据类型
*
使用方式：不能创建对象使用，只能作为方法的参数使用
*
/
*
public class Demo1 {
*
/
*
定义一个方法，能遍历所有类型的ArrayList,不知道ArrayList使用什么类型，使用<?>
*
*/
*
public static void printArray(ArrayList<?> t) {
//遍历集合
*
Iterator<?> T=t.iterator();
*
while(T.hasNext()) {
*
Object o=T.next();
*
System.out.println(o);
*
}
*
}
*
public static void main(String[] args) {
*
ArrayList t=new ArrayList();
t.add(1);
*
t.add(2);
ArrayList t1=new ArrayList();
t1.add(“A”);
t1.add(“B”);
printArray(t);
*
}
*
}
*
泛型的上限下限
*
1.上限：类型名称<? extends 类> 对象名称 只能接收该类型及其子类
*
2.下限：类型名称<? super 类> 对象名称 只能接收该类型及其父类