Java的RTTI机制–反射

最新推荐文章于 2024-07-25 17:07:03 发布

原创最新推荐文章于 2024-07-25 17:07:03 发布 · 417 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #语言 #RTTI #反射

Java 专栏收录该内容

0 篇文章

订阅专栏

本文通过具体的Java代码示例，介绍了如何利用RTTI机制实现动态调用方法的功能，并展示了如何通过装饰模式增强程序员类的功能。

Java的RTTI机制–反射

最初是在C#语言中接触到反射这种技术的，可以说反射是使代码更加简介，减少类间耦合的利器。最近要搞Spring这个东西，所以顺便了解一下Java的RTTI机制。
结构图 (简单的桥接模式和装饰模式)

Worker类

package test.rtti.worker;

import java.lang.reflect.Method;

import test.rtti.work.Work;

public abstract class Worker {

    public void makeMoney()
    {
        try
        {
            Method m = _clz.getMethod("doWork");
            m.invoke(_clz.newInstance());
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    protected Class<? extends Work> _clz;
}

Work类

package test.rtti.work;

abstract public class Work {
    abstract public void doWork();
}

Programmer类

package test.rtti.programmer;

import test.rtti.work.Work;
import test.rtti.worker.Worker;

public class Programmer extends Worker {

    public Programmer()
    {

    }

    public Programmer(Class<? extends Work> work)
    {
        _clz = work;
    }
}

Feature类

package test.rtti.feature;

public abstract class Feature {
    public abstract void feature();
}

FastFeature类

package test.rtti.feature;

public class FastFeature extends Feature {

    @Override
    public void feature() {
        // TODO Auto-generated method stub
        System.out.println("Now you can do fast");
    }

}

SuperProgrammer类

package test.rtti.superprogrammer;

import java.lang.reflect.Method;

import test.rtti.feature.Feature;
import test.rtti.programmer.Programmer;

public class SuperProgrammer extends Programmer {

    public SuperProgrammer(Programmer programer, Class<? extends Feature> feature)
    {
        _programmer = programer;
        _feature = feature;
    }

    public void makeMoney()
    {
        try
        {
            Method m = _feature.getMethod("feature");
            m.invoke(_feature.newInstance());
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        _programmer.makeMoney();
    }

    private Programmer _programmer;
    private Class<? extends Feature> _feature;
}

Main

package test.rtti.main;

import test.rtti.code.Code;
import test.rtti.feature.CorrectFeature;
import test.rtti.feature.FastFeature;
import test.rtti.programmer.Programmer;
import test.rtti.superprogrammer.SuperProgrammer;

public class TestRTTI {

    public static void main(String[] args) {
        // TODO Auto-generated method stub      
        Programmer p = new Programmer(Code.class);
        Programmer sp = new SuperProgrammer(p, FastFeature.class);
        Programmer ssp = new SuperProgrammer(sp, CorrectFeature.class);

        ssp.makeMoney();
    }

}

输出：

Now you can do correctly
Now you can do fast
Code to make money