Java基础知识13--Java反射原理以及基本使用和重写与重载的区别

1.Java反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在Java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。

2.类加载的过程

Class对象的由来是将class文件读入内存，并为之创建一个Class对象

3.Java反射的作用与解决的问题

Java中编译类型有两种：

静态编译：在编译时确定类型，绑定对象即通过。
动态编译：运行时确定类型，绑定对象。动态编译最大限度地发挥了Java的灵活性，体现了多态的应用，可以减低类之间的耦合性。

Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public、static等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。

Reflection可以在运行时加载、探知、使用编译期间完全未知的classes。即Java程序可以加载一个运行时才得知名称的class，获取其完整构造，并生成其对象实体、或对其fields设值、或唤起其methods。

一句话概括就是使用反射可以赋予jvm动态编译的能力，否则类的元数据信息只能用静态编译的方式实现，例如热加载，Tomcat的classloader等等都没法支持。

3.1 编译期和运行期区别

编译期：检查是否有语法错误，如果没有就将其翻译成字节码文件。即.class文件。
运行期：java虚拟机分配内存，解释执行字节码文件。

3.2 Java 重写(Override)与重载(Overload)

3.2.1 重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，抛出 IOException 异常或者 IOException 的子类异常。

重写是父类与子类之间多态性的表现，在运行时起作用（动态多态性，譬如实现动态绑定）

方法的重写是在运行时进行的。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

在上面的例子中可以看到，尽管 b 属于 Animal 类型，但是它运行的是 Dog 类的 move方法。

这是由于在编译阶段，只是检查参数的引用类型。

然而在运行时，Java 虚拟机(JVM)指定对象的类型并且运行该对象的方法。

方法的重写规则：

参数列表与被重写方法的参数列表必须完全相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
构造方法不能被重写。

3.2.2 重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

方法重载是在编译时执行的。

重载规则:

被重载的方法必须改变参数列表(参数列表中的参数顺序、个数、类型不一样)；

被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

实例：

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

3.2.3 重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

方法重载：
1、同一个类中
2、方法名相同，参数列表不同（参数顺序、个数、类型）
3、方法返回值、访问修饰符任意
4、与方法的参数名无关

方法重写：
1、有继承关系的子类中
2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
3、访问修饰符，访问范围需要大于等于父类的访问范围
4、与方法的参数名无关

4.反射的使用

4.1 获取Class对象的三种方式

Object ——> getClass();
任何数据类型（包括基本数据类型）都有一个“静态”的class属性
通过Class类的静态方法：forName（String className）(常用)

测试案例：

/**
 * @Author lucky
 * @Date 2021/12/28 16:09
 */
