Java基础（二）—— 泛型

泛型类型

单个参数

多个参数

泛型类型的继承

虽然Integer继承自Number，但是Box 和Box都是Box，同类 不算继承。

原始类型

泛型方法

限制类型参数

示例

泛型类

package 泛型;
/**
* @author JohnnyLin
* @version Creation Time：2020年9月23日 下午11:41:24
* 类说明
*/
/*
 * 原本Fanxing为普通类 使用<T>之后变成了泛型类
 * T起占位符作用 表示不确定类型
 * 当创建该类对象的时候才将该类型确定下来
 */
public class FanXing<T> {

}

class Test{
	public static void main(String [ ]args) {
		FanXing<Integer> f=new FanXing<Integer>();
		
	}
}

泛型方法

泛型包下声明Student类:

package 泛型;
/**
* @author JohnnyLin
* @version Creation Time：2020年9月23日 下午4:11:59
* 类说明
*/
class Student {
	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}


	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]"+"\n";
	}
	public Student() {
		
	}
	public Student(String n,int a) {
		setAge(a);
		setName(n);
	}
}

package 泛型;
import 泛型.Student;

/**
* @author JohnnyLin
* @version Creation Time：2020年9月23日 下午9:14:47
*/
/**
 * @author Johnny
 * @param  
 * @return
 * @param <T>
 */
//泛型类就是在类的后面加入了<T> T充当着占位符的作用表示不确定是什么类型
//只在使用该类创建对象时确定
class A<T> {
	//普通方法
	public void a() {	}	
	//参数为泛型的方法
	public void b(T [] x  ){
	}
	//返回值为泛型的方法
	
	//d方法的参数是E类型的 E的类型在调用该方法时确定
	//解决了d方法的重载问题 避免了重复写 只有参数类型不一样的d方法
	public <E> void d(E e) {
		System.out.println(e.getClass()+"\t :"+e);
	}
	
	/*T类型在创建A类型对象时确定下来
	而static 是优于对象存在的 也就是一经编译 
	 即使没有创建对象也早已经在内存中 因此下面代码会提示：
	 Cannot make a static reference to the non-static type T
	 这种错误跟 在静态方法中调用非静态方法（注意成员方法包括静态方法和非静态方法）一样的错误
	public static void g(T y) {
	}
	*/
	/*
	下面这种写法就不会有问题
	这是因为E类型不依赖于A类型的泛型 不需要创建对象确定
	可以使用 类名.方法名() 调用g方法
	*/
	//带泛型参数的静态方法
	public static <E>  void g(E y) {
		System.out.println("A的静态方法： "+y);
	}

	public <Q> Q[] k(Q ...q) {
		/*
		...表示不定参数 如果一个方法的参数定为不定参数的话，这个参数可以根据参数个数动态生成一个数组
		因此可以用遍历数组的方法 遍历这个不定长的参数数组q
		 */
		

		//增强遍历
		for (Q q2 : q) {
			System.out.println(q2);
		}

		return q;
	}
	
}
public class Test_GenericsMethods{
	public static void main(String[] args) {
		System.out.println("ta.d-----------------");
		A<Integer> ta=new A<Integer>();
		ta.d(123);
		ta.d("hello!!");
		ta.d(new Student("JohnnyLin",20));
		
		System.out.println("A.g(\"s\")-------------");
		A.g("s");
		System.out.println("-------------");
		Integer [] t= {1,5,6,7,0,3};
		Object [] objects=ta.k(t,"s",new Student("JohnnyLin",20));
		for (Object object : objects) {
			System.out.println(object);
		}
		
	}

	
	
}

泛型接口

package 泛型;
/**
* @author JohnnyLin
* @version Creation Time：2020年9月23日 下午11:26:32
* 类说明
*/
//泛型接口 当实现该接口时由实现类确定类型
public interface MyInterface<mm> {

}
//当普通接口使用
class M implements MyInterface {
	
}
//在实现类实现接口时 将类型确定 
class N implements MyInterface<String>{
	
}
//在实现类实现接口时 仍然使用占位符 表示不确定类型
class Q<qq> implements MyInterface<qq>{
	
}

泛型受限

package 泛型;

import java.util.ArrayList;

/**
* @author JohnnyLin
* @version Creation Time：2020年9月23日 下午11:53:37
* 类说明
*/
class Person {
	private int age;
	public Person(int a) {
		setAge(a);
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
class Teacher extends Person{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Teacher(String n,int a) {
		super(a);
		setName(n);
	}
	@Override
	public String toString() {
		return "Teacher [name=" + name + "]";
	}
	
}
class Test2{
	//<? extends Person>确定泛型的上界
	public static void show(ArrayList<? extends Person> a) {
		for (Object object : a) {
			System.out.println(a);
		}
	}
	public  static void main(String args[]) {
		ArrayList<Person> al=new ArrayList<Person>();
		al.add(new Person(28));
		al.add(new Person(36));
		al.add(new Person(54));
		show(al);
		
		ArrayList<Teacher> al2=new ArrayList<Teacher>();
		al2.add(new Teacher("Lili", 25));
		al2.add(new Teacher("joe", 36));
		al2.add(new Teacher("xiao", 35));
		al2.add(new Teacher("qing ", 89));
		show(al2);
	}
	
}

泛型的使用限制