反射---输入一个类,打印出类中所有元素

package com.sadhu;
import java.util.*;
import java.lang.reflect.*;
/**
反射---输入一个类,打印出类中所有元素
reflect包中有三个描述类元素的类:Field、Method、Constructor
*/
public class Sample
{
    public static void main(String[] args)
    {
        String name;//收集用户输入的类
        if(args.length > 0)
        {
            name = args[0];
        }
        else
        {
            Scanner in = new Scanner(System.in);
            System.out.println("Enter class name!");
            name = in.next();
        }
        try
        {
            Class cl = Class.forName(name);//获得用户输入类的Class类型
            Class supercl = cl.getSuperclass();//获得用户输入类的超类
            String modifiers = Modifier.toString(cl.getModifiers());//获得修饰符数值后用Modifier类解释出来。
            if(modifiers.length() > 0)
            {
                System.out.print(modifiers + " ");
            }
            System.out.print("class " + name);
            if(supercl != null)//如果想排除掉顶级根:&& supercl != Object.class
            {
                System.out.print(" extends "+supercl.getName());
            }
            System.out.print("\n{\n");
            printConstructors(cl);//获得构造函数
            System.out.println();
            printMethods(cl);//获得方法
            System.out.println();
            printFields(cl);//获得字段
            System.out.println("}");
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        System.exit(0);
    }
    public static void printConstructors(Class cl)
    {
        Constructor[] constructors = cl.getDeclaredConstructors();//获得构造函数列表
        for(Constructor c : constructors)
        {
            String name = c.getName();//获得名字
            System.out.print("  ");
            String modifiers = Modifier.toString(c.getModifiers());//获得修饰符
            if(modifiers.length() > 0)
            {
                System.out.print(modifiers+" ");
            }
            System.out.print(name+"(");
            Class[] paramTypes = c.getParameterTypes();//获得参数类型列表
            for(int j = 0;j < paramTypes.length; j++)
            {
                System.out.print(paramTypes[j].getName());
                if( j < paramTypes.length-1)
                {
                    System.out.print(", ");
                }
            }
            System.out.println(");");
        }
    }
    public static void printMethods(Class cl)
    {
        Method[] methods = cl.getDeclaredMethods();
        for(Method m : methods)
        {
            Class retType = m.getReturnType();
            String name = m.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(m.getModifiers());
            if(modifiers.length() > 0)
            {
                System.out.print(modifiers+" ");
            }
            System.out.print(retType.getName()+" "+name+"(");
            Class[] paramTypes = m.getParameterTypes();
            for(int j = 0;j < paramTypes.length; j++)
            {
                System.out.print(paramTypes[j].getName());
                if( j < paramTypes.length-1)
                {
                    System.out.print(", ");
                }
            }
            System.out.println(");");
        }
    }
    public static void printFields(Class cl)
    {
        Field[] fields = cl.getDeclaredFields();
        for(Field f:fields)
        {
            Class type = f.getType();
            String name = f.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(f.getModifiers());
            if(modifiers.length() > 0)
            {
                System.out.print(modifiers + " ");
            }
            System.out.println(type.getName()+" "+name+";");
        }
    }
}
/**
输出类似结果:
public final class java.util.Scanner extends java.lang.Object
{
  private java.util.Scanner(java.nio.file.Path, java.nio.charset.Charset);
  public java.util.Scanner(java.io.InputStream, java.lang.String);
  public java.util.Scanner(java.io.InputStream);
  public java.util.Scanner(java.nio.file.Path);
  private java.util.Scanner(java.lang.Readable, java.util.regex.Pattern);
  private java.util.Scanner(java.io.File, java.nio.charset.CharsetDecoder);
  public java.util.Scanner(java.io.File, java.lang.String);
  public java.util.Scanner(java.io.File);
  public java.util.Scanner(java.nio.file.Path, java.lang.String);
  public java.util.Scanner(java.nio.channels.ReadableByteChannel, java.lang.Stri
ng);
  public java.util.Scanner(java.lang.Readable);
  public java.util.Scanner(java.nio.channels.ReadableByteChannel);
  public java.util.Scanner(java.lang.String);

  public void remove();
  public java.lang.String toString();
  public boolean hasNext();
  public boolean hasNext(java.lang.String);
  public boolean hasNext(java.util.regex.Pattern);
  public java.lang.String next();
  public volatile java.lang.Object next();
  public java.lang.String next(java.util.regex.Pattern);
  public java.lang.String next(java.lang.String);
  public void close();
  public java.util.Scanner reset();
  public double nextDouble();
  public int nextInt(int);
  public int nextInt();
  public java.util.regex.MatchResult match();
  public java.util.Scanner skip(java.util.regex.Pattern);
  public java.util.Scanner skip(java.lang.String);
  private void ensureOpen();
  public java.util.Locale locale();
  private static java.nio.charset.Charset toCharset(java.lang.String);
  private static java.util.regex.Pattern boolPattern();
  private void buildFloatAndDecimalPattern();
  private java.lang.String buildIntegerPatternString();
  private void cacheResult();
  private void cacheResult(java.lang.String);
  private void clearCaches();
  private java.util.regex.Pattern decimalPattern();
  public java.util.regex.Pattern delimiter();
  public java.lang.String findInLine(java.util.regex.Pattern);
  public java.lang.String findInLine(java.lang.String);
  private java.lang.String findPatternInBuffer(java.util.regex.Pattern, int);
  public java.lang.String findWithinHorizon(java.util.regex.Pattern, int);
  public java.lang.String findWithinHorizon(java.lang.String, int);
  private java.util.regex.Pattern floatPattern();
  private java.lang.String getCachedResult();
  private java.lang.String getCompleteTokenInBuffer(java.util.regex.Pattern);
  public boolean hasNextBigDecimal();
  public boolean hasNextBigInteger();
  public boolean hasNextBigInteger(int);
  public boolean hasNextBoolean();
  public boolean hasNextByte(int);
  public boolean hasNextByte();
  public boolean hasNextDouble();
  public boolean hasNextFloat();
  public boolean hasNextInt(int);
  public boolean hasNextInt();
  public boolean hasNextLine();
  public boolean hasNextLong(int);
  public boolean hasNextLong();
  public boolean hasNextShort();
  public boolean hasNextShort(int);
  private boolean hasTokenInBuffer();
  private java.util.regex.Pattern integerPattern();
  public java.io.IOException ioException();
  private static java.util.regex.Pattern linePattern();
  private static java.lang.Readable makeReadable(java.nio.channels.ReadableByteC
hannel, java.nio.charset.CharsetDecoder);
  private static java.lang.Readable makeReadable(java.io.InputStream, java.nio.c
harset.Charset);
  private static java.lang.Readable makeReadable(java.nio.channels.ReadableByteC
hannel);
  private boolean makeSpace();
  private java.lang.String matchPatternInBuffer(java.util.regex.Pattern);
  public java.math.BigDecimal nextBigDecimal();
  public java.math.BigInteger nextBigInteger();
  public java.math.BigInteger nextBigInteger(int);
  public boolean nextBoolean();
  public byte nextByte();
  public byte nextByte(int);
  public float nextFloat();
  public java.lang.String nextLine();
  public long nextLong(int);
  public long nextLong();
  public short nextShort(int);
  public short nextShort();
  private java.lang.String processFloatToken(java.lang.String);
  private java.lang.String processIntegerToken(java.lang.String);
  public int radix();
  private void readInput();
  private boolean revertState(boolean);
  private void revertState();
  private void saveState();
  private static java.util.regex.Pattern separatorPattern();
  private void setRadix(int);
  private void throwFor();
  private static java.nio.charset.CharsetDecoder toDecoder(java.lang.String);
  private void translateSavedIndexes(int);
  public java.util.Scanner useDelimiter(java.lang.String);
  public java.util.Scanner useDelimiter(java.util.regex.Pattern);
  public java.util.Scanner useLocale(java.util.Locale);
  public java.util.Scanner useRadix(int);
  private void useTypeCache();

  private java.nio.CharBuffer buf;
  private static final int BUFFER_SIZE;
  private int position;
  private java.util.regex.Matcher matcher;
  private java.util.regex.Pattern delimPattern;
  private java.util.regex.Pattern hasNextPattern;
  private int hasNextPosition;
  private java.lang.String hasNextResult;
  private java.lang.Readable source;
  private boolean sourceClosed;
  private boolean needInput;
  private boolean skipped;
  private int savedScannerPosition;
  private java.lang.Object typeCache;
  private boolean matchValid;
  private boolean closed;
  private int radix;
  private int defaultRadix;
  private java.util.Locale locale;
  private sun.misc.LRUCache patternCache;
  private java.io.IOException lastException;
  private static java.util.regex.Pattern WHITESPACE_PATTERN;
  private static java.util.regex.Pattern FIND_ANY_PATTERN;
  private static java.util.regex.Pattern NON_ASCII_DIGIT;
  private java.lang.String groupSeparator;
  private java.lang.String decimalSeparator;
  private java.lang.String nanString;
  private java.lang.String infinityString;
  private java.lang.String positivePrefix;
  private java.lang.String negativePrefix;
  private java.lang.String positiveSuffix;
  private java.lang.String negativeSuffix;
  private static volatile java.util.regex.Pattern boolPattern;
  private static final java.lang.String BOOLEAN_PATTERN;
  private java.util.regex.Pattern integerPattern;
  private java.lang.String digits;
  private java.lang.String non0Digit;
  private int SIMPLE_GROUP_INDEX;
  private static volatile java.util.regex.Pattern separatorPattern;
  private static volatile java.util.regex.Pattern linePattern;
  private static final java.lang.String LINE_SEPARATOR_PATTERN;
  private static final java.lang.String LINE_PATTERN;
  private java.util.regex.Pattern floatPattern;
  private java.util.regex.Pattern decimalPattern;
  static final boolean $assertionsDisabled;
}
*/

反射---输入一个类,打印出类中所有元素

时间: 2024-09-30 21:09:24

反射---输入一个类,打印出类中所有元素的相关文章

剑指Offer(Java版)第四十题:在数组中的两个数字,如果前面一个数字大于后面的数字, 则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。 并将P对1000000007取模的结果输出。 即输出P%1000000007

/*在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对.输入一个数组,求出这个数组中的逆序对的总数P.并将P对1000000007取模的结果输出. 即输出P%1000000007 */ import java.util.*; public class Class40 { public int InversePairs(int[] array){ int length = array.length; int P = 0; for(int i = 0; i < lengt

依次将10个数输入,要求打印出其中最大的数

#include <stdio.h>void main(){ int j=0,k=0,max=0; printf("请输入十个数:\n"); scanf("%d",&j); max=j; for(;k<=9;k++) { scanf("%d",&j); if(j>max) { max=j; } } printf("十个数中最大的数是:%d\n",max); } 依次将10个数输入,要求打

根据输入的内容打印出菱形

/* 5 根据输入的内容打印出菱形 */ +(void)print:(NSInteger)count blankString:(NSString*)blankString flagString:(NSString*)flagString /* { NSMutableString * ptr = [[NSMutableString alloc]init]; for (NSInteger i = 0; i < count; i++) { for (NSInteger j = 0; j < coun

Tree Operations 打印出有向图中的环

题目: You are given a binary tree with unique integer values on each node. However, the child pointers on each node may point to any other node in the tree including itself, introducing cycles into the binary tree. A cycle is defined when you can trave

依据输入的内容打印出菱形

/* 5 依据输入的内容打印出菱形 */ +(void)print:(NSInteger)count blankString:(NSString*)blankString flagString:(NSString*)flagString /* { NSMutableString * ptr = [[NSMutableString alloc]init]; for (NSInteger i = 0; i < count; i++) { for (NSInteger j = 0; j < coun

1142: 零起点学算法49——找出数组中最大元素的位置(下标值)

1142: 零起点学算法49--找出数组中最大元素的位置(下标值) Time Limit: 1 Sec  Memory Limit: 64 MB   64bit IO Format: %lldSubmitted: 1937  Accepted: 977[Submit][Status][Web Board] Description 找出数组中最大的元素的下标. Input 多组测试,每组先输入一个不大于10的整数n 然后是n个整数 Output 输出这n个整数中最大的元素及下标值 Sample I

编程之美 - 写一个函数,返回数组中所有元素被第一个元素除的结果

问题: 写一个函数,返回数组中所有元素被第一个元素除的结果,包含第一个元素,也要自己除自己 分析: 主要注意两点:1,判断输入是否合法:2,判断除数是否为0:3,从后往前除(真猥琐) 代码实现: 1 /* div_array.cc 2 * 2014/09/03 create 3 * 写一个函数,返回数组中所有元素被第一个元素除的结果,包含第一个元素,也要自己除自己 4 */ 5 #include <iostream> 6 using namespace std; 7 8 void div_ar

删除数组元素 功能描述:有一个有序整数数组,要求输入一个数字, 在数组中查找是否有这个数,如果有,将该数从数组中删除, 要求删除后的数组仍然保持有序;

public static void main(String[] args) { int[] a={23,34,56,7,8,9}; int[] b = new int[a.length]; Scanner scan = new Scanner(System.in); System.out.println("请输入一个整数:"); int num = scan.nextInt(); boolean flag = true; int i = 0; for( ; i < a.leng

2016.06.06 周一 C语言 将字符串根据字符的ASCII码从大到小排序并打印出字符串中的字符类型的总数

第一次变量冲突问题 解决了一个多小时,.... 代码如下: ↓ #include<stdio.h> #include<string.h> #define N 200 //输入字符串的最大长度 int main() { //************************输入开始部分******************************** printf("请输入字符串.(长度在200以内)\n\n"); int i=0,j,k,temp,lowLetter