jdk5.0新特性 反射

时间：2021-04-03 15:14:15

泛型

常用集合： list ， set ，map
语法：List<String>泛型中必须是包装类

byte – Byte
short – Short
int – Integer
long – Long
float – Float
double – Double
char – Character
boolean – Boolean

List

list的三种实现 ArrayList， linkedList， Vector
代码：

public void testList() {
List list = new ArrayList();
list.add(“aaa”);
list.add(“bbb”);
list.add(“ccc”);

遍历list集合(普通for循环 迭代器 增强for)

普通for循环
for(int i=0;i<list.size();i++) {
String s = list.get(i);
System.out.println(s);
}

使用增强for

for (String s1 : list) {
System.out.println(s1);
}

使用迭代器遍历

Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}

Set


  • 特点：唯一 ，无序
  • public void testSet() {
    Set<String> set = new HashSet<String>();
    set.add(“www”);
    set.add(“qqq”);
    set.add(“zzz”);
    set.add(“qqq”);

遍历set 有两种方式 （迭代器 增强for循环）
for (String s2 : set) {
System.out.println(s2);
}

Iterator it1 = set.iterator();
while(it1.hasNext()) {
System.out.println(it1.next());
}
}

Map

  • map结构：key-value形式
    public void testMap() {
Map<String,String> map = new HashMap<String,String>();
        map.put("aaa", "111");
        map.put("bbb", "222");
        map.put("ccc", "333");

遍历map 有两种遍历方式
1,获取所有的key，通过key得到value 使用get方法
Set<String> sets = map.keySet();
for (String key : sets) {
String value = map.get(key);
System.out.println(key+” : “+value);
}
2、获取key和value的关系
Set<Entry<String, String>> sets1 = map.entrySet();
for (Entry<String, String> entry : sets1) {
String keyv = entry.getKey();
String valuev = entry.getValue();
System.out.println(keyv+” : “+valuev);
}
}

泛型使用在方法上

  • public static <T> void swap1(T[] arr ,int a,int b) {
    T temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
    }
  • 泛型使用在类上：
    在一个类上定义一个类型，这个类型可以在类里面直接使用
    public class TestDemo {
    T aa;
    public void test11(T bb) {}
    //写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
    public static <A> void test(A cc) {}
    }

枚举（enum）

  • 枚举的简介：需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。
  • 枚举的API
    name() ：返回枚举的名称
    ordinal() ：枚举的下标，下标从0开始
    valueOf(Class enumType, String name) ：得到枚举的对象
    这两个方法是编译的时候生成两个方法：
    valueof(String name) 转换枚举对象
    values() 获得所有枚举对象数组

知道枚举的对象，得到枚举名称和下标
public void test1() {
//得到枚举对象
Color100 c100 = Color100.RED;
//枚举名称
String name = c100.name();
//枚举的下标
int idx = c100.ordinal();
System.out.println(name+” “+idx);
}

知道枚举的名称，得到枚举的对象和下标

public void test2() {
String name1 = “GREEN”;
//得到对象
Color100 c1 = Color100.valueOf(name1);
//枚举下标
int idx1 = c1.ordinal();
System.out.println(idx1);
}

知道枚举的下标，得到枚举的对象和名称

public void test3() {
int idx2 = 2;
//得到枚举的对象
Color100[] cs = Color100.values();
//根据下标得到对象
Color100 c12 = cs[idx2];
//得到枚举的名称
String name = c12.name();
System.out.println(name);
}

自动拆装箱

  • 装箱
    把基本的数据类型转换成包装类
  • 拆箱
    把包装类转换成基本的数据类型
  • 在JDK5.0中自动拆装箱：
    Integer i = 10;（自动装箱）
    int m = i;（自动拆箱）
  • 在jdk1.4里面如何实现装箱和拆箱
    public void test1() {
    //装箱
    Integer m = new Integer(10);
    //拆箱
    int a = m.intValue();
    }
  • jdk是会向下兼容

增强for循环

  • 语法 for(遍历出来的值 : 要遍历的集合) {}

     for(String s : list) {
        System.out.println(s);
    }
  • 使用场景： 数组；实现Iterable接口的集合 可以使用增强for循环
  • 在集合上使用增强for循环遍历
    list set 实现了Iterator接口，所以可以使用增强for循环
    map不能使用增强for循环，没有实现Iterator接口，所以不能使用增强for循环
  • 增强for循环出现目的：为了替代迭代器
    ** 增强for底层就是迭代器实现的

