java基础语法（三十九）—反射机制（一）

反射机制

1、反射机制有什么用?
通过java语言中的反射机制可以操作字节码文件.
优点类似于黑客( 可以读和修改字节码文件)
通过反射机制可以操作代码片段。(class文件)
2、反射机制的相关类在哪个包下?
java.lang.reflect.*;
3、反射机制相关的重要的类有哪些?
java.lang.Class:代表整个字节码，代表一个类型,代表整个类
java.lang.reflect.Method:代表字节码中的方法字节码。代表类中的方法
java.lang.reflect.Constructor:代表字节码中的构造方法字节码.代表类中的构造方法
java.lang.reflect.Field:代表字节码中的属性字节码。代表类中的属性，也就是类中的成员变量（静态变量和实例变量）

java.lang.Class:
    public class User{
        //Field
        int no;
        //Constructor
        public User() {

        }
        public User (int no) {
        this.no=no;
      }
      //Method
       public void setNo(int no) {
            this.no=no;
       }
       public int getNo() {
         return no;
         }

    }

获得一个类的字节码，三种方式

要操作一个类的字节码,需要首先获取到这个类的字节码,怎么获取java.lang.Class实例?
三种方式.
第一种方式： Class c=Class.forName(“完整类名带包名”);
第二种方式： Class c = 对象.getClass();
第三种方式： Class c=任何类型.class;

public class ReflectTest01 {
    public static void main(String[] args) {
        /*
        Class.forName()
            1、静态方法
            2.方法的参数是一个字符串。
            3。字符串需要的是一个完整类名。
            4、完整类名必须带有包名。java.lang包也不能省略。

         */
        Class c1=null;
        try {
             c1=Class.forName("java.lang.String");//c1代表string.class文件,或者说c1代表String类型。
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //java中任何一个对象都有一个方法：getClass()
        String s="abc";
        Class x=s.getClass();//x代表String.Class字节码文件, x代表String类型。
        System.out.println(c1==x);//true(==判断的是对象的内存地址)

        //第三种方式, java语言中任何一种类型，包括基本数据类型，它都有.class属性。
        Class z=String.class;//z代表String类型
        System.out.println(z==x);//true

    }
}

实例化对象

获取到Class,能干什么？
通过Class的newInstance()方法来实例化对象。
注意: newInstance()方法内部实际上调用了无参数构造方法,必须保证无参构造存在才可以。
先给出User类

public class User {
    public User() {
        System.out.println("无参数构造方法！");
    }
    //定义了有参数的构造方法,无参数构造方法就没了。
    public User(String s){

    }

}

public class ReflectTest02 {
    public static void main(String[] args) {
        //这是不使用反射机制,创建对象
        User user = new User();
        System.out.println(user);
        //下面这段代码是以反射机制的方式创建对象。

        //通过反射机制,获取Class ,通过Class来实例化对象
        try {
            Class c=Class.forName("reflect.User");
            // newInstance() 这个方法会调用User这个类的无参数构造方法，完成对象的创建。
            //重点是:newInstance() 调用的是无参构造。须保证无参构造是存在的!
            Object obj=c.newInstance();
            System.out.println(obj);//reflect.User@50cbc42f
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }

    }
}

验证反射机制的灵活性。

java代码写一遍，在不改变java源代码的基础之上。可以做到不同对象的实例化。

后期要学习的是高级框架,而工作过程中，也都是使用高級框架,
包括: ssh ssm
Spring SpringMVC MyBatis
Spring Struts Hibernate
…
这些高级框架底层实现原理:都采用了反射机制。所以反射机制还是重要的。
学会了反射机制有利于理解制析框架底层的源代码。

import java.io.FileReader;
import java.util.Properties;

public class ReflectTest03 {
    public static void main(String[] args) throws Exception {
        //这种方式代码就写死了。只能创建一个User类型的对象
        //User user = new User();
        //以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。

        //通过Io流读取classinfo.properties文件
        FileReader reader = new FileReader( "src/classinfo.properties");
        //创建属性类对象
        Properties pro = new Properties(); // key value 都是String
        //加载
        pro.load(reader);

        //关闭流
        reader.close();
        //通过key获取value
        String className=pro.getProperty("className");
        //通过反射机制实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

研究一下：Class.forName()发生了什么
记住，重点:
如果只是希望一个类的静态代码块执行，其它代码一律不执行,
可以使用:
Class.forName(“完整类名");
这个方法的执行会导致类加裁，类加裁时,静态代码块执行。

public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.forName()这个方法的执行会导致:类加裁。
            Class.forName("reflect.MyClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class MyClass {
    //静态代码块在类加载时执行,并且只执行一次。
    static {
        System.out.println("MyClass类的静态代码块执行了!");
    }
}

文件路径的问题

研究一下文件路径的问题。
怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。但前提是:文件需要在类路径下。才能用这种方式。

import java.io.FileReader;

public class AboutPath {
    public static void main(String[] args) throws Exception {
        //这种方式的路径缺点是:移植性差，在IDEA中默认的当前路径是project的根。
        //这个代码假设离开了IDEA ,换到了其它位置，可能当前路径就不是project的根了,这时这个路径就无效了。
        //FileReader reader = new FileReader("src/classinfo.properties");
        //接下来说一种比较通用的一种路径。即使代码换位置了,这样编写仍然是通用的。
        //注意:使用以下通用方式的前提是:这个文件必须在类路径下。
        //什么类路径下?凡是在src下的都是类路径下。 [记住它]
        //src是类的根路径。
        /*
        解释:
            Thread.currentThread()当前线程对象
            getContextClassLoader()是线程对象的方法，可以获取到当前线程的类加载器对象。
            getResource() [获取资源] 这是类加裁器对象的方法。当前线程的类加裁器默认从类的根路径下加载资源。
         */
        String path=Thread.currentThread().getContextClassLoader().getResource("classinfo.properties").getPath();
        //采用以上的代码可以拿到一个文件的绝对路径
        System.out.println(path);


    }
}

可变长度参数

可变长度参数
int… args 这就是可变长度参数
语法是:类型… (注意：一定是3个点)

1.可变长度参数要求的参数个数是:0~N个。
2.可变长度参数在参数列表中必须在最后一个位置上 ,而且可变长度参数只能有1个。
3.可变长度参数可以当做一个数组来看待

public class ArgsTest {
    public static void main(String[] args) {
        m();
        m(10);

        m2(100);
        m2(100,"abc");
        m2(200,"abc","def");

        m3("abc","def");

        String[] strs={"a","b","c"};
        //也可以传一个数组
        m3(strs);

        //直接传1个数组
        m3(new String[]{"d","e","f"});

    }

    public static void m(int... args){
        System.out.println("m方法执行了！！！");
    }
    //public static void m2(String... args1,int... args2){}

    //必须在最后，只能有1个
    public static void m2(int a,String... args1){

    }

    public static void m3(String... args){
        args有length属性，说明args是一个数組!
        //可以将可变长度数组当做一个数组来看
        for (int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }//abc def
    }
}

以流的形式返回

import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;

public class IoPropertiesTest {
    public static void main(String[] args) throws Exception {
        /*String path=Thread.currentThread().getContextClassLoader().getResource("classinfo.properties").getPath();
        FileReader reader=new FileReader(path);
         */

        //直接以流的形式返回
        InputStream reader=Thread.currentThread().getContextClassLoader().getResourceAsStream("classinfo.properties");
        Properties pro=new Properties();
        pro.load(reader);
        reader.close();
        //通过key获取value
        String className=pro.getProperty("className");
        System.out.println(className);

    }
}