类型的参数化
- 泛型类可以同时设置多个参数
- 泛型类可以继承泛型类
- 泛型类可以实现泛型接口
示例--泛型类
package com.date;
public class GenericDemo {
public static void main(String[] args) {
GenClass<String> genClass=new GenClass<String>("tanlei");
System.out.println(genClass.getData());
GenClass<Integer> genClass2=new GenClass<Integer>(100);
System.out.println(genClass2.getData());
}
}
//创建一个泛型类
class GenClass<T>{
private T data;
public GenClass(T data) {
this.data = data;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
- 泛型类可以同时设置多个参数
package com.date;
public class GenericDemo {
public static void main(String[] args) {
Genclass2<String,Integer> genclass2=new Genclass2("tanlei", 100);
System.out.println(genclass2.getData1());
System.out.println(genclass2.getData2());
}
}
class Genclass2<T1,T2>{
private T1 data1;
private T2 data2;
public Genclass2(T1 data1, T2 data2) {
this.data1 = data1;
this.data2 = data2;
}
public T1 getData1() {
return data1;
}
public void setData1(T1 data1) {
this.data1 = data1;
}
public T2 getData2() {
return data2;
}
public void setData2(T2 data2) {
this.data2 = data2;
}
}
- 泛型类可以继承泛型类
package com.date;
public class Grneric {
public static void main(String[] args) {
subClass<String,Integer> subClass=new subClass("xiaotan", 22);
System.out.println(subClass.Show1());
subClass.show2(22);
}
}
interface Iinfo<T2>{
public void show2(T2 var2) ;
}
class superClass<T1>{
private T1 var1;
public superClass(T1 var1) {
this.var1 = var1;
}
public T1 Show1() {
return var1;
}
}
class subClass<T1,T2> extends superClass<T1> implements Iinfo<T2>{
private T2 var2;
public subClass(T1 var1,T2 var2) {
super(var1);
this.var2=var2;
}
public T1 Show1() {
return super.Show1();
}
public void show2(T2 var3) {
System.out.println(var3);
System.out.println(var2);
}
}
限制泛型可用类型
可以在定义类型时,使用extends关键字指定这个类型必须继承某个类,或者实现某个接口
package com.date;
public class Extends_InterfaceDemo {
public static void main(String[] args) {
GenericClass<Dog> dogclass=new GenericClass<Dog>();
dogclass.setObj(new Dog());
dogclass.getObj().eat();
GenericClass<Cat> catclass=new GenericClass<Cat>();
catclass.setObj(new Cat());
catclass.getObj().eat();
}
}
//只能接受Animal类型或者Animal类的子类类型
class GenericClass<T extends Animal>{
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗啃骨头");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
类型通配声明
泛型通配的方式
"?"代表任意一个类型
泛型方法
访问修饰符 <泛型列表> 返回类型 方法名(参数列表){
实现代码
}
什么时候用到泛型方法,而不是泛型类呢?
添加类型约束只作用于一个方法的多个参数之间,而不涉及到类中的其他方法
public class Extends_InterfaceDemo {
public static void main(String[] args) {
GenericClass gen=new GenericClass();
gen.println("ABC");
gen.println(true);
gen.println(10);
gen.println(10.8);
gen.println(new Dog());
GenericClass.print("haha");
}
}
class GenericClass{
//泛型方法
public<T> void println(T content) {
System.out.println(content);
}
//泛型方法的重载
public<T extends Animal> void println(T animal) {
animal.eat();
}
public static <T> void print(T content) {
System.out.println(content);
}
}
案例讲解
自定义一个存放指定数据的容器
package com.day1;
import java.util.Arrays;
public class ArrayListDemo {
public static void main(String[] args) {
IContainer<String> list=new Container<String>();
for (int i = 0; i < 12; i++) {
list.add("data:"+(i+1));
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
interface IContainer<T>{
public void add(T obj);//给容器添加数据
public T get(int index);//根据下标 获取指定位置的元素内容
public int size();//返回容器中元素的个数
}
class Container<T> implements IContainer<T>{
// private T[] data=new T[10];//错误,不能参加泛型数组,无法知道数据类型
private Object [] data=null;
private int size=0;//记录容器元素的个数
public Container() {
data=new Object[10];//初始大小为10
}
public Container(int capacity) {
data=new Object[capacity];//
}
@Override
public void add(T obj) {
//判断元素的个数是否超过容器的大小,超过了对容器进行扩容
ensureCapacity(size+1);
data[size++]=obj;//添加元素
}
private void ensureCapacity(int i) {
if(i>data.length) {
int oldi=data.length;
int newi=oldi+(oldi>>1);//扩容为原有容量的1.5倍
data=Arrays.copyOf(data, newi);//将原有数组中的数据拷贝到新创建的数组中
}
}
@Override
public T get(int index) {
return (T)data[index];
}
@Override
public int size() {
return size;
}
}
@SuppressWarnings("unchecked") 去掉黄色警告