在好例子网,分享、交流、成长!
您当前所在位置:首页Java 开发实例Android平台开发 → java 反射入门级示例(reflect)

java 反射入门级示例(reflect)

Android平台开发

下载此实例
  • 开发语言:Java
  • 实例大小:0.02M
  • 下载次数:12
  • 浏览次数:309
  • 发布时间:2018-08-20
  • 实例类别:Android平台开发
  • 发 布 人:crazycode
  • 文件格式:.zip
  • 所需积分:2
 相关标签: 反射 EF java c ref

实例介绍

【实例简介】

【实例截图】

from clipboard

【核心代码】

/*
 * Copyright (c) 2000 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 2nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book (recommended),
 * visit http://www.davidflanagan.com/javaexamples2.
 */

import java.awt.event.*;
import java.beans.*;
import java.lang.reflect.*;
import java.io.*;
import java.util.*;

/**
 * This class represents a Method, the list of arguments to be passed
 * to that method, and the object on which the method is to be invoked.
 * The invoke() method invokes the method.  The actionPerformed() method
 * does the same thing, allowing this class to implement ActionListener
 * and be used to respond to ActionEvents generated in a GUI or elsewhere. 
 * The static parse() method parses a string representation of a method
 * and its arguments.
 **/
public class Command implements ActionListener {
    Method m;       // The method to be invoked
    Object target;  // The object to invoke it on
    Object[] args;  // The arguments to pass to the method

    // An empty array; used for methods with no arguments at all.
    static final Object[] nullargs = new Object[] {};
    
    /** This constructor creates a Command object for a no-arg method */
    public Command(Object target, Method m) { this(target, m, nullargs); }

    /** 
     * This constructor creates a Command object for a method that takes the
     * specified array of arguments.  Note that the parse() method provides
     * another way to create a Command object
     **/
    public Command(Object target, Method m, Object[] args) { 
	this.target = target;
	this.m = m;
	this.args = args;
    }

    /**
     * Invoke the Command by calling the method on its target, and passing
     * the arguments.  See also actionPerformed() which does not throw the
     * checked exceptions that this method does.
     **/
    public void invoke()
	throws IllegalAccessException, InvocationTargetException
    {
	m.invoke(target, args);  // Use reflection to invoke the method
    }

    /**
     * This method implements the ActionListener interface.  It is like
     * invoke() except that it catches the exceptions thrown by that method
     * and rethrows them as an unchecked RuntimeException
     **/
    public void actionPerformed(ActionEvent e) {
	try {
	    invoke();                           // Call the invoke method
	}
	catch (InvocationTargetException ex) {  // but handle the exceptions
	    throw new RuntimeException("Command: "   
				       ex.getTargetException().toString());
	}
	catch (IllegalAccessException ex) { 
	    throw new RuntimeException("Command: "   ex.toString());
	}
    }

    /**
     * This static method creates a Command using the specified target object,
     * and the specified string.  The string should contain method name
     * followed by an optional parenthesized comma-separated argument list and
     * a semicolon.  The arguments may be boolean, integer or double literals,
     * or double-quoted strings.  The parser is lenient about missing commas,
     * semicolons and quotes, but throws an IOException if it cannot parse the
     * string.
     **/
    public static Command parse(Object target, String text) throws IOException
    {
	String methodname;                 // The name of the method
	ArrayList args = new ArrayList();  // Hold arguments as we parse them.
	ArrayList types = new ArrayList(); // Hold argument types.

	// Convert the string into a character stream, and use the
	// StreamTokenizer class to convert it into a stream of tokens
	StreamTokenizer t = new StreamTokenizer(new StringReader(text));

	// The first token must be the method name
	int c = t.nextToken();  // read a token
	if (c != t.TT_WORD)     // check the token type
	    throw new IOException("Missing method name for command");
	methodname = t.sval;    // Remember the method name

	// Now we either need a semicolon or a open paren
	c = t.nextToken();
	if (c == '(') { // If we see an open paren, then parse an arg list
	    for(;;) {                   // Loop 'till end of arglist
		c = t.nextToken();      // Read next token

		if (c == ')') {         // See if we're done parsing arguments.
		    c = t.nextToken();  // If so, parse an optional semicolon
		    if (c != ';') t.pushBack();
		    break;              // Now stop the loop.
		}

		// Otherwise, the token is an argument; figure out its type
		if (c == t.TT_WORD) {
		    // If the token is an identifier, parse boolean literals, 
		    // and treat any other tokens as unquoted string literals.
		    if (t.sval.equals("true")) {       // Boolean literal
			args.add(Boolean.TRUE);
			types.add(boolean.class);
		    }
		    else if (t.sval.equals("false")) { // Boolean literal
			args.add(Boolean.FALSE);
			types.add(boolean.class);
		    }
		    else {                             // Assume its a string
			args.add(t.sval);
			types.add(String.class);
		    }
		}
		else if (c == '"') {         // If the token is a quoted string
		    args.add(t.sval);
		    types.add(String.class);
		}
		else if (c == t.TT_NUMBER) { // If the token is a number
		    int i = (int) t.nval;
		    if (i == t.nval) {           // Check if its an integer
			// Note: this code treats a token like "2.0" as an int!
			args.add(new Integer(i));
			types.add(int.class);
		    }
		    else {                       // Otherwise, its a double
			args.add(new Double(t.nval));
			types.add(double.class);
		    }
		}
		else {                        // Any other token is an error
		    throw new IOException("Unexpected token "   t.sval  
					  " in argument list of "  
					  methodname   "().");
		}

		// Next should be a comma, but we don't complain if its not 
		c = t.nextToken();
		if (c != ',') t.pushBack();
	    }
	}
	else if (c != ';') { // if a method name is not followed by a paren  
	    t.pushBack();    // then allow a semi-colon but don't require it.
	}

	// We've parsed the argument list.
	// Next, convert the lists of argument values and types to arrays
	Object[] argValues = args.toArray();
	Class[] argtypes = (Class[])types.toArray(new Class[argValues.length]);

	// At this point, we've got a method name, and arrays of argument
	// values and types.  Use reflection on the class of the target object
	// to find a method with the given name and argument types.  Throw
	// an exception if we can't find the named method.
	Method method;
	try { method = target.getClass().getMethod(methodname, argtypes); }
	catch (Exception e) {
	    throw new IOException("No such method found, or wrong argument "  
				  "types: "   methodname);
	}

	// Finally, create and return a Command object, using the target object
	// passed to this method, the Method object we obtained above, and
	// the array of argument values we parsed from the string.
	return new Command(target, method, argValues);
    }

