本文共 5108 字，大约阅读时间需要 17 分钟。

泛型的引入

1. 集合中的问题：
   (1)存取时都应该以Object 方式，影响程序的读写操作
   (2)取出时的强制类型转换操作麻烦，并可能出错
2. 改进办法
   在创建集合时就规定允许保存的类型，然后由编译器自动检测其加入元素的合法性，这样在取出元素时就不用再考虑类型转换的问题

泛型的作用和定义

1. SE5之后开始引入
2. 将原本确定不变的数据类型参数化
3. 作为对JAVA原有类型的扩充，提高程序的类型安全、可维护性和可靠性

import java.util.*;public class FanXing {
   	public static void main(String[] args){
   		Vector v =new Vector();		v.add("huang");		v.add("guo");		v.addElement("quan");		v.addElement(5);		v.addElement(new Date());		System.out.println(v.get(0));		System.out.println(v.get(1));		System.out.println(v.get(2));		System.out.println(v.get(3));		System.out.println(v.get(4));		for(int i=0;i

在Hashtable中的泛型应用（键值对的情况）

import java.util.*;public class HashT {
   	public static void main(String[] args){
   		Hashtable
   
     ht=new Hashtable
    
     ();		ht.put(12,new Person("huang",40));		ht.put(13,new Person("guo",20));				Person p=ht.get(12);		p.print();	}}class Person{
   	private String name;	private int age;	public Person(String name,int age){
   			super(); this.name=name; this.age=age;}	public String getName(){
    return name;}	public void setName(String name){
    this.name=name; }	public int getAge(){
    return age; }	public void setAge(int age){
    this.age=age; }	public String toString(){
   		return "Person[name:"+name+",age:"+age+"]";	}	public void print() {
   System.out.println(toString());}}
    
   

泛型的深入理解

1. 只有泛型类才可启用泛型机制
   泛型类:由类型参数修饰的类称为泛型类：
   Public class Vector< E >{ }
2. 使用泛型后的通用性问题：通配符？的使用
3. 泛型方法
   Public T printf(T a,T b)｛｝
   Public T printf(T a,T b，int x)｛｝//参数中可以有确定的类型

自定义一个泛型类

public class Teacher
   
     {
   	private int id;	private T zj;	public Teacher(int id) {
   		super();		this.id = id;	}	public int getId() {
      return id;  }	public void setId(int id) {
      this.id = id;   }	public T getZj() {
     return zj;   }	public void setZj(T zj) {
      this.zj = zj;   }	public static void main(String[] args) {
   		Teacher
    
      t=new Teacher(10);		t.setZj("shenfenzheng");		System.out.println(t.getZj());				Teacher
     
       t1= new Teacher
      
       (20);		t1.setZj(420106);		System.out.println(t1.getZj());				Teacher t2=new Teacher(30);//系统自动调整为Object类型并会提出安全警告		System.out.println(t2.getZj());        }    }
      
     
    
   

通配符？的使用

import java.util.Vector;public class Tongpei {
   	public static void main(String[] args)	{
           Vector
   
     v=new Vector
    
     ();		v.add("huang");   v.add("guo");		v.addElement("quan");		Vector
     
       v1=new Vector
      
       ();		v1.add(1);    v1.add(2);		v1.addElement(3);		printf(v);		printf(v1);			}	/*public static void printf(Vector 
       
         v)	{    for(Object o:v){  System.out.println(o);   }  }	public static void printf(Vector
        
       
      
     
    
   

泛型方法

public class Fxff {
   	public static void main(String[] args){
   		Fxff f=new Fxff();		String s=f.eql("huang","huang");		Integer i=f.eql(100,200);		System.out.println(s);		System.out.println(i);			}	public 
   
     T eql(T a,T b){
   		if(a.equals(b))   return a;		else   return null;    }}
   

public class Fxff 
   
    {
   	public static void main(String[] args){
   		Fxff f=new Fxff();		//String s=f.eql(“huang”,“huang”);错误		Object s=f.eql("huang","huang");		//Integer i=f.eql(100,200);错误		Object i=f.eql(100,200);		System.out.println(s);   System.out.println(i);		}		public 
    
      T eql(T a,T b){
   		if(a.equals(b))    return a;		else   return null;   }  }
    
   

class Fxff 
   
    {
   	//实例化类的时候指明泛型的具体类型	//public T eql(T a,T b)//参数类型非泛型类限定类型无法调用此方法            public 
    
      T eql(T a,T b)//参数类型非泛型类限定类型亦可调用此方法，输出结果非正常值	{
      if(a.equals(b))    return a;                else   return null;	}	public static void main(String[] args) {
   				Fxff
     
       f=new Fxff
      
       ();		String s=f.eql(“huang”, “huang”);//可行，正常输出		Integer i=f.eql(100,200);//可行，null		System.out.println(s);		System.out.println(i);	}}
      
     
    
   

import java.util.Vector;public class Tongpei1 {
   	public static void main(String[] args)	{
   		Vector
   
     v=new Vector
    
     ();		v.add("huang");   v.add("guo");		v.addElement("quan");		Vector
     
       v1=new Vector
      
       ();		v1.add(1);   v1.add(2);		v1.addElement(3);		  //printf(v); //不可行，对通配符进行了限制，无法执行此方法		printf(v1);			}	public static void printf(Vector
        v)	{
   		for(Object o:v)		{
   			System.out.print(o);		}	}}
      
     
    
   

思考

利用JAVA的反射机制来“攻击”单例模式，并思考如何抵御这样的攻击？

package test;class Elvis  {
         private static boolean flag = false;      private Elvis(){
         }      private  static class SingletonHolder{
             private static final Elvis INSTANCE = new Elvis();      }       public static Elvis getInstance()      {
             return SingletonHolder.INSTANCE;      }      public void doSomethingElse()      {
         }  }public class test{
   	public static void main(String[] args) {
   		Elvis e1=Elvis.getInstance();		Elvis e2=Elvis.getInstance();		System.out.println(e1==e2);  //TRUE	}}

转载地址：https://blog.csdn.net/weixin_45854582/article/details/106266284 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！