黑马程序员-基础加强02泛型

最新推荐文章于 2022-02-20 23:23:01 发布

浮光123

最新推荐文章于 2022-02-20 23:23:01 发布

阅读量588

点赞数

本文链接：https://blog.csdn.net/shengxiaguang/article/details/19019725

版权

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

泛型：jdk1.5版本以后出现的一个安全机制。表现格式：< >
好处：
1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。
2：避免了强制转换的麻烦。
 
泛型的格式：
集合类<数据类型> 变量 = new 集合类<数据类型>();
泛型的出现，规定了集合存储的数据类型
 
什么时候使用泛型：
当你用一个类的时候，发现这个类的右边有<>就要使用泛型
当使用集合时，将集合中要存储的数据类型作为参数传递到< >中即可。
 
练习：泛型
 
class GenericDemo  
{  
         public static void main(String[] args)  
         {  
   
                   ArrayList<String> al = new ArrayList<String>();  
   
                   al.add("abc01");  
                   al.add("abc0991");  
                   al.add("abc014");  
   
                   //al.add(4);//al.add(newInteger(4));  自动装箱
                    
   
                   Iterator<String> it = al.iterator();  
                   while(it.hasNext())  
                   {  
                            String s = it.next();  
   
                            System.out.println(s+":"+s.length());  
                   }  
         }  
}  
 
练习：泛型的应用
 
import java.util.*;  
class GenericDemo2  
{  
         public static void main(String[] args)  
         {  
                   TreeSet<String> ts = new TreeSet<String>(new LenComparator());  
   
                   ts.add("abcd");  
                   ts.add("cc");  
                   ts.add("cba");  
                   ts.add("aaa");  
                   ts.add("z");  
                   ts.add("hahaha");  
   
                   Iterator<String> it = ts.iterator();  
   
                   while(it.hasNext())  
                   {  
                            String s = it.next();  
                            System.out.println(s);  
                   }  
         }  
}  
   
   
class LenComparator implements Comparator<String>  
{  
         public int compare(String o1,String o2)  
         {  
                   int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));  
   
                   if(num==0)  
                            returno2.compareTo(o1);  
                   return num;  
         }  
}  


4.2 泛型类。
什么时候定义泛型类？
    当类中要操作的引用数据类型不确定的时候 
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
 
练习六：泛型定义在类上
 class Tool  
{  
         private Worker w;  
         public void setWorker(Worker w)  
         {  
                   this.w= w;  
         }  
         public Worker getWorker()  
         {  
                   returnw;  
         }  
}  
*/  
   
class Worker  
{  
   
}  
class Student  
{  
}  
//泛型前做法。  
class Tool  
{  
         private Object obj;  
         public void setObject(Object obj)  
         {  
                   this.obj= obj;  
         }  
         public Object getObject()  
         {  
                   returnobj;  
         }  
}  
   
class Utils<QQ>  
{  
         private QQ q;  
         public void setObject(QQ q)  
         {  
                   this.q= q;  
         }  
         public QQ getObject()  
         {  
                   returnq;  
         }  
}  
   
   
class GenericDemo3  
{  
         public static void main(String[] args)  
         {  
                   Utils<Worker>u = new Utils<Worker>();  
   
                   u.setObject(newStudent());  
                   Worker w = u.getObject();;  //不需要强转了
                   /* 
                   Toolt = new Tool(); 
                   t.setObject(new Student()); 
                   Worker w = (Worker)t.getObject(); 
                   */  
         }  
}  


4.3 泛型方法
 
泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
 
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。
 
定义在方法上时，放在返回类型的前面，修饰符的后面
例：public  static <W> void method(W t)
 
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
 
练习：泛型定义在方法上
 
class Demo<T>  
{  
         public  void show(T t)  
         {  
                   System.out.println("show:"+t);  
         }  
         public<Q> void print(Q q)  
         {  
                   System.out.println("print:"+q);  
         }  
         public  static <W> void method(W t)  
         {  
                   System.out.println("method:"+t);  
         }  
}  
class GenericDemo4  
{  
         public static void main(String[] args)  
         {  
                   Demo<String> d = new Demo<String>();  
                   d.show("haha");  
                   //d.show(4);  
                   d.print(5);  
                   d.print("hehe");  
   
                   Demo.method("hahahahha");  
   
   
         }  
}  
 
练习：泛型定义在接口上。
 
interface Inter<T>  
{  
         voidshow(T t);  
}  
   
