java的泛型

/*
Collection<E> extends Iterable<E>,所有单鞋集合恶斗可以使用增强for

public interface Iterable<T>
实现此接口允许对象成为“for-each loop”语句的目标。

    增强for循环，用来遍历结合和数组
    格式：
        for(集合/数组的数据类型 变量名：集合名/数组名){
            sout(变量名)
        }
 */

 /*
    使用泛型
        避免类型转换的满分,存储时什么类型,出去就是什么类型
        运行期间异常,提到编译期的异常
     */

////创建集合对象，不用泛型
//    集合不使用泛型，默认的类型是object类型，可以存储任意类型的数据
//    不安全，会引发异常

public class DemoFor {
    public static void main(String[] args) {
        show1();
        show2();
    }

    /*
    使用泛型
        避免类型转换的满分,存储时什么类型,出去就是什么类型
        运行期间异常,提到编译期的异常
     */
    private static void show2(){
        ArrayList<String> list = new ArrayList<>();
        list.add("BBB");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
//            int i= it.next().length();不能进行流式编程
            System.out.println(s);
            System.out.println(s.length());
        }
    }



////创建集合对象，不用泛型
//    集合不使用泛型，默认的类型是object类型，可以存储任意类型的数据
//    不安全，会引发异常
    private static  void show1(){
        ArrayList list = new ArrayList();
        list.add("DDDD");
        list.add(1);

//        迭代器遍历
        Iterator it =list.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
//            想要使用String类特有的方法，length获取字符串的长度，
//              现在不能使用,因为多态  object obj = "obj" 不能使用子类特有的方法
//            需要向下转型 String s = (String)obj;
////            会抛出异常ClassCastException,不能把Integer类型转换为String类型
//            String s = (String)obj;
//            System.out.println(s.length());
        }


    }
}
/*
DDDD
1
BBB
3

 */

/*
定义含有泛型的类,模拟ArrayList
泛型是一个位置的数据类型,当我们不确定什么数据类型的时候,可以使用泛型
泛型可以接受任意数据类型,可以使用String ,Integer
创建对象的时候确定泛型的数据类型
 */
public class Gennerice<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

public class GenericeDo {
    public static void main(String[] args) {
//       不写泛型,默认是objcet
        Gennerice gc = new Gennerice();
        gc.setName("dddd");
        Object obj = gc.getName();

//        创建对象,使用泛型Intager
        Gennerice<Integer> gc2 = new Gennerice<>();
        gc2.setName(999);
        Integer name = gc2.getName();
        System.out.println(name);

//        使用字符串类型
        Gennerice<String> gc3 = new Gennerice<>();
        gc3.setName("RRRR");
        String name2 = gc3.getName();
        System.out.println(name2);
    }
}

/*
定义含有泛型的方法,泛型定义在修饰符和返回值之间
格式:
    修饰符 <泛型> 返回值类型 方法名 (参数列表(使用泛型)){
        方法体
    }
    含有泛型的方法,在调用方法的时候确定泛型的数据类型,传递什么类型的参数,泛型就是什么类型

 */

public class GenericMethod {

    public <M> void  methon(M m){
        System.out.println(m);
    }

//    含有泛型的静态方法:
    public static <S> void methon2(S s){
        System.out.println(s);
    }
}

public class GmTest {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
//        调用泛型方法,传递什么类型就是什么类G型
        gm.methon(10);
        gm.methon("ddd");

        gm.methon2("静态方法的调用,不建议创建对象使用");

//        静态方法,通过类名.方法名 直接调用
        GenericMethod.methon2(999);
        GenericMethod.methon2("quan");
    }
}

/*
10
ddd
静态方法的调用,不建议创建对象使用
999
quan
 */

public interface GenerInterface<I> {
//    抽象函数
    public abstract void method(I i);

}

/*
含有泛型的接口:第一种:定义接口的实现,指定接口的泛型
 */
public class GenInterTest implements GenerInterface<String> {
    @Override
    public void method(String s){
        System.out.println(s);
    }

}

/*
第二种使用方式,
    接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
    相当于定义了一个含有泛型的类,实现对象的时候觉得泛型的数据类型
 */
public class GenInterTest2<I> implements GenerInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }

}

public class GenInterTestALl {
    public static void main(String[] args) {
        GenInterTest git = new GenInterTest();
        git.method("done");

//
        GenInterTest2<Integer> git2 = new GenInterTest2<>();
        git2.method(111);

        GenInterTest2<String> git3 = new GenInterTest2<>();
        git3.method("WUQN");
    }
}
/*
done
111
WUQN
 */