java se回顾——泛型

雨点打透心脏的1/2处 2022-11-06 05:57 127阅读 0赞

## 一，什么是泛型？ ##

*  是一种未知的数据类型当我们不知道使用什么数据类型的时候可以使用泛型
 *  泛型也可以看出是一个变量用来接收数据类型

## 二，使用泛型和不使用泛型的对比： ##

class test{
        public static void main(String[] args) {
            /**
             * 使用泛型：Collection<String>
             * 优点：避免了类型的转化，存什么类型数据就取什么类型的数据
             *       把运行期的异常提升到编译期
             * 缺点：泛型是什么类型就只能存什么类型
             */
            Collection<String> collection=new ArrayList<>();//使用泛型
            collection.add("A12");
            collection.add("B1");
            collection.add("C21121");
            for (String info:collection){//遍历的目标只能是集合或数组
                System.out.println(info+"的长度: "+info.length());
            }
    
            /**
             * 没有使用泛型：Collection
             * 优点：集合不使用泛型，默认是Object类型，可以存储任意的对象
             * 缺点：不安全，会发生异常
             */
            Collection collection1=new ArrayList();
            collection1.add("d");
            collection1.add("e");//返回值为true,说明添加成功
            collection1.add("f");
            collection1.add(123);
            Iterator iterator=collection1.iterator();
            while (iterator.hasNext()){
                String obj=(String)iterator.next();//回报类型转化错误，因为int不能强转成String类型。
                System.out.println(obj+"的长度: "+obj.length());
            }
    
    
        }
    }

## 三，编写一个泛型类测试：（泛型类，泛型方法，泛型接口，泛型通配符？泛型的上下界） ##

class test{
        public static void main(String[] args) {
            /**
             * 泛型类的使用
             */
            People<String> people1=new People<>();//创建对象时，传入的String相当于实参
            people1.setName("建江");
            System.out.println(people1.getName());
    
            People<Integer> people2=new People<>();//创建对象时，传入的Integer相当于实参
            people2.setName(123);
            System.out.println(people2.getName());
            /**
             * 泛型方法的使用
             */
            people1.show(123);
            people1.show("abc");
            people1.show(20.1);
            people1.show(true);
            /**
             * 泛型接口的使用
             */
            IPeople<String> people=new People<>();
            people.showTo("asd");
            /**
             * 泛型通配符：？
             * 可以代指任意类型
             * 例如下面的方法可以接受两种不同类型的ArrayList
             * 它只能作为方法中的参数传递
             */
            ArrayList<Integer> arrayList1=new ArrayList<>();
            arrayList1.add(111);
            arrayList1.add(222);
            arrayList1.add(333);
            ArrayList<String > arrayList2=new ArrayList<>();
            arrayList2.add("aaa");
            arrayList2.add("bbb");
            arrayList2.add("ccc");
            showAllTypeTElement(arrayList1);
            showAllTypeTElement(arrayList2);
            /**
             * 泛型的上限限定：？ extend E  :泛型只能是E类型的子类或本身
             * 泛型的下限限定：？ super E  :泛型只能是E类型的父类或本身
             *
             */
            show1(arrayList1);
            //show1(arrayList2);//报错因为String类型不继承Number
            ArrayList<Number> arrayList3=new ArrayList<>();
            ArrayList<Object> arrayList4=new ArrayList<>();
            show2(arrayList3);
            show2(arrayList4);
    
    
    
        }
        public static void showAllTypeTElement(ArrayList<?> list){
            Iterator iterator=list.iterator();
            while (iterator.hasNext())
                System.out.println(iterator.next());
        }
    
        public static void show2(ArrayList<? super Number> list){
            Iterator iterator=list.iterator();
            while (iterator.hasNext())
                System.out.println(iterator.next());
        }
        public static void show1(ArrayList<? extends Number> list){
            Iterator iterator=list.iterator();
            while (iterator.hasNext())
                System.out.println(iterator.next());
        }
    }
    
    class People<E> implements IPeople<E>{//泛型类，E类似于形参
        private E name;
    
        public E getName() {
            return name;
        }
    
        public void setName(E name) {
            this.name = name;
        }
    
        public <A> void show(A a){//泛型方法A是传入的类型
            System.out.println(a);
        }
    
        @Override
        public void showTo(E e) {
            System.out.println("泛型接口传入参数打印："+e);
        }
    }
    
    interface IPeople<E>{//泛型接口
        void showTo(E e);
    }

## 四，斗地主案例： ##

//斗地主案例
    class test{
        public static void main(String[] args) {
            /**
             * 1，准备牌
             * 2，洗牌
             * 3，发牌
             * 4，看牌
             */
            //准备牌
            ArrayList<String> pokerList=new ArrayList<>();//存储牌的集合
            String colors[]={"♠","♥","♣","■"};
            String numbers[]={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            pokerList.add("大王");
            pokerList.add("小王");
            for (String color:colors){
                for (String number:numbers){
                    pokerList.add(color+number);//组装牌存入集合中
                }
            }
            Collections.shuffle(pokerList);//洗牌
    
            ArrayList<String> play1=new ArrayList<>();
            ArrayList<String> play2=new ArrayList<>();
            ArrayList<String> play3=new ArrayList<>();
            ArrayList<String> diPai=new ArrayList<>();//底牌
    
            for(int i=0;i<pokerList.size();i++){
                //获得每一张牌
                String p=pokerList.get(i);
                //给玩家发牌：
                if(i>=51){
                    //留下三张作为底牌
                    diPai.add(p);
                }
                else if(i%3==0){
                    play1.add(p);//玩家1得到牌
                }else if(i%3==1){
                    play2.add(p);//玩家2得到牌
                }else if(i%3==2){
                    play3.add(p);//玩家3得到牌
                }
            }
            //看牌 ：
            System.out.println("建江1："+play1);
            System.out.println("建江2："+play2);
            System.out.println("建江3："+play3);
            System.out.println("底牌："+diPai);
    
    
    
    
        }
    }

# #