java入门基础学习----泛型

概念：泛型就是参数化类型，使用广泛的类型

作用：

1. 安全：在编译的时候检查类型安全； 2.省心：所有的强制转换都是自动和隐式的，提高代码的重用率

一、泛型类：声明时使用泛型
字母：
  T Type 表示类型
  K V 分别代表兼职中的Key Value
  E 代表Element
  使用是确定类型
  注意：
  1.泛型只能使用引用类型，不能基本类型
  2.泛型声明时字母不能使用在静态属性|静态方法上

接口中泛型字母只能使用在方法中，不能使用在全局常量中

泛型方法<>，返回类型前面
只能访问对象的信息，不能修改信息（因为类型不确定）

二、抽象类继承

package com.kennosaur.gen03;
/**
 * 父类为泛型类
 * 1.属性
 * 2.方法
 * 
 * 要么同时擦除，要么子类大于等于父类的类型,
 * 不能子类擦除,父类泛型
 * 1.属性类型
 *   父类中，随父类而定
 *   子类中，随子类而定
 * 2.方法重写
 *   随父类而定
 * @author Administrator
 *
 * @param <T>
 */
public abstract class Father<T,T1> {
	T name;
	public abstract void test(T t);
}

/**
 * 子类指定具体类型
 * 属性类型为具体类型
 * 方法同理
 */
class Child1 extends Father<String,Integer>{
	String t1;
	@Override
	public void test(String t) {
		t1 = this.name;		
	}	
}
/**
 * 子类为泛型类，类型在使用时确定
 *
 *
 */
class Child2<T1,T> extends Father<T,T1>{
	T t2;
	@Override
	public void test(T t) {
				
	}	
}

/**
 * 子类为泛型，父类不指定类型---泛型的擦除,使用Object替换
 */
class Child3<T1, T2> extends Father{

	@Override
	public void test(Object t) {
				
	}	
}

/**
 * 子类与父类同时擦除
 */
class Child4 extends Father{

	@Override
	public void test(Object t) {
				
	}	
}

/**
 * 错误：子类擦除，父类使用泛型
 */
//class Child5 extends Father<T, T1>{
//
//	@Override
//	public void test(T t) {
//		
//	}
//
//}

三、接口泛型

package com.kennosaur.gen03;
/**
 * 泛型接口:与继承同理
 * 重写方法随父类而定
 * @author Administrator
 *
 * @param <T>
 */
public interface Comparable<T> {
	void compare(T t);
}
//声明子类指定具体类型
class Comp implements Comparable<Integer>{

	@Override
	public void compare(Integer t) {
		// TODO Auto-generated method stub
		
	}
	
}
//擦除
class Comp1 implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}

//父类擦除，子类泛型
class Comp2<T> implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}

//子类泛型>=父类泛型
class Comp3<T> implements Comparable<T>{

	@Override
	public void compare(T t) {
		// TODO Auto-generated method stub
		
	}
	
}

//父类泛型，子类擦除----错误
//class Comp4 implements Comparable<T>{
//	
//}

四、泛型的擦除

1.继承|实现声明时不指定类型；

2.使用时不指定类型

统一Object对待

五、泛型没有多态

通配符？

package com.kennosaur.gen04;

import com.kennosaur.gen01.App;

/**
 * ?的使用：声明类型|声明方法上，不能声明类或使用时
 * ? extends: <=上限， 指定类型为子类或自身
 * ? super :  >=下限，指定类型为自身或父类
 * @author Administrator
 *
 */
public class Student<T> {
	 T score;
	 
	 public static void main(String[] args) {
		 Student<?> stu = new Student<String>();
		 test(new Student<Integer>());
		 test2(new Student<Apple>());
		 //test3(new Student<Apple>());   错误，泛型没有多态
		 
		 //test4(new Student<Apple>());   X错误
		 
//		 stu = new Student<Fruit>();
//		 test4(stu);                      X错误
		 
		 test4(new Student<Object>());
		 test4(new Student<Fruit>());
	 }
	 
	 public static void test(Student<?> stu) {
		 
	 }
	 
	 public static void test2(Student<? extends Fruit> stu) {
			 
	 }
	 public static void test3(Student<Fruit> stu) {
		 
	 }
	 
	 public static void test4(Student<? super Fruit> stu) {
		 
	 }
}

泛型的嵌套：使用时从外到内，一层层拆分

泛型数组是不存在的

没有泛型数组，不能创建泛型数组

可以只有声明，可以使用“?”声明，没有实际意义

java入门基础学习----泛型

猜你喜欢