zoukankan      html  css  js  c++  java
  • 泛型

    泛型
    3.1  泛型概述

    在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。

    3.2 使用泛型的好处

    package com.itheima.demo03.Generic;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class Demo01Generic {
        public static void main(String[] args) {
            show02();
        }
    
        /*
            创建集合对象,使用泛型
            好处:
                1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
                2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
             弊端:
                泛型是什么类型,只能存储什么类型的数据
         */
        private static void show02() {
            ArrayList<String> list = new ArrayList<>();
            list.add("abc");
            //list.add(1);//add(java.lang.String)in ArrayList cannot be applied to (int)
    
            //使用迭代器遍历list集合
            Iterator<String> it = list.iterator();
            while(it.hasNext()){
                String s = it.next();
                System.out.println(s+"->"+s.length());
            }
        }
    
        /*
            创建集合对象,不使用泛型
            好处:
                集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
            弊端:
                不安全,会引发异常
         */
        private static void show01() {
            ArrayList list = new ArrayList();
            list.add("abc");
            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());
            }
        }
    }
    

     3.1  泛型概述
    ## 3.3  泛型的定义与使用

    我们在集合中会大量使用到泛型,这里来完整地学习泛型知识。
    泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递

    定义格式:

    修饰符 class 类名<代表泛型的变量> {  }
    

     例如,API中的ArrayList集合:

    class ArrayList<E>{ 
        public boolean add(E e){ }
    
        public E get(int index){ }
       	....
    }
    

     使用泛型: 即什么时候确定泛型。

    在创建对象的时候确定泛型

    例如,ArrayList<String> list = new ArrayList<String>();

    此时,变量E的值就是String类型,那么我们的类型就可以理解为:

    class ArrayList<String>{ 
         public boolean add(String e){ }
    
         public String get(int index){  }
         ...
    }
    

    再例如,ArrayList<Integer> list = new ArrayList<Integer>();

    此时,变量E的值就是Integer类型,那么我们的类型就可以理解为

    class ArrayList<Integer> { 
         public boolean add(Integer e) { }
    
         public Integer get(int index) {  }
         ...
    }
    

     举例自定义泛型类

    public class MyGenericClass<MVP> {
    	//没有MVP类型,在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    	private MVP mvp;
         
        public void setMVP(MVP mvp) {
            this.mvp = mvp;
        }
         
        public MVP getMVP() {
            return mvp;
        }
    }
    

     使用:

    public class GenericClassDemo {
      	public static void main(String[] args) {		 
             // 创建一个泛型为String的类
             MyGenericClass<String> my = new MyGenericClass<String>();    	
             // 调用setMVP
             my.setMVP("大胡子登登");
             // 调用getMVP
             String mvp = my.getMVP();
             System.out.println(mvp);
             //创建一个泛型为Integer的类
             MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
             my2.setMVP(123);   	  
             Integer mvp2 = my2.getMVP();
        }
    }
    

     栗子:

    package com.itheima.demo03.Generic;
    
    public class Demo02GenericClass {
        public static void main(String[] args) {
            //不写泛型默认为Object类型
            GenericClass gc = new GenericClass();
            gc.setName("只能是字符串");
            Object obj = gc.getName();
    
            //创建GenericClass对象,泛型使用Integer类型
            GenericClass<Integer> gc2 = new GenericClass<>();
            gc2.setName(1);
    
            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);
        }
    }
    
    package com.itheima.demo03.Generic;
    /*
        定义一个含有泛型的类,模拟ArrayList集合
        泛型是一个未知的数据类型,当我们不确定什么什么数据类型的时候,可以使用泛型
        泛型可以接收任意的数据类型,可以使用Integer,String,Student...
        创建对象的时候确定泛型的数据类型
     */
    public class GenericClass<E> {
        private E name;
    
        public E getName() {
            return name;
        }
    
        public void setName(E name) {
            this.name = name;
        }
    }
    

     B 含有泛型的方法

    定义格式

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

    for example:

    package com.itheima.demo03.Generic;
    /*
        定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
    
        格式:
            修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
                方法体;
            }
    
        含有泛型的方法,在调用方法的时候确定泛型的数据类型
        传递什么类型的参数,泛型就是什么类型
     */
    public class GenericMethod {
        //定义一个含有泛型的方法
        public <M> void method01(M m){
            System.out.println(m);
        }
    
        //定义一个含有泛型的静态方法
        public static <S> void method02(S s){
            System.out.println(s);
        }
    }
    

     使用格式:调用方法时,确定泛型的类型

    package com.itheima.demo03.Generic;
    /*
        测试含有泛型的方法
     */
    public class Demo03GenericMethod {
        public static void main(String[] args) {
            //创建GenericMethod对象
            GenericMethod gm = new GenericMethod();
    
            /*
                调用含有泛型的方法method01
                传递什么类型,泛型就是什么类型
             */
            gm.method01(10);
            gm.method01("abc");
            gm.method01(8.8);
            gm.method01(true);
    
            gm.method02("静态方法,不建议创建对象使用");
    
            //静态方法,通过类名.方法名(参数)可以直接使用
            GenericMethod.method02("静态方法");
            GenericMethod.method02(1);
        }
    }
    

     C.含有泛型的接口

    package com.itheima.demo03.Generic;
    /*
        定义含有泛型的接口
     */
    public interface GenericInterface<I> {
        public abstract void method(I i);
    }
    
    package com.itheima.demo03.Generic;
    /*
        含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
        public interface Iterator<E> {
            E next();
        }
        Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
        public final class Scanner implements Iterator<String>{
            public String next() {}
        }
     */
    public class GenericInterfaceImpl1 implements GenericInterface<String>{
        @Override
        public void method(String s) {
            System.out.println(s);
        }
    }
    
    package com.itheima.demo03.Generic;
    
    /*
        含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
        就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
        public interface List<E>{
            boolean add(E e);
            E get(int index);
        }
        public class ArrayList<E> implements List<E>{
            public boolean add(E e) {}
            public E get(int index) {}
        }
     */
    public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
        @Override
        public void method(I i) {
            System.out.println(i);
        }
    }
    

     确定泛型

    package com.itheima.demo03.Generic;
    /*
        测试含有泛型的接口
     */
    public class Demo04GenericInterface {
        public static void main(String[] args) {
            //创建GenericInterfaceImpl1对象
            GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
            gi1.method("字符串");
    
            //创建GenericInterfaceImpl2对象
            GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
            gi2.method(10);
    
            GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
            gi3.method(8.8);
        }
    }
    

     3.4. 泛型通配符

    当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

    通配符基本使用

    泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

    此时只能接受数据,不能往该集合中存储数据。

    package com.itheima.demo03.Generic;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /*
        泛型的通配符:
            ?:代表任意的数据类型
        使用方式:
            不能创建对象使用
            只能作为方法的参数使用
     */
    public class Demo05Generic {
        public static void main(String[] args) {
            ArrayList<Integer> list01 = new ArrayList<>();
            list01.add(1);
            list01.add(2);
    
            ArrayList<String> list02 = new ArrayList<>();
            list02.add("a");
            list02.add("b");
    
            printArray(list01);
            printArray(list02);
    
            //ArrayList<?> list03 = new ArrayList<?>();
        }
    
        /*
            定义一个方法,能遍历所有类型的ArrayList集合
            这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型
            注意:
                泛型没有继承概念的
         */
        public static void printArray(ArrayList<?> list){
            //使用迭代器遍历集合
            Iterator<?> it = list.iterator();
            while(it.hasNext()){
                //it.next()方法,取出的元素是Object,可以接收任意的数据类型
                Object o = it.next();
                System.out.println(o);
            }
        }
    }
    

    通配符高级使用----受限泛型

    之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限下限

    泛型的上限

    • 格式类型名称 <? extends 类 > 对象名称

    • 意义只能接收该类型及其子类

    泛型的下限

    • 格式类型名称 <? super 类 > 对象名称

    • 意义只能接收该类型及其父类型

    package com.itheima.demo03.Generic;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /*
        泛型的上限限定: ? extends E  代表使用的泛型只能是E类型的子类/本身
        泛型的下限限定: ? super E    代表使用的泛型只能是E类型的父类/本身
     */
    public class Demo06Generic {
        public static void main(String[] args) {
            Collection<Integer> list1 = new ArrayList<Integer>();
            Collection<String> list2 = new ArrayList<String>();
            Collection<Number> list3 = new ArrayList<Number>();
            Collection<Object> list4 = new ArrayList<Object>();
    
            getElement1(list1);
            //getElement1(list2);//报错
            getElement1(list3);
            //getElement1(list4);//报错
    
            //getElement2(list1);//报错
            //getElement2(list2);//报错
            getElement2(list3);
            getElement2(list4);
    
            /*
                类与类之间的继承关系
                Integer extends Number extends Object
                String extends Object
             */
    
        }
        // 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
        public static void getElement1(Collection<? extends Number> coll){}
        // 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
        public static void getElement2(Collection<? super Number> coll){}
    }
    

    Test

    package com.itheima.demo04.Test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    
    /*
        斗地主综合案例:
            1.准备牌
            2.洗牌
            3.发牌
            4.看牌
     */
    public class DouDiZhu {
        public static void main(String[] args) {
            //1.准备牌
            //定义一个存储54张牌的ArrayList集合,泛型使用String
            ArrayList<String> poker = new ArrayList<>();
            //定义两个数组,一个数组存储牌的花色,一个数组存储牌的序号
            String[] colors = {"♠","♥","♣","♦"};
            String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            //先把大王和小王存储到poker集合中
            poker.add("大王");
            poker.add("小王");
            //循环嵌套遍历两个数组,组装52张牌
            for(String number : numbers){
                for (String color : colors) {
                    //System.out.println(color+number);
                    //把组装好的牌存储到poker集合中
                    poker.add(color+number);
                }
            }
            //System.out.println(poker);
    
            /*
                2.洗牌
                使用集合的工具类Collections中的方法
                static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
             */
            Collections.shuffle(poker);
            //System.out.println(poker);
    
            /*
                3.发牌
             */
            //定义4个集合,存储玩家的牌和底牌
            ArrayList<String> player01 = new ArrayList<>();
            ArrayList<String> player02 = new ArrayList<>();
            ArrayList<String> player03 = new ArrayList<>();
            ArrayList<String> diPai = new ArrayList<>();
    
            /*
                遍历poker集合,获取每一张牌
                使用poker集合的索引%3给3个玩家轮流发牌
                剩余3张牌给底牌
                注意:
                    先判断底牌(i>=51),否则牌就发没了
             */
            for (int i = 0; i < poker.size() ; i++) {
                //获取每一张牌
                String p = poker.get(i);
                //轮流发牌
                if(i>=51){
                    //给底牌发牌
                    diPai.add(p);
                }else if(i%3==0){
                    //给玩家1发牌
                    player01.add(p);
                }else if(i%3==1){
                    //给玩家2发牌
                    player02.add(p);
                }else if(i%3==2){
                    //给玩家3发牌
                    player03.add(p);
                }
            }
    
            //4.看牌
            System.out.println("刘德华:"+player01);
            System.out.println("周润发:"+player02);
            System.out.println("周星驰:"+player03);
            System.out.println("底牌:"+diPai);
        }
    }
    
  • 相关阅读:
    Android Loader异步装载
    Android 清除本地缓存
    Android 小知识
    Android 百度地图用法
    ANDROID笔记:四大组件之广播
    Android扩展:一个自动findViewById的小工具
    ANDROID笔记:基于handle的异步请求网络数据的一种方法
    ANDROID笔记:多线程断点下载
    ANDROID笔记:AIDL介绍
    ANDROID笔记:activity通过ContentProvider传值(仿调用系统图片浏览器过程)
  • 原文地址:https://www.cnblogs.com/crushgirl/p/13528957.html
Copyright © 2011-2022 走看看