java基础 之 泛型

泛型

public class 泛型 <E>{
    private E name;
    private E age;
    public 泛型(E name, E age) {
        this.name = name;
        this.age = age;
    }
    public 泛型() {
    }
    public E getName() {
        return name;
    }
    public void setName(E name) {
        this.name = name;
    }
    public E getAge() {
        return age;
    }
    public void setAge(E age) {
        this.age = age;
    }
}

public static void main(String[] args) {
        //不写泛型默认为Object类型
        泛型<Integer> fx=new 泛型<>();
        fx.setName(1);
        Integer s=fx.getName();
        System.out.println(s);
    }

• 使用泛型： 即什么时候确定泛型。是在创建对象的时候确定泛型。

定义和使用含有泛型的方法

• 格式：

修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
		方法体...
}

• 含有泛型的方法，在调用方法的时候确定泛型的数据类型。
• 传递什么类型的参数，泛型就是什么类型。

public class GenericMethod {
    public <E> void Method(E m){
        System.out.println(m);
    }
}

测试类

class GenericMethodTest {
    public static void main(String[] args) {
        //创建一个GenericMethod的对象
        GenericMethod gm=new GenericMethod();
        //调用含有泛型的方法，传入什么类型，泛型就是什么类型。
        gm.Method(2);
    }
}

运行结果：

2

静态方法：

public class GenericMethod {
    //静态方法
    public static <E> void Method(E m,E n){
        System.out.println(m);
        System.out.println(n);
    }
}

class GenericMethodTest {
    public static void main(String[] args) {
        //静态方法直接用类名
        GenericMethod.Method(1,"fff");
    }
}

• 注意：静态方法不需要实例化对象，只需要用类名去调用该静态方法即可。

定义和使用含有泛型的接口

使用方式：

第一种：定义接口的实现类，实现接口，指定接口的泛型。

• 定义含有泛型的接口

public interface GenericInterface<m> {
    public abstract void method(m i);
}

• 使用含有泛型的接口:实现测试类

public class GenericMethod implements GenericInterface<String>{
    @Override
    public void method(String i) {//重写了method()方法
        System.out.println(i);
    }
    public static void main(String[] args) {
        GenericMethod gm=new GenericMethod();
        gm.method("1");
    }
}

第二种：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走，就相当于定义一个含有泛型的类，创建对象的时候确定泛型的类型。

public class GenericMethod<i> implements GenericInterface<i>{
    public static void main(String[] args) {
    	//创建对象的时候确定泛型
        GenericMethod<String> gm=new GenericMethod<>();
        gm.method("1");
    }
    @Override
    public void method(i i) {
        System.out.println(i);
    }
}

泛型通配符

• 不知道什么类型来接收的时候可以使用？。
• 此时只能接收数据，而不能往该集合存储数据。
• 泛型的通配符：？
• 使用方式：不能创建对象使用，只能作为方法的参数使用。

public class GenericDemo {
    public static void main(String[] args) {
        Collection<Integer> list1=new ArrayList<>();
        Collection<String> list2=new ArrayList<>();

        list1.add(1);
        list1.add(2);
        list2.add("fjc");
        list2.add("ltf");

    }
    //只能用作方法的传递参数
    public void printArray(ArrayList<?> list){
    	//迭代器
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }
}