【150天】尚学堂高淇Java300集视频精华笔记（115-116）

第115集：遍历Map的两种方式

1. 第一种方法是直接从Map里面将键取出组成set

2. 第二种方法是直接从Map里面将键值对取出组成set

package test115;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test115 {
    public static void main(String[] args){
        Map map = new HashMap();
        map.put("aaa", "bbb");
        map.put("ccc", "ddd");
        
        //遍历Map的第一种方式
        Set keys = map.keySet(); //把map里的键放进Set容器
        for(Iterator iter = keys.iterator();iter.hasNext();){
            String a = (String)iter.next();
            System.out.println(map.get(a));
        }
        
        //遍历Map的第二种方式 
        
        Set<Entry> entry = map.entrySet();//把map里的键值对放进Set容器
        for(Iterator iter = entry.iterator();iter.hasNext();){
            Entry a = (Entry)iter.next();
            System.out.println(a.getKey()+"---"+a.getValue());
        }
                
    }
    
}

第116集：自定义泛型泛型类泛型接口泛型方法安全省心

不使用泛型导致的难题

1. 我们经常需要将一个类的属性里设置为不同类型的值，若不使用泛型，就需要将属性设置为Object类，这样导致的后果是：

   1. 装入数据的类型都被当作Object对待，从而“丢失”自己的实际类型。

   2. 获取数据时往往需要转型，效率低，容易出错。

2. 不使用泛型的话，我们需要：

   1. 强制类型转换

   2. 手动类型检查

package test116;
/**
 * @param args
 * 使用泛型的好处：
 * 1. 不用再进行强制类型转换
 * 2. 不用再手动进行类型检查（不检查转换可能报错）；
 * 
 */
public class APP {
    
    public static void main(String[] args){
        //强制类型转换
        Student stu = new Student(80,90);//丢失了装入数据的类型，int变成了Object。
        int a = (Integer)stu.getJavase();//Object——>integer——>int 这里还要进行强制类型转换，麻烦
        System.out.println(a);
        
        //手动类型检查
        String b = null;
        if(stu.getJavase() instanceof String ){//这里还要进行类型检查
            b = (String)stu.getJavase();
        }
        System.out.println(b);
    }
}

package test116;

public class Student {
    private Object javase;
    private Object oracle;
    
    public void setJavase(Object javase){
        this.javase = javase;
    }
    
    public Object getJavase(){
        return javase;
    }
    
    public void setOracle(Object oracle){
        this.oracle = oracle;
    }
    
    public Object getOracle(){
        return oracle;
    }
    
    public Student(Object javase,Object oracle){
        this.javase = javase;
        this.oracle = oracle;
    }
}

使用泛型后的好处

1. 安全：在编译的时候检查类型安全。

2. 省心：所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型的使用方法

注意事项

1. 泛型只能使用引用类型，不能使用基本类型

2. 泛型声明时字母不能使用在静态属性和静态方法上【因为泛型的类型是在使用时确定，而静态属性与方法是在编译时就确定的】

3. 泛型方法只能访问对象的信息，不能修改信息。

       package com.fangxing;
   
   /**
    * @author wangtao
    *
    * @param <L>
    * 
    * 泛型只能访问对象的信息，不能修改信息
    * 
    */
   public class TestMethod<L> {
       
       //private static L name;//不能在声明时使用泛型字母,注意其与泛型方法的区别
       
       public static <T> void test(T a){ 
           //a没法用set设置
           System.out.println(a);
       }
       
       public static void main(String[] args){
           test("aaa");
       }
   }
   

4. 接口中，泛型只能用在方法中，不可用在全局常量中。

   package com.fangxing;
   
   public interface Test02<T> {
       //T int size; //接口中泛型字母只能用在方法中，不能用在全局常量里。
       public void add(T a);
       public <T> void set(T a);
   }