zoukankan      html  css  js  c++  java
  • Generic 泛型 <> 钻石表达式

    什么是泛型:
        1 JDK5.0之后推出的新特性:泛型
        2 泛型这种语法机制,只在程序编译阶段起作用,只是给编译器作参考的。(运行阶段泛型没用!)
        3 使用了泛型的好处是什么?
            第一:集合中存储的元素类型统一了。
            第二:从集合中取出的元素类型是泛型指定的类型,不需要进行大量的“向下转型”!
     
     
        4 泛型的缺点是什么?
            导致集合中存储的元素缺乏多样性!
            大多数业务中,集合中的元素类型还是统一的,所以这种泛型特性被大家所认可。
     
     
    案例1:
    package com.javaSe;
    
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    
    /*
    1 JDK5.0之后推出的新特性:泛型
    2 泛型这种语法机制,只在程序编译阶段起作用,只是给编译器作参考的。(运行阶段泛型没用!)
    3 使用了泛型的好处是什么?
        第一:集合中存储的元素类型统一了。
        第二:从集合中取出的元素类型是泛型指定的类型,不需要进行大量的“向下转型”!
    
    
    4 泛型的缺点是什么?
        导致集合中存储的元素缺乏多样性!
        大多数业务中,集合中的元素类型还是统一的,所以这种泛型特性被大家所认可。
    */
    public class GenericTest01 {
        public static void main(String[] args) {
            /*// 不使用泛型机制,分析程序存在的缺点
            List myList = new ArrayList();
            
            // 准备对象
            Cat c = new Cat();
            Bird b = new Bird();
            
            // 将对象添加到集合当中
            myList.add(c);
            myList.add(b);
            
            // 遍历集合,取出Cat让他抓老鼠,取出Bird让它飞。
            Iterator it = myList.iterator();
            while(it.hasNext()){
                
                *//*if (obj instanceof Cat){
                    ((Cat) obj).catchMouse();
                }else if(obj instanceof Bird){
                    ((Bird) obj).fiy();
                }*//*
                
                // 没有这个语法,通过迭代器取出就是Object
                // Animal a = it.next();
                
                // obj中没有move方法,无法调用,需要向下转型!
                Object obj = it.next();
                
                if(obj instanceof Animal){
                    Animal a = (Animal)obj;
                    a.move();
                }
            }*/
            
            // 使用JDK5之后的泛型机制
            // 使用泛型List<Animal>之后,表示List集合中只允许存储Animal类型的数据。
            // 用泛型来指定集合中存储的数据类型
            List<Animal> list = new ArrayList<Animal>();
            
            // 指定List集合中只能存储Animal类型的对象,那么存储String类型就报错了。
            // 这样用了泛型之后,集合中的元素数据类型更加统一了。
            // list.add("abc");
        
            // 准备对象
            Cat c = new Cat();
            Bird b = new Bird();
        
            // 将对象添加到集合当中
            list.add(c);
            list.add(b);
            
            // 获取迭代器
            Iterator<Animal> it = list.iterator();
            while(it.hasNext()){
                
                // 使用泛型之后,每一次迭代返回的数据都是Animal类型。
                /*Animal a = it.next();
                a.move();*/
        
                Animal a = it.next();
                if(a instanceof Cat){
                    ((Cat) a).catchMouse();
                }
                
                if(a instanceof Bird){
                    ((Bird) a).fiy();
                }
            }
            
        }
    }
    
    
    class Animal{
        public void move(){
            System.out.println("动物在移动!");
        }
    }
    
    
    class Cat extends Animal{
        public void catchMouse(){
            System.out.println("猫抓老鼠!");
        }
    }
    
    
    class Bird extends Animal{
        public void fiy(){
            System.out.println("鸟儿在飞翔!");
        }
    }

    案例2:

    package com.javaSe;
    
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    
    /*
    JDK之后引入了:自动类型推断机制。(又称为钻石表达式)
    */
    public class GenericTest02 {
        public static void main(String[] args) {
            // ArrayList<这里的类型会自动推断>(),前提是JDK8之后才允许。
            // 自动类型推断,钻石表达式!
            List<Animal> myList = new ArrayList<>();
            myList.add(new Animal());
            myList.add(new Cat());
            myList.add(new Bird());
            
            // 遍历
            Iterator<Animal> it = myList.iterator();
            while(it.hasNext()){
                Animal animal = it.next();
                animal.move();
            }
            
            List<String> strList = new ArrayList<>();
            // 类型不匹配
            // strList.add(new Cat());
            strList.add("http://www.baidu.com");
            strList.add("http://www.126.com");
            strList.add("http://localhost:8090/reinsure");
            
            // 类型不匹配
            // strList.add(123);
        
            System.out.println(strList.size());
            
            // Iterator的泛型就是String
            Iterator<String> iterator = strList.iterator();
            /*Object obj = iterator.next();
                if(obj instanceof String){
                    String s = ((String) obj).substring(7);
                    System.out.println(s);
                }*/
            while (iterator.hasNext()){
                
                // 如果没有使用泛型
                
                
                // 通过迭代器获取了String类型的数据
                String s = iterator.next();
                // 直接调用String类的subString()方法截取字符串。
                s = s.substring(7);
                System.out.println(s);
            }
        }
    }

    案例3:

    package com.javaSe;
    /*
    自定义泛型可以吗?可以
        自定义泛型的时候,<>尖括号中的是一个标识符,随便写。
        java源代码中经常出现的是:
            <E>和<T>
        E是element单词首字母。
        T是type单子首字母。
        
    */
    public class GenericTest03<aaaaaa> {
        public void doSome(aaaaaa o) {
            System.out.println(o);
        }
        
        public static void main(String[] args) {
            // new对象的时候指定了泛型是:String类型
            GenericTest03<String> gt = new GenericTest03<>();
            
            // 类型不匹配
            // gt.doSome(123)
            
            gt.doSome("abcdef");
            
            // ------------------------------------------------------
            
            GenericTest03<Integer> gt2 = new GenericTest03<>();
            gt2.doSome(123);
            
            // 类型不匹配
            // gt2.doSome("123");
            
            MyIterator<String> mit = new MyIterator();
            String s1 = mit.get();
            System.out.println(s1);
        
            MyIterator<Animal> mit2 = new MyIterator();
            Animal a = mit2.get();
            System.out.println(a);
            
            // 不用泛型就是Object类型
            // GenericTest03 gt3 = new GenericTest03();
            // gt3.doSome(new Object());
        }
    }
    
    
    class MyIterator<T>{
        public T get(){
            return null;
        }
    }
  • 相关阅读:
    网页加速的14条优化法则 网站开发与优化
    .NET在后置代码中输入JS提示语句(背景不会变白)
    C语言变量声明内存分配
    SQL Server Hosting Toolkit
    An established connection was aborted by the software in your host machine
    C语言程序设计 2009春季考试时间和地点
    C语言程序设计 函数递归调用示例
    让.Net 程序脱离.net framework框架运行
    C语言程序设计 答疑安排(2009春季 110周) 有变动
    软件测试技术,软件项目管理 实验时间安排 2009春季
  • 原文地址:https://www.cnblogs.com/xlwu/p/13415713.html
Copyright © 2011-2022 走看看