可变参数

  • 如果实现的多个方法，这些方法里面逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数
  • 可变参数的定义方法 数据类型…数组的名称
    • 代码
public static void add1(int...nums) {
//System.out.println(nums.length);
int sum = 0;
for(int i=0;i<`nums.length`;i++) {
                sum += nums[i];
            }
            System.out.println(sum);
        }
  • 注意的地方
    （1）可变参数需要写在方法的参数列表中，不能单独定义
    （2）在方法的参数列表中只能有一个可变参数
    （3）方法的参数列表中的可变参数，必须放在参数最后
    add1(int a,int…nums)

反射


  • 反射原理：
    • 首先需要把java文件保存到本地硬盘 .java
    • 编译java文件，成.class文件
    • 使用jvm，把class文件通过类加载加载到内存中
    • 当使用反射时候，首先需要获取到Class类，得到了这个类之后，就可以得到class文件里面的所有内容
  • 包含属性 构造方法 普通方法
    • 属性通过一个类 Filed
    • 构造方法通过一个类 Constructor
    • 普通方法通过一个类 Method

得到Class的方法：
Class clazz1 = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName(“cn.itcast.test09.Person”);

利用反射操作无参数的构造方法：

public void test() throws Exception {
Class c3 = Class.forName("cn.home.Person");
//得到Person类的实例
        Person p = (Person) c3.newInstance();
        p.setName("zhangsan");
        System.out.println(p.getName());
    }

使用反射操作有参数的构造方法

public void test() throws Exception {
        Class c1 = Class.forName("cn.home.Person");
        //c1.getConstructors();//获取所有的构造方法
        //传递是有参数的构造方法里面参数类型，类型使用class形式传递
        Constructor cs = c1.getConstructor(String.class,String.class);
        Person p1 = (Person) cs.newInstance("lisi","100");
        System.out.println(p1.getId()+" "+p1.getName());
    }

使用反射操作属性

public void test3() {
try {
            Class c2 = Class.forName("cn.home.Person");
//c2.getDeclaredFields();//表示得到所有的属性
            Person p11 = (Person) c2.newInstance();
//通过这个方法得到属性，参数是属性的名称
            Field f1 = c2.getDeclaredField("name");
//可以操作私有属性m1.setAccessible(true),可以操作私有属性
            f1.setAccessible(true);
//设置name值 set方法，两个参数：第一个参数类的实例，第二个参数是设置的值
            f1.set(p11, "wangwu"); //相当于 在 p.name = "wangwu";
            System.out.println(f1.get(p11)); //相当于 p.name
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

使用泛型操作普通方法：

public void test4() throws Exception {
        Class c4 = Class.forName("cn.home.Person");
        Person p4 = (Person) c4.newInstance();
//c4.getDeclaredMethods();//得到所有的普通方法
//传递两个参数：第一个参数，方法名称；第二个参数，方法里面参数的类型
        Method m1 = c4.getDeclaredMethod("setName", String.class);
//让setName方法执行 ，执行设置值
//使用invoke(p4, "niuqi");传递两个参数：第一个参数，person实例；第二个参数，设置的值
//执行了invoke方法之后，相当于，执行了setName方法，同时通过这个方法设置了一个值是niuqi
        m1.invoke(p4, "niuqi");
        System.out.println(p4.getName());
    }


  • Class类的常用方法

String getName()：获取类名称，包含包名；
String getSimpleName()：获取类名称，不包含包名；
Class getSupperClass()：获取父类的Class，例如：new Integer(100).getClass().getSupperClass()返回的是Class！但new Object().getSupperClass()返回的是null，因为Object没有父类；
T newInstance()：使用本类无参构造器来创建本类对象；
boolean isArray()：是否为数组类型；
boolean isAnnotation()：是否为注解类型；
boolean isAnnotationPresent(Class annotationClass)：当前类是否被annotationClass注解了；
boolean isEnum()：是否为枚举类型；
boolean isInterface()：是否为接口类型；
boolean isPrimitive()：是否为基本类型；
boolean isSynthetic()：是否为引用类型；

标签：

相关文章