public class ReflectTest {
    public static void main(String[] args) {
        //第一种方式获取Class对象
        Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
        Class stuClass = stu1.getClass();//获取Class对象
        System.out.println(stuClass.getName());

        //第二种方式获取Class对象
        Class stuClass2 = Student.class;
        System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个

        //第三种方式获取Class对象
        try {
            Class stuClass3 = Class.forName("com.ttbank.flep.core.entity.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
            System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

注意：在运行期间，一个类，只有一个Class对象产生。

三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。

4.2 通过反射获取构造方法并使用

Teacher类：

package com.ttbank.flep.core.entity;

/**
 * @Author lucky
 * @Date 2021/12/28 16:30
 */
public class Teacher {
    //---------------构造方法-------------------
    //（默认的构造方法）
    Teacher(String str){
        System.out.println("(默认)的构造方法 s = " + str);
    }

    //无参构造方法
    public Teacher(){
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }

    //有一个参数的构造方法
    public Teacher(char name){
        System.out.println("姓名：" + name);
    }

    //有多个参数的构造方法
    public Teacher(String name ,int age){
        System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
    }

    //受保护的构造方法
    protected Teacher(boolean n){
        System.out.println("受保护的构造方法 n = " + n);
    }

    //私有构造方法
    private Teacher(int age) {
        System.out.println("私有的构造方法   年龄：" + age);

    }

    public void sayHello(){
        System.out.println("hello");
    }
}

典型应用代码：

    public static void main(String[] args) {
        try {
            //01 获取Class对象
            Class<?> teacherClass = Class.forName("com.ttbank.flep.core.entity.Teacher");
            //02 获取构造方法
            Constructor<?> constructor = teacherClass.getConstructor(String.class,int.class);
            //03 利用构造方法创建声明类Teacher的新实例
            Teacher teacher = (Teacher) constructor.newInstance("lucky", 25);
            teacher.sayHello();
        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

控制台输出：

测试代码：

package com.ttbank.flep.core.test;

import java.lang.reflect.Constructor;

/**
 * @Author lucky
 * @Date 2021/12/28 16:35
 */
public class ConstructorTest {
    public static void main(String[] args) throws Exception {
        //1.加载Class对象
        Class clazz = Class.forName("com.ttbank.flep.core.entity.Teacher");


        //2.获取所有公有构造方法
        System.out.println("**********************所有公有构造方法*********************************");
        Constructor[] conArray = clazz.getConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }


        System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
        conArray = clazz.getDeclaredConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }

        System.out.println("*****************获取公有、无参的构造方法*******************************");
        Constructor con = clazz.getConstructor(null);
        //1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
        //2>、返回的是描述这个无参构造函数的类对象。

        System.out.println("con = " + con);
        //调用构造方法
        Object obj = con.newInstance();
        //    System.out.println("obj = " + obj);
        //    Student stu = (Student)obj;

        System.out.println("******************获取私有构造方法，并调用*******************************");
        con = clazz.getDeclaredConstructor(char.class);
        System.out.println(con);
        //调用构造方法
        con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
        obj = con.newInstance('男');
    }
}

控制台输出：

**********************所有公有构造方法*********************************
public com.ttbank.flep.core.entity.Teacher(java.lang.String,int)
public com.ttbank.flep.core.entity.Teacher(char)
public com.ttbank.flep.core.entity.Teacher()
************所有的构造方法(包括：私有、受保护、默认、公有)***************
private com.ttbank.flep.core.entity.Teacher(int)
protected com.ttbank.flep.core.entity.Teacher(boolean)
public com.ttbank.flep.core.entity.Teacher(java.lang.String,int)
public com.ttbank.flep.core.entity.Teacher(char)
public com.ttbank.flep.core.entity.Teacher()
com.ttbank.flep.core.entity.Teacher(java.lang.String)
*****************获取公有、无参的构造方法*******************************
con = public com.ttbank.flep.core.entity.Teacher()
调用了公有、无参构造方法执行了。。。
******************获取私有构造方法，并调用*******************************
public com.ttbank.flep.core.entity.Teacher(char)
姓名：男

调用方法：
<1>获取构造方法：
1).批量的方法：

public Constructor[] getConstructors() //所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()//获取所有的构造方法(包括私有、受保护、默认、公有)

2).获取单个的方法，并调用：

public Constructor getConstructor(Class... parameterTypes) //获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes) //获取"某个构造方法"可以是私有的，或受保护、默认、公有；

<2>newInstance是 Constructor类的方法（管理构造函数的类）
api的解释为：
newInstance(Object... initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用

5.Java中new和反射创建对象

5.1 Java中new创建对象

图来自知乎

如果我们在代码中如果写了一段

A a = new A();

在JVM中会帮你做的事情有以下：

JVM把类的.java文件编译为一个.class的字节码文件
类加载器把.class文件加载进jvm的内存中，一个Class对象生成，并放入方法区中，这Class对象对于任何类都是唯一一个。

做完这些之后，才是new字段的工作：

判断内存中是否已经有那个唯一的Class对象
如果没有，则进行上述操作。
如果有，则在内存中申请空间开辟，即根据Class对象获取有关的构造器进行实例化，在这里我们假设是一个无参数构造，那么只需要newInstance()。

5.2 Java中使用反射创建对象

这次的代码是我们最常见的反射代码

Class c = Class.forName("A的全类名");

当JVM编译到这段代码的时候，他的步骤是：
1、使用类加载，将对应.class加载入内存的方法区中，并返回Class对象。
这时候，我们可以查看这个类对象里面的构造器方法，并使用无参数构造器进行构造实例,即如下代码

Constructor constructor = c.getConstructor();
Object obj = constructor.newInstance();

用同样的图，我们可以画出来。

到这里，我们几乎可以知道无论是反射，还是New，其实都是通过类加载器对.class文件加载进内存中，创建了Class对象。‘’

Java中反射属于动态编译，而new属于静态编译。

粗俗解释：

1、静态编译相当于把所有需要的东西都在初始化的时候加载了，如果程序一大，就很有可能会跑得慢。

2、动态编译，在编译的时候，需要的模块都没有编译进去，启动程序的时候，模块不会被加载而是在运行的时候，需要哪个模块就调用哪个模块。

上面的过程告诉我们，我们如果用new，那么我们要创建的类都是已经“写死”在.class文件里面了，我们无法控制JVM帮我们加载类的这一项工作。

但是如果我们用反射创建类对象，我们是相当于亲自“指导”JVM，我们“按需加载”.class文件，如果内存里面没有这个类的.class文件，那么我们用Class.forName（）去叫类加载器帮忙加载就行了，而不是把程序停下来，再打一段代码，再让类加载器进行加载，从而体现出了Java的“动态性”。

因为Spring在加载类的实例时，我们知道其实是用工厂的方式，给出一个个实例，而在工厂里面，用了单例，但是真正实例化，则是反射的newInstance来创建对象，而不是new。

那么，为什么是反射的newInstance，而不是new呢？

那么首先我们必须明白，Java里面，反射的目的是什么？

高内聚，低耦合。

进一步，反射比new的好处是什么？

反射不用知道类名，可以直接实例化类，也就是不用硬编码。

有人问了，不知道类名那怎么反射呢？

例子：

通过new，我们这么写：

A a = New A();

通过反射，我们这么写：

Class c = Class.forName(“A”);
factory = (AInterface)c.newInstance();

其中AInterface是类A的接口，如果下面这样写，你可能会理解：

String className = “A”;
Class c = Class.forName(className);
factory = (AInterface)c.newInstance();

进一步，如果下面写，你可能会理解：

String className = readfromXMlConfig;//从xml 配置文件中获得字符串
Class c = Class.forName(className);
factory = (AInterface)c.newInstance();

上面代码就消灭了A类名称，优点：无论A类怎么变化，上述代码不变，甚至可以更换A的兄弟类B , C , D….等，只要他们继承Ainterface就可以。

参考文献：https://blog.csdn.net/qq_26558047/article/details/109745018

https://blog.csdn.net/weixin_34672875/article/details/115074666

https://blog.csdn.net/sinat_38259539/article/details/71799078----经典

posted @ 2021-11-22 11:27 雨后观山色阅读(756) 评论(0) 编辑收藏举报

刷新页面返回顶部

雨后观山色