[零基础学JAVA]Java SE应用部分-36.反射机制与工厂设计模式-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_33860147/article/details/85200652

本文详细介绍了Java反射机制的基本概念及应用，并结合工厂模式实现了一个高可扩展性的水果工厂示例，展示了如何通过配置文件来扩展工厂的功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本季目标

Java的反射机制
工厂模式综合讲解

1、什么叫反射
Java.lang.reflect包下
正常情况下我们可以通过类实例化一个对象，那么通过反射实际上就可以通过一个对象得到此类完整的包.类名称。

package org.michael;
class Person{
         private String name;
         private int age;
         public void setName(String name){
                 this.name = name;
        }
         public void setAge( int age){
                 this.age = age;
        }
         public String getName(){
                 return this.name;
        }
         public int getAge(){
                 return this.age;
        }
}
public class Demo01{
         public static void main(String args[]){
                Person p = new Person();
                 //假设现在不知道p是那个类的对象，则可以通过反射机制找到
                Class c = null;
                c = p.getClass();
                System.out.println(c.getName());
        }
}

看下效果：

除了可以找到对象所在的包.类名称，实际上也可以把所有的方法名称列出来。

package        org.michael;
import java.lang.reflect.*;
class Person{
         private String name;
         private int age;
         public void setName(String name){
                 this.name = name;
        }
         public void setAge( int age){
                 this.age = age;
        }
         public String getName(){
                 return this.name;
        }
         public int getAge(){
                 return this.age;
        }
}
public class Demo02{
         public static void main(String args[]){
                Person p = new Person();
                 //假设现在不知道p是那个类的对象，则可以通过反射机制找到
                Class c = null;
                c = p.getClass();
                Method m[] = c.getMethods();
                 for( int i=0;i<m.length;i++){
                System.out.println(m[i]);
                }
        }
}

2、研究Class类
Class类的构造方法被私有化了，外部无法直接看见，所以其内部必然有一个方法可以取得Class 实例。
public static Class<?> forName(String className) throws ClassNotFoundException
此方法可以返回Class类的实例，此方法接收一个完整的包.类名称。
通过newInstance方法，可以将传入的完整的字符串（包.类名称）实例化。

package        org.michael;
import java.lang.reflect.*;
class Person{
         private String name;
         private int age;
         public void setName(String name){
                 this.name = name;
        }
         public void setAge( int age){
                 this.age = age;
        }
         public String getName(){
                 return this.name;
        }
         public int getAge(){
                 return this.age;
        }
}
public class Demo03{
         public static void main(String args[]){
                Person p = null;
                Class c = null;
                 try{
                        c = Class.forName( "org.michael.Person");
                } catch (Exception e){}
                 try{
                        p = (Person)c.newInstance();
                } catch (Exception e){}
                 //上面两行代码也可以使用下面一行代码取代哈~
                 // p = (Person)Class.forName("org.michael.Person").newInstance();
                p.setName( "Michael");
                p.setAge(30);
                System.out.println(p.getName()+ "--->"+p.getAge());
        }
}

如果要使用以上的代码去实例化一个对象，则必须有一个前途条件：在对象所在的类中必须有一个无参构造方法，如果没有此无参构造，则肯定会出现错误。

package        org.michael;
import java.lang.reflect.*;
class Person{
         private String name;
         private int age;
         public Person(String name, int age){
                 this.name = name;
                 this.age = age;
        }
         public void setName(String name){
                 this.name = name;
        }
         public void setAge( int age){
                 this.age = age;
        }
         public String getName(){
                 return this.name;
        }
         public int getAge(){
                 return this.age;
        }
}
public class Demo04{
         public static void main(String args[]){
                Person p = null;
                Class c = null;
                 try{
                        c = Class.forName( "org.michael.Person");
                        p = (Person)c.newInstance();
                } catch (Exception e){
                        System.out.println(e);
                }
                System.out.println(p.getName()+ "--->"+p.getAge());
        }
}

在此时如果想继续通过此操作为对象进行实例化，则可以通过构造方法类（Constructor）完成。

package        org.michael;
import java.lang.reflect.*;
class Person{
         private String name;
         private int age;
         public Person(String name, int age){
                 this.name = name;
                 this.age = age;
        }
         public void setName(String name){
                 this.name = name;
        }
         public void setAge( int age){
                 this.age = age;
        }
         public String getName(){
                 return this.name;
        }
         public int getAge(){
                 return this.age;
        }
}
public class Demo05{
         public static void main(String args[]){
                Person p = null;
                Class c = null;
                 try{
                        c = Class.forName( "org.michael.Person");
                        Constructor[] cs = c.getConstructors();
                        Object obj[] = new Object[]{ "Michael",30};
                         //一个类中会有多个构造方法，所以此时返回一个数组
                        p = (Person)cs[0].newInstance(obj);
                } catch (Exception e){
                        System.out.println(e);
                }
                System.out.println(p.getName()+ "--->"+p.getAge());
        }
}

