黑马程序员-泛型-T-E-泛型类-泛型方法-泛型接口

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

泛型

格式：

<>

尖括号，是把参数类型作为参数传递给集合。

 

数据结构类名<引用数据类型> 数据结构对象名 = new 数据结构类名<存储的对象类型>

使用迭代器时：

Iterator<引用数据类型>

如：

ArrayList<String> al = new ArrayList<String>;

Iterator<String> it = al.iterator();

 

继承Comparator接口，使用比较器时：

public StringLengthComparator implements Comparator<String > ...

 

继承Comparable接口

 

泛型的好处：

1. 解决了类型的安全问题，将运行时的错误转到编译时就可以查看出来。

2. 避免了编译时，强转类型而带来的安全问题。

 

何时使用泛型？：

当API的集合框架中，出现了<>的标志时，则需要使用泛型。

package com.lxh.collection;
import java.util.*;
public class GenericDemo {

	public static void main(String[] args) {
		TreeSet
   
   
    
     ts = new TreeSet
    
    
     
     (new StringLengthComparator());
		ts.add("sdfsd");
		ts.add("b");
		ts.add("fasefwefas");
		ts.add("adfsa");
		ts.add("ddfsa");
		// 编译时就判断了类型安全的问题。
		//ts.add(2);
		
		// 迭代器也需要声明泛型
		Iterator
     
     
      
       it = ts.iterator();
		
		while(it.hasNext()) {
			String str = it.next();
			System.out.println(str);
		}
	}

}

// 迭代器声明泛型
class StringLengthComparator implements Comparator
      
      
       
        {
	/**
	 * 比较器是String类型的，也就是实际声明了，所以其必须实现的抽象方法compare()的参数列表，
	 * 则必须为String，这就是继承中多态的体现。
	 * */
	public int compare(String s1, String s2) {
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num == 0)
			return s1.compareTo(s2);
		return num;
	}
}

      
      
     
     
    
    
   
   

泛型类：

何时使用反省类：

当定义的类，自己要操作的引用数据类型（基本数据类型不可以）不确定的时候，使用泛型类。

 

表示泛型的标志可以自定义，并非一定是E或者T。

package com.lxh.collection;
public class CreateGenericDemo {
	public static void main(String[] args) {
		Utils
   
   
    
     util = new Utils
    
    
     
     ();
		util.setObject(new Student());
		util.getObject();
		
		/*
		 * 非泛型类的方式
		Tools t = new Tools();
		t.setObject(new Student());
		t.getObject();
		*/
	}

}

/**
 * 泛型类
 * */
class Utils
     
     
      
       {
	private T t;
	public void setObject(T aa) {
		this.t = t;
	}
	
	public T getObject() {
		return this.t;
	}
}

/**
 * 非泛型类型
 * */
class Tools {
	private Object obj;
	public void setObject(Object obj) {
		this.obj = obj;
	}
	
	public Object getObject() {
		return this.obj;
	}
}

class Student {
	public String name = "df";
}

class Teacher {
	
}

     
     
    
    
   
   

l 泛型方法

当泛型定义在类上的时候，其下的方法都会被泛型所使用的引用类型所限制。当想让同一个类的不同方法可以操作不同的引用类型时，则不要在类上定义泛型，而只是在方法上定义泛型。

格式：

public <T> void methodName() ...

package com.lxh.collection;

public class GenericMethod {

	public static void main(String[] args) {
		GenericMethodDemo m = new GenericMethodDemo();
		m.print("abc");
		m.show(123);
 	}

}

class GenericMethodDemo {
	public 
    
    
     
      void print(T t) {
		System.out.println("print:" + t);
	}
	
	public 
     
     
      
       void show(T t) {
		System.out.println("show:" + t);
	}
}

     
     
    
    

使泛型类的方法不适用泛型类的引用类型:

解决方案：

对泛型方法定义自己的泛型。类似于就近原则。

 

静态方法的泛型：

static修饰符修饰的方法，在类对象没有创建之前，即类被虚拟机加载的时候就存储在内存当中了。所以，需要将静态方法定义上泛型。

package com.lxh.collection;

package com.lxh.collection;

public class GenericMethod {

	public static void main(String[] args) {
		GenericMethodDemo2
    
    
     
      m = new GenericMethodDemo2
     
     
      
      ();
		m.print("abc");
		m.show(123);
		GenericMethodDemo2.method(12431321);
 	}

}

class GenericMethodDemo2
      
      
       
        {
	public void print(T t) {
		System.out.println("print:" + t);
	}
	
	/**
	 * 泛型类中，定义泛型方法
	 * */
	public 
       
        void show(Q t) {
		System.out.println("show:" + 5424);
	}
	
	/**
	 * 泛型类中，定义静态泛型方法
	 * */
	public static 
        
        
          void method(T t) { System.out.println("show:" + t); } } 
        
      
      
     
     
    
    

泛型接口：

实现了泛型接口的类仍旧可以定义成为一个泛型类型的。

package com.lxh.collection;

public class GenericInterface {

	public static void main(String[] args) {
		Demo d = new  Demo();
		d.print("ac");
		
		Demo2
    
    
     
      d2 = new Demo2
     
     
      
      ();
		d2.print(456486);
	}

}

class Demo2
      
      
       
        implements Inter
       
       
        
         {
	public void print(T t) {
		System.out.println(t);
	}
}

class Demo implements Inter
        
        
          { public void print(String str) { System.out.println(str); } } interface Inter 
         
           { public void print(T t); }