zoukankan      html  css  js  c++  java
  • 泛型擦除 反射 自动装配

    1.泛型擦除

    package cn.itcast.demo;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo1 {
    
        public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
            // 定义一个List<Integer>
            List<Integer> list = new ArrayList<Integer>();
    
            // 添加一个字符串 "abc"
            // list.add("abc");
    
            // 解决问题,使用反射
            // 1.得到List的Class。
            Class clazz = list.getClass();
            
            //2.通过clazz去获取add方法.
            Method addMethod=clazz.getMethod("add", Object.class);
            
            //3.调用add方法,将"abc"添加.
            
            addMethod.invoke(list, "abc");
            
            System.out.println(list);
        }
    }

    2.四种获取对象的方式.
    1.new
    2.反射
    3.IO流(Object流) ----注意需要实现Serializable
    4.clone() ---需要在类中重写clone()方法实现Cloneable接口.

    package cn.itcast.demo;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    import org.junit.Test;
    
    //获取对象
    public class Demo2 {
    
        // 1.new
        @Test
        public void fun1() {
            Person p = new Person();
        }
    
        // 使用反射
        @Test
        public void fun2() throws ClassNotFoundException, InstantiationException,
                IllegalAccessException {
            Class c = Class.forName("cn.itcast.demo.Person");
            c.newInstance();
        }
    
        // 3.使用IO流.
        @Test
        public void fun3() throws FileNotFoundException, IOException {
            // 将一个对象写入到object.txt文件中.
            Person p = new Person();
            p.setName("tom");
            p.setSex("male");
            p.setAddress("北京");
    
            // 在java中如果描述路径要使用 两个\,也可以使用一个/。
    
            File file = new File("D:/java0106/workspace/day02/src/object.txt");
            // // 绝对路径
            // 相对路径
            // File file=new File("src/object.txt");
    
            // 在开发中获取classpath路径。 获取我们的classpath路径的根目录. 那么如果文件存在于bin中,就可以直接在后面写路径
            // String path = Demo2.class.getResource("/object.txt").getPath();
    
            // File file=new File(path);
    
            // System.out.println(file.exists());
    
            writeObjectToFile(p, file);
    
        }
    
        @Test
        public void fun4() throws FileNotFoundException, IOException,
                ClassNotFoundException {
            File file = new File("D:/java0106/workspace/day02/src/object.txt");
            Person p = (Person) readObjectFromFile(file);
    
            System.out.println(p);
        }
    
        // 从文件中读取对象
        private Object readObjectFromFile(File file) throws FileNotFoundException,
                IOException, ClassNotFoundException {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
            Object obj = ois.readObject();
            ois.close();
            return obj;
        }
    
        // 将对象写入到文件中的操作
        private void writeObjectToFile(Object obj, File file)
                throws FileNotFoundException, IOException {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
                    file));
    
            oos.writeObject(obj);
            oos.flush();
            oos.close();
    
        }
    
        // 使用克隆
        @Test
        public void fun5() throws CloneNotSupportedException {
            Person p = new Person();
            p.setName("tom");
            p.setSex("male");
            p.setAddress("北京");
            
            
            Person pp = (Person) p.clone(); // 得到一个p对象的副本
            
            System.out.println(pp);
        }
    }

    2

    package cn.itcast.demo;
    
    import java.io.Serializable;
    
    public class Person implements Cloneable{// implements Serializable {
    
        // private static final long serialVersionUID = 1L;
        private String name;
        private String sex;
        private String address;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person [name=" + name + ", sex=" + sex + ", address=" + address
                    + "]";
        }
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
    }

    3.自动装配操作.
    创建一个Map集合.
    map.put("name","tom");
    map.put("sex","男");
    map.put("address","北京");

    Person类.
    class Person{

    private String name;
    private String sex;
    private String address;

    get/set方法.
    }

    要求,使用反射,将map集合中key值与Person类中属性名相同的用key的value对Person类的属性赋值.

    不使用Field类,使用 Method类操作.

    package cn.itcast.demo;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    import org.junit.Test;
    
    public class Demo3 {
    
        public static void main(String[] args) throws SecurityException,
                NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
            Map<String, String> map = new HashMap<String, String>();
            map.put("name", "tom");
            map.put("sex", "男");
            map.put("address", "北京");
    
            Person p = new Person();
    
            // 1.得到集合中的所有key
            Set<String> keys = map.keySet();
    
            // 2.得到所有的Person类中的属性.
            Class clazz = p.getClass();
            Field[] fields = clazz.getDeclaredFields();// 属性是private
    
            // 3.遍历属性,判断keys是否包含这些属性.
    
            for (Field field : fields) {
                // 得到属性名称.
                String fieldName = field.getName();
    
                if (keys.contains(fieldName)) {
                    // map集合的key中包含这样的属性名。那么就需要调用这个属性对应的set方法将key对应的value进行赋值操作.
    
                    // 1.得到value
                    String value = map.get(fieldName);
    
                    // 2.得到属性对应的set方法
                    Method setMethod = clazz.getMethod(getSetMethodName(fieldName),
                            String.class);
                    
                    //3.调用方法进行赋值.
                    
                    setMethod.invoke(p, value);
    
                }
            }
            
            System.out.println(p);
        }
    
        public static String getSetMethodName(String param) {
    
            return "set" + (char) (param.charAt(0) - 32) + param.substring(1);
    
        }
    
        @Test
        public void fun() {
            // 'n'---->N
    
            System.out.println((char) ('n' - 32));
    
        }
    }
  • 相关阅读:
    Longest Palindromic Substring
    PayPal MLSE job description
    Continuous Median
    Remove Duplicates From Linked List
    Valid IP Address
    Longest substring without duplication
    Largest range
    Subarray sort
    Multi String Search
    Suffix Trie Construction
  • 原文地址:https://www.cnblogs.com/spadd/p/4192444.html
Copyright © 2011-2022 走看看