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():是否为引用类型;