Рефлексия

import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.LinkedList;
import java.util.List;
 
/**
 * Created by Yoghurt_92 on 03.11.14.
 */
 
 
public class Test {
 
    public static void writeToFile(List<String> list, String file) {
 
        try(FileWriter fileWriter = new FileWriter(file + ".java")) {
 
            list.forEach(value -> {
                try {
                    fileWriter.write(value + "\r\n");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
 
        } catch(IOException exc) { exc.printStackTrace(); }
    }
 
    public static void nameClass(List<String> list, Class c) {
 
        String name = "";
 
        int mods = c.getModifiers();
        if (Modifier.isPublic(mods)) {
            name += "public ";
        }
        if (Modifier.isAbstract(mods)) {
            name += "abstract ";
        }
        if (Modifier.isFinal(mods)) {
            name += "final ";
        }
 
        name += c.getSimpleName();
 
        String superName;
        if ((superName = c.getSuperclass().getSimpleName()) != null)
            name += (" extends " + superName);
 
        Class[] interfaces = c.getInterfaces();
        if (interfaces != null) {
            name += " implements ";
 
            for (int i = 0; i < interfaces.length; ++i) {
                name += interfaces[i].getSimpleName();
                if (i < interfaces.length - 2) name += ", ";
                else if (i != interfaces.length - 1) name += " ";
            }
        }
 
        list.add(name);
        list.add("\n");
    }
 
    public static void fieldsClass(List<String> list, Class c) {
 
        Field[] publicFields = c.getFields();
        for (Field field : publicFields) {
            Class fieldType = field.getType();
            list.add(fieldType.getSimpleName() + " " + field.getName());
        }
 
        list.add("\n");
    }
 
    public static void constructorsClass(List<String> list, Class c) {
 
        Constructor[] constructors = c.getConstructors();
        for (Constructor constructor : constructors) {
 
            String value = "";
            int _mods = constructor.getModifiers();
            if (Modifier.isPublic(_mods)) {
                value += "public ";
            }
            else if (Modifier.isPrivate(_mods)) {
                value+= "private ";
            }
 
            value += (c.getSimpleName() + "(");
            Class[] paramTypes = constructor.getParameterTypes();
            for (int i = 0; i < paramTypes.length; ++i) {
                value += paramTypes[i].getSimpleName();
                if (i < paramTypes.length - 2) value+= ", ";
                else if (i != paramTypes.length - 1) value += " ";
            }
            value+= ")";
            list.add(value);
        }
 
        list.add("\n");
    }
 
    public static void methodsClass(List<String> list, Class c) {
        Method[] methods = c.getMethods();
        for (Method method : methods) {
 
            String value = "";
            int mods = method.getModifiers();
            if (Modifier.isPublic(mods)) {
                value += "public ";
            }
            if (Modifier.isAbstract(mods)) {
                value += "abstract ";
            }
            if (Modifier.isFinal(mods)) {
                value += "final ";
            }
            if (Modifier.isStatic(mods)) {
                value += "static ";
            }
 
            value += method.getReturnType().getSimpleName();
            value += (" " + method.getName());
 
            Class[] paramTypes = method.getParameterTypes();
            value += "(";
            for (int i = 0; i < paramTypes.length; ++i) {
                value += paramTypes[i].getSimpleName();
                if (i < paramTypes.length - 2) value += ", ";
                else if (i != paramTypes.length - 1) value += " ";
            }
            value += ")";
            list.add(value);
        }
    }
 
    public static void main(String... args) {
 
        Class c = Integer.class;
        List<String> list = new LinkedList<>();
 
        nameClass(list, c);
        fieldsClass(list, c);
        constructorsClass(list, c);
        methodsClass(list, c);
        writeToFile(list, c.getSimpleName());
    }
}

public interface ListInterface {
 
int hashCode();
 
boolean equals(Object x1);
 
void add(int x1, Object x2);
 
boolean add(Object x1);
 
boolean contains(Object x1);
 
Object get(int x1);
 
int indexOf(Object x1);
 
boolean isEmpty();
 
int lastIndexOf(Object x1);
 
int size();
 
List subList(int x1, int x2);
 
Object[] toArray();
 
Object[] toArray(Object[] x1);
 
boolean addAll(int x1, Collection x2);
 
boolean addAll(Collection x1);
 
Iterator iterator();
 
Object remove(int x1);
 
boolean remove(Object x1);
 
void clear();
 
Object set(int x1, Object x2);
 
boolean containsAll(Collection x1);
 
ListIterator listIterator();
 
ListIterator listIterator(int x1);
 
boolean removeAll(Collection x1);
 
boolean retainAll(Collection x1);
 
}