从零开始看java泛型

泛型是一种未知的数据类型,当无法确定使用什么数据类型的时候,可以使用泛型,泛型也是一个变量,用来接收数据类型。

 T t: Type  类型

 E e:Element 元素

ArrayList<String> coll = new ArrayList<>();  //创建集合对象的时候会确定泛型数据类型 为string
使用泛型可以直接使用数据类型的方法,无序转换,存储的是什么类型,取出的就是什么类型
private static void show02() {   //使用泛型
    ArrayList<String> list = new ArrayList<>();
    list.add("qwer");
   //使用迭代器遍历list集合
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        String s = it.next();
        System.out.println(s+"->"+s.length());
    }
}
private static void show01() {  //不使用泛型
    ArrayList list = new ArrayList();
    list.add("qwer");
    list.add(1);
    //使用迭代器遍历list集合
    //获取迭代器
    Iterator it = list.iterator();
    //使用迭代器中的方法hasNext和next遍历集合
    while(it.hasNext()){
        //取出元素也是Object类型
        Object obj = it.next();
        System.out.println(obj);
        //想要使用String类特有的方法,length获取字符串的长度;不能使用  多态 Object obj = "abc"   
        //抛出ClassCastException类型转换异常,不能把Integer类型转换为String类型 需要向下转型
        String s = (String)obj;
        System.out.println(s.length());
    }
}

运行结果

 

泛型类

    因为泛型是一个未知的数据类型,所以当不确定使用数据类型的种类时,可以使用泛型,它可以接受任意数据类型,Integer,String,Student,Teacher...

 

     含有泛型的类

public class GenericClass<E> {
    private E name;
    public E getName() {
        return name;
    }
    public void setName(E name) {
        this.name = name;
    }
}

 

测试类:

 public static void main(String[] args) {
        //使用泛型GenericClass对象,泛型使用Integer类型  
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(222);
        Integer name = gc2.getName();
        System.out.println(name);

        //创建GenericClass对象,泛型使用String类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("明世隐");
        String name1 = gc3.getName();
        System.out.println(name1);
    }
}

输入结果: 

 

    泛型方法:

  格式:
    修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
        方法体;
    } 
含有泛型的方法,在调用方法的时候确定泛型的数据类型
传递什么类型的参数,泛型就是什么类型
public class GenericMethod {
    //定义一个含有泛型的方法
    public <Z> void method01(Z z){
        System.out.println(z);
    }
}

测试含有泛型的方法:

 public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        /*
            调用含有泛型的方法method01
            传递什么类型,泛型就是什么类型
         */
        gm.method01(10);  //传递数字
        gm.method01("abc"); //字符
        gm.method01(8.8);  //doble
        gm.method01(true);  //boolean
    }
}

输出:

测试含有泛型的静态方法
public class GenericMethod {
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

测试类:

  public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        gm.method02("静态方法,创建对象时不建议使用"); 
        //静态方法,通过类名.方法名(参数)可以直接使用
    }   
}

输出结果:

  泛型接口

定义格式:

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

如:

public interface GenericInterface<E>{
    public abstract void add(E e);
    public abstract E getE();
}

定义泛型接口:

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

实现类一:

实现泛型接口,指定接口的泛型类型

Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认

public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

实现类二:

接口使用什么泛型,实现类就使用什么泛型
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

测试类:

public class DemoGenericInterface {
    public static void main( String[] args ) {
        GenericInterfaceImpl1 g1 = new GenericInterfaceImpl1();
        g1.method("String字符");
        GenericInterfaceImpl2<Integer> g2 = new GenericInterfaceImpl2<>(); //整数泛型
        g2.method(121);
        GenericInterfaceImpl2<Double> g3 = new GenericInterfaceImpl2<>(); //复数泛型
        g3.method(1210.1);
    }
}

输出结果:

 

 

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读