黑马程序员-泛型-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); } 
          
        
       
       
      
      
     
     
    
    

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值