    /**
     * This simple program demonstrates how a Command object can be parsed from
     * a string and used as an ActionListener object in a Swing application.
     **/
    static class Test {
	public static void main(String[] args) throws IOException {
	    javax.swing.JFrame f = new javax.swing.JFrame("Command Test");
	    javax.swing.JButton b1 = new javax.swing.JButton("Tick");
	    javax.swing.JButton b2 = new javax.swing.JButton("Tock");
	    javax.swing.JLabel label = new javax.swing.JLabel("Hello world");
	    java.awt.Container pane = f.getContentPane();

	    pane.add(b1, java.awt.BorderLayout.WEST);
	    pane.add(b2, java.awt.BorderLayout.EAST);
	    pane.add(label, java.awt.BorderLayout.NORTH);

	    b1.addActionListener(Command.parse(label, "setText(\"tick\");"));
	    b2.addActionListener(Command.parse(label, "setText(\"tock\");"));
	    
	    f.pack();
	    f.show();
	}
    }
}

标签: 反射 EF java c ref

实例下载地址

java 反射入门级示例(reflect)

不能下载?内容有错? 点击这里报错 + 投诉 + 提问

好例子网口号:伸出你的我的手 — 分享

网友评论

发表评论

(您的评论需要经过审核才能显示)

查看所有0条评论>>

小贴士

感谢您为本站写下的评论,您的评论对其它用户来说具有重要的参考价值,所以请认真填写。

  • 类似“顶”、“沙发”之类没有营养的文字,对勤劳贡献的楼主来说是令人沮丧的反馈信息。
  • 相信您也不想看到一排文字/表情墙,所以请不要反馈意义不大的重复字符,也请尽量不要纯表情的回复。
  • 提问之前请再仔细看一遍楼主的说明,或许是您遗漏了。
  • 请勿到处挖坑绊人、招贴广告。既占空间让人厌烦,又没人会搭理,于人于己都无利。

关于好例子网

本站旨在为广大IT学习爱好者提供一个非营利性互相学习交流分享平台。本站所有资源都可以被免费获取学习研究。本站资源来自网友分享,对搜索内容的合法性不具有预见性、识别性、控制性,仅供学习研究,请务必在下载后24小时内给予删除,不得用于其他任何用途,否则后果自负。基于互联网的特殊性,平台无法对用户传输的作品、信息、内容的权属或合法性、安全性、合规性、真实性、科学性、完整权、有效性等进行实质审查;无论平台是否已进行审查,用户均应自行承担因其传输的作品、信息、内容而可能或已经产生的侵权或权属纠纷等法律责任。本站所有资源不代表本站的观点或立场,基于网友分享,根据中国法律《信息网络传播权保护条例》第二十二与二十三条之规定,若资源存在侵权或相关问题请联系本站客服人员,点此联系我们。关于更多版权及免责申明参见 版权及免责申明

;
报警