反射机制实际上是我们所有框架的一个基础，那么现在就利用反射机制完成一个高可扩展性的工厂设计。

回顾：工厂设计

interface Fruit{
         public void grow();
         public void eat();
}
class Apple implements Fruit{
         public void grow(){
                System.out.println( "苹果在生长...");
        }
         public void eat(){
                System.out.println( "吃苹果...");
        }
}
class Orange implements Fruit{
         public void grow(){
                System.out.println( "橘子在生长...");
        }
         public void eat(){
                System.out.println( "吃橘子...");
        }
}
class Factory{
         public static Fruit getFruit( int i){
                Fruit f = null;
                 if (i==1){
                        f = new Apple();
                }
                 if (i==2){
                        f = new Orange();
                }
                 return f;
        }
}
public class Demo06{
         public static void main(String args[]){
                Fruit f = Factory.getFruit(1);
                f.grow();
        }
}

客户端只与工厂和直接的接口有关了，而与其他的无关，但是有个问题，如果现在要扩展了子类，则工厂也必须同时进行修改。那么有没有一种方法，可以让子类扩充之后不去修改工厂呢？肯定是有的，通过Class.forName 完成。

interface Fruit{
         public void grow();
         public void eat();
}
class Apple implements Fruit{
         public void grow(){
                System.out.println( "苹果在生长...");
        }
         public void eat(){
                System.out.println( "吃苹果...");
        }
}
class Orange implements Fruit{
         public void grow(){
                System.out.println( "橘子在生长...");
        }
         public void eat(){
                System.out.println( "吃橘子...");
        }
}
class Banana implements Fruit{
         public void grow(){
                System.out.println( "香蕉在生长...");
        }
         public void eat(){
                System.out.println( "吃香蕉...");
        }
}
class Factory{
         public static Fruit getFruit(String className){
                Fruit f = null;
                 try{
                        f = (Fruit)Class.forName(className).newInstance();
                } catch (Exception e){}
                 return f;
        }
}
public class Demo07{
         public static void main(String args[]){
                Fruit f = Factory.getFruit( "Banana");
                f.grow();
        }
}

但是此程序依然有一个缺点，现在的输入的包.类名称实际上长度非常的短，如果包.类名称的长度过长了，则在使用的时候就比较麻烦了。所以最好可以找个代号进行替代。
使用Hashtable的子类 —— Properties完成。

如果现在再增加子类呢？
属性文件肯定不够了。
所以此时为了达到好的效果，则最好可以将属性保存起来，之后通过修改保存的文件达到属性的扩充。

import java.util.*;
import java.io.*;
interface Fruit{
         public void grow();
         public void eat();
}
class Apple implements Fruit{
         public void grow(){
                System.out.println( "苹果在生长...");
        }
         public void eat(){
                System.out.println( "吃苹果...");
        }
}
class Orange implements Fruit{
         public void grow(){
                System.out.println( "橘子在生长...");
        }
         public void eat(){
                System.out.println( "吃橘子...");
        }
}
class Banana implements Fruit{
         public void grow(){
                System.out.println( "香蕉在生长...");
        }
         public void eat(){
                System.out.println( "吃香蕉...");
        }
}
class Factory{
         public static Fruit getFruit(String className){
                Fruit f = null;
                 try{
                        f = (Fruit)Class.forName(className).newInstance();
                } catch (Exception e){}
                 return f;
        }
}
class PropertyOperate{
         private Properties pro = null;
         public PropertyOperate(){
                 this.pro = new Properties();
                 this.load();
        }
         //设置一个返回方法
         public Properties getPro(){
                 return this.pro;
        }
         //从文件中读出属性，如果文件不存在，则创建一个默认的
         private void save(){
                pro.setProperty( "a", "Apple");
                pro.setProperty( "o", "Orange");
                 //保存在文件之中
                 try{
                        pro.storeToXML( new FileOutputStream( new File( "e:\\fruit.xml")), "FRUIT FACTORY");
                } catch (Exception e){}
        }
         private void load(){
                File f = new File( "e:\\fruit.xml");
                 if(f.exists()){
                         //文件存在则可以读取
                         try{
                                pro.loadFromXML( new FileInputStream(f));
                        } catch (Exception e){}
                } else{
                         //进行创建
                         this.save();
                }
        }
}
class InputData{
         private BufferedReader buf = null;
         public InputData(){
                 this.buf = new BufferedReader( new InputStreamReader(System.in));
        }
         public String getString(){
                String str = null;
                 try{
                        str = this.buf.readLine();
                } catch(Exception e){}
                 return str;
        }
}
public class Demo09{
         public static void main(String args[]){
                Properties p = new PropertyOperate().getPro();
                System.out.println(p);
                System.out.print( "请选择所需要的类型：");
                String str = new InputData().getString();
                 //进一步扩展，现在可以由用户自己输入要使用的类型
                Fruit f = Factory.getFruit(p.getProperty(str));
                f.grow();
        }
}