强烈推荐mkw Ceder老师的视频，讲得非常好！其实教学视频也不错。
在Java语言中，除了静态成员和普通的数据类型不是对象，万物皆对象。类本身也是 java.lang.Class 类的实例对象 。There is a class named Class！
编译：javac offer.java，将源代码→字节码文件(offer.class)
运行：java offer，字节码进入虚拟机，变成机器码运行结果
静态加载：编译时加载类是静态加载类
动态加载：运行时加载是动态加载类
Class.forName("类的全称")
首先，用任何文本编辑器(Notepadd++)编写以下代码：
class Office {
public static void main(String[] args) {
if("Word".equals(args[0])) {
Word w = new Word();
w.start();
}
if("Excel".equals(args[0])) {
Excel e = new Excel();
e.start();
}
然后编译 javac Office.java，会报错：找不到 Word和Excel类以及start()方法我们再编写Word类。
class Word {
public void start() {
System.out.println("Word...Start");
}
}
再执行：
javac Word.java
javac Office.java
报错，找不到 Excel类
这种是静态加载类，即编译的时候就加载所有可能使用到的类，不管后面会不会用到。
这里Office类用到了 两个类，在编译的时候这两个类都要有，设想能不能只编写Word类或者没有Word类，我希望就能编译成功，用到Word类的时候，再编写编译Word类，这就用到动态加载。重写一个OfficeTest.java
class OfficeTest {
public static void main(String[] args) {
try{
Class c = Class.forName(args[0]);
} catch(Exception e){
e.printStackTrace();
}
}
}
动态加载类，在运行时加载，此时编译不报错，只有在运行的时候需要加参数，如果没有对应的被编译后的class文件就会报错。
OfficeBetter.java
class OfficeBetter {
public static void main(String[] args) {
try{
Class c = Class.forName(args[0]);
OfficeAble oa = (OfficeAble)c.newInstance();
oa.start();
} catch(Exception e){
e.printStackTrace();
}
}
}
OfficeAble.java 是一个接口
public interface OfficeAble {
public void start();
}
以上两个编译后不会报错，后面谁实现了该接口，然后自己编译即可，而上述代码就不用再编译了，例如：
Word实现
class Word implements OfficeAble{
public void start() {
System.out.println("Word...Start");
}
}
编译并执行
javac Word.java
java OfficeBetter Word
# Word...Start
添加 Excel功能实现时，再编写并单独编译即可，这就实现了某种解耦，模块化编程的思想。
class Excel implements OfficeAble{
public void start() {
System.out.println("Excel...Start");
}
}
反射是在运行时动态访问类与对象的技术，JDK1.2以后的技术，大多数Java框架都基于反射实现参数配置、动态注入等特性
Java放射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
获取某个具体类的类类型有三种方法：
package com.imooc.reflect;
class Foo{
void print(){
System.out.println("foo");
}
}
public class ClassDemo1 {
public static void main(String[] args) {
//Foo的实例对象如何表示
Foo foo1 = new Foo();//foo1就表示出来了.
//Foo这个类 也是一个实例对象，Class类的实例对象,如何表示呢
//任何一个类都是一个唯一的Class类的实例对象，这个实例对象有三种表示方式
//第一种表示方式--->实际在告诉我们任何一个类都有一个隐含的静态成员变量class
Class c1 = Foo.class;
//第二中表达方式 已经知道该类的对象通过getClass方法
Class c2 = foo1.getClass();
/*官网 c1 ,c2 表示了Foo类的类类型(class type)
* 万事万物皆对象，
* 类也是对象，是Class类的实例对象
* 这个对象我们称为该类的类类型
*
*/
//不管c1 or c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
System.out.println(c1 == c2);
//第三种表达方式
Class c3 = null;
try {
c3 = Class.forName("com.imooc.reflect.Foo");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(c2==c3);
//我们完全可以通过类的类类型创建该类的对象实例---->通过c1 or c2 or c3创建Foo的实例对象
try {
Foo foo = (Foo)c1.newInstance();//需要有无参数的构造方法
foo.print();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
核心方法：
classObj.getConstructor()：获取指定public修饰的构造方法对象
constructorObj.newInstance()：通过对应的构造方法创建对象
Employee.java
public class Employee {
static {
System.out.println("Employee类已被加载到jvm，并已初始化");
}
private Integer eno;
public String ename;
private Float salary;
private String dname;
public Employee(){
System.out.println("Employee默认构造方法已执行");
}
public Employee(Integer eno, String ename, Float salary, String dname) {
this.eno = eno;
this.ename = ename;
this.salary = salary;
this.dname = dname;
System.out.println("Employee带参构造方法已执行");
}
//省略了每个变量的getter setter方法。
@Override
public String toString() {
return "Employee{" +
"eno=" + eno +
", ename=‘" + ename + ‘\‘‘ +
", salary=" + salary +
", dname=‘" + dname + ‘\‘‘ +
‘}‘;
}
public Employee updateSalary(Float val){
this.salary += val;
System.out.println(this.ename + "调薪至" + this.salary + "元");
return this;
}
}
Consructor方法类
Class employeeClass = Class.forName("com.imooc.reflect.entity.Employee");
Constructor constructor = employeeClass.getConstructor(new Class[]{Integer.class,String.class,Float.class,String.class});
Employee employee = (Employee) constructor.newInstance(new Object[]{1000,"李雷",2000f,"研发部"});
classObj.getMethod()方法获取，通过Method对象调用指定对象的对应方法
classObj.getMethod()：获取指定public修饰的方法对象
methodObj.invoke()：调用指定对象的对应方法
Method updateSalaryMethod = employeeClass.getMethod("updateSalary",Float.class);
Employee employee1 =(Employee) updateSalaryMethod.invoke(employee,new Object[]{1000f});
classObj.getField()：获取指定public修饰的成员变量对象
fieldObj.set()：为某对象指定成员变量赋值
fieldObj.get()：获取某对象指定成员变量数值
Field enameField = employeeClass.getField("ename");
String ename = (String) enameField.get(employee);
enameField.set(employee,"王大锤");
getConstructor(s)|Methods(s)|Field(s)都是获取 public的方法
getDeclaredConstructor(s)|Methods(s)|Field(s)能获取所有的对象，public和private都有
Field[] fields = employeeClass.getDeclaredFields();
for(Field field:fields){
//System.out.println(field.getName());
if(field.getModifiers() == 1){ //public修饰
Object val = field.get(employee);
System.out.println(field.getName() + ":" + val);
} else if(field.getModifiers() == 2) { //private修饰
//对于私有的属性，调用提供的getter方法来调用，这里是连接字符串得到的的
String methodName = "get" + field.getName().substring(0,1).toUpperCase() +
field.getName().substring(1);
Method getMethod = employeeClass.getMethod(methodName);
Object ret = getMethod.invoke(employee); //不能强制转换，因为属性的类类型都不同
System.out.println(field.getName() + ":" + ret);
}
}
写了一个 i18n的Java项目
主要是用配置文件修改程序的逻辑，和后面的 Spring的applicationContext.xml修改类一样。
原文：https://www.cnblogs.com/it-bt/p/14589414.html