/* 
class InterImpl implementsInter<String> 
{ 
         public void show(String t) 
         { 
                   System.out.println("show:"+t); 
         } 
} 
  
*/  
   
class InterImpl<T> implementsInter<T>  
{  
         public void show(T t)  
         {  
                   System.out.println("show:"+t);  
         }  
}  
class GenericDemo5  
{  
         public static void main(String[] args)  
         {  
   
                   InterImpl<Integer> i = new InterImpl<Integer>();  
                   i.show(4);  
                   //InterImpl i = new InterImpl();  
                   //i.show("haha");  
         }  
}  
 
4.4 泛型的高级应用：限定
 
? 通配符。也可以理解为占位符。
 
泛型的限定：适用于泛型扩展用的
 
？ extends E: 可以接收E类型或者E的子类型。上限。
 
？ super E: 可以接收E类型或者E的父类型。下限
 
练习：泛型的高级应用限定练习
 
import java.util.*;  
class GenericDemo6  
{  
         publicstatic void main(String[] args)  
         {  
                   ArrayList<Person> al = new ArrayList<Person>();  
                   al.add(new Person("abc1"));  
                   al.add(new Person("abc2"));  
                   al.add(new Person("abc3"));  
                   //printColl(al);  
   
                   ArrayList<Student> al1 = new ArrayList<Student>();  
                   al1.add(new Student("abc--1"));  
                   al1.add(new Student("abc--2"));  
                   al1.add(new Student("abc--3"));  
                   printColl(al1);  //ArrayList<? extends Person> al = newArrayList<Student>();error  
   
         }  
         publicstatic void printColl(Collection<? extends Person> al)  
         {  
                   Iterator<?extends Person> it = al.iterator();  
   
   
                   while(it.hasNext())  
                   {  
                            System.out.println(it.next().getName());  
                   }  
         }  
         /* 
         public static void printColl(ArrayList<?> al)//ArrayList al = newArrayList<Integer>();error 
         { 
                   Iterator<?> it = al.iterator(); 
  
  
                   while(it.hasNext()) 
                   { 
                            System.out.println(it.next().toString()); 
                   } 
         } 
         */  
}  
   
class Person  
{  
         private String name;  
         Person(Stringname)  
         {  
                   this.name= name;  
         }  
         public String getName()  
         {  
                   return name;  
         }  
}  
   
class Student extends Person  
{  
         Student(Stringname)  
         {  
                   super(name);  
         }  
   
}  


练习：泛型限定<?super E>的应用
 
import java.util.*;  
class GenericDemo7  
{  
         public static void main(String[] args)  
         {  
                    
                   TreeSet<Student> ts = new TreeSet<Student>(new Comp());  
   
                   ts.add(new Student("abc03"));  
                   ts.add(new Student("abc02"));  
                   ts.add(new Student("abc06"));  
                   ts.add(new Student("abc01"));  
                    
                   Iterator<Student> it = ts.iterator();  
   
                   while(it.hasNext())  
                   {  
                            System.out.println(it.next().getName());  
                   }  
                   /**/  
   
   
   
                   TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());  
   
                   ts1.add(new Worker("wabc--03"));  
                   ts1.add(new Worker("wabc--02"));  
                   ts1.add(new Worker("wabc--06"));  
                   ts1.add(new Worker("wabc--01"));  
   
   
                   Iterator<Worker> it1 = ts1.iterator();  
   
                   while(it1.hasNext())  
                   {  
                            System.out.println(it1.next().getName());  
                   }  
         }  
}  
   
/* 
class StuComp implements Comparator<Student> 
{ 
         public int compare(Student s1,Student s2) 
         { 
                   return s1.getName().compareTo(s2.getName()); 
         } 
} 
  
class WorkerComp implementsComparator<Worker> 
{ 
         public int compare(Worker s1,Worker s2) 
         { 
                   return s1.getName().compareTo(s2.getName()); 
         } 
} 
*/  
   
class Comp implementsComparator<Person>  
{  
         public int compare(Person p1,Person p2)  
         {  
                   return p2.getName().compareTo(p1.getName());  
         }  
}  
   
   
class Person  
{  
         private String name;  
         Person(Stringname)  
         {  
                   this.name= name;  
         }  
         public String getName()  
         {  
                   return name;  
         }  
         public String toString()  
         {  
                   return "person :"+name;  
         }  
}  
   
class Student extends Person  
{  
         Student(Stringname)  
         {  
                   super(name);  
         }  
   
}  
   
class Worker extends Person  
{  
         Worker(Stringname)  
         {  
                   super(name);  
         }  
}  

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------