public class CrazyitObjectFactory {
    public static Object getInstance(String clsName) {
        try {
            // 创建指定类对应的Class对象
            Class cls = Class.forName(clsName);
            // 返回使用该Class对象所创建的实例
            return cls.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

//获取实例后需要强制类型转换
Date d =(Date) CrazyitObjectFactory.getInstance("java.util.Date");

JFrame f=(JFrame )CrazyitObjectFactory.getInstance("java.util.Date");

import java.util.*;
import javax.swing.*;

public class CrazyitObjectFactory2 {
    public static <T> T getInstance(Class<T> cls) {
        try {
            return cls.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        // 获取实例后无须类型转换
        Date d = CrazyitObjectFactory2.getInstance(Date.class);
        JFrame f = CrazyitObjectFactory2.getInstance(JFrame.class);
    }
}

//使用 Array的 newInstance方法来创建一个数组
Object arr = Array.newInstance(String.class, 10);

static Object newInstance(Class<?> componentType, int length)

public static <T> T[] newInstance(Class<T> componentType, int length);

import java.lang.reflect.*;

public class CrazyitArray {
    // 对Array的newInstance方法进行包装
    @SuppressWarnings("unchecked")
    public static <T> T[] newInstance(Class<T> componentType, int length) {
        return (T[]) Array.newInstance(componentType, length); // ①
    }

    public static void main(String[] args) {
        // 使用CrazyitArray的newInstance()创建一维数组
        String[] arr = CrazyitArray.newInstance(String.class, 10);
        // 使用CrazyitArray的newInstance()创建二维数组
        // 在这种情况下，只要设置数组元素的类型是int[]即可。
        int[][] intArr = CrazyitArray.newInstance(int[].class, 5);
        arr[5] = "HelloWorld";
        // intArr是二维数组，初始化该数组的第二个数组元素
        // 二维数组的元素必须是一维数组
        intArr[1] = new int[] { 23, 12 };
        System.out.println(arr[5]);
        System.out.println(intArr[1][1]);
    }
}

//获取成员变量field的类型
Class<?> a =field.getType();

//获得成员变量field的泛型类型
Type gType =field.getGenericType();

import java.util.*;
import java.lang.reflect.*;

public class GenericTest {
    private Map<String, Integer> score;

    public static void main(String[] args) throws Exception {
        Class<GenericTest> clazz = GenericTest.class;
        Field f = clazz.getDeclaredField("score");
        // 直接使用getType()取出的类型只对普通类型的成员变量有效
        Class<?> a = f.getType();
        // 下面将看到仅输出java.util.Map
        System.out.println("score的类型是:" + a);
        // 获得成员变量f的泛型类型
        Type gType = f.getGenericType();
        // 如果gType类型是ParameterizedType对象
        if (gType instanceof ParameterizedType) {
            // 强制类型转换
            ParameterizedType pType = (ParameterizedType) gType;
            // 获取原始类型
            Type rType = pType.getRawType();
            System.out.println("原始类型是：" + rType);
            // 取得泛型类型的泛型参数
            Type[] tArgs = pType.getActualTypeArguments();
            System.out.println("泛型信息是:");
            for (int i = 0; i < tArgs.length; i++) {
                System.out.println("第" + i + "个泛型类型是：" + tArgs[i]);
            }
        } else {
            System.out.println("获取泛型类型出错！");
        }
    }
}

public interface Dog
{
    // info方法声明
    void info();
    // run方法声明
    void run();
}

public class GunDog implements Dog
{
    // 实现info()方法，仅仅打印一个字符串
    public void info()
    {
        System.out.println("我是一只猎狗");
    }
    // 实现run()方法，仅仅打印一个字符串
    public void run()
    {
        System.out.println("我奔跑迅速");
    }
}

public class DogUtil
{
    // 第一个拦截器方法
    public void method1()
    {
        System.out.println("=====模拟第一个通用方法=====");
    }
    // 第二个拦截器方法
    public void method2()
    {
        System.out.println("=====模拟通用方法二=====");
    }
}

import java.lang.reflect.*;

public class MyInvokationHandler implements InvocationHandler
{
    // 需要被代理的对象
    private Object target;
    public void setTarget(Object target)
    {
        this.target = target;
    }
    // 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Exception
    {
        DogUtil du = new DogUtil();
        // 执行DogUtil对象中的method1。
        du.method1();
        // 以target作为主调来执行method方法
        Object result = method.invoke(target , args);//关键代码
        // 执行DogUtil对象中的method2。
        du.method2();
        return result;
    }
}

import java.lang.reflect.*;

public class MyProxyFactory
{
    // 为指定target生成动态代理对象
    public static Object getProxy(Object target)
        throws Exception
        {
        // 创建一个MyInvokationHandler对象
        MyInvokationHandler handler =new MyInvokationHandler();
        // 为MyInvokationHandler设置target对象
        handler.setTarget(target);
        // 创建、并返回一个动态代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader()
            , target.getClass().getInterfaces() , handler);
    }
}

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        // 创建一个原始的GunDog对象，作为target
        Dog target = new GunDog();
        // 以指定的target来创建动态代理
        Dog dog = (Dog)MyProxyFactory.getProxy(target);
        dog.info();
        dog.run();
    }
}

// 创建一个InvocationHandler对象
InvocationHandler handler = new MyInvokationHandler();
// 使用指定的InvocationHandler来生成一个动态代理对象
Person p = (Person)Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class}, handler);

import java.lang.reflect.*;

interface Person
{
    void walk();
    void sayHello(String name);
}
class MyInvokationHandler implements InvocationHandler
{
    /*
    执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
    其中：
    ：代表动态代理对象
    method：代表正在执行的方法
    args：代表调用目标方法时传入的实参。
    */
    public Object invoke(Object proxy, Method method, Object[] args)
    {
        System.out.println("----正在执行的方法:" + method);
        if (args != null)
        {
            System.out.println("下面是执行该方法时传入的实参为：");
            for (Object val : args)
            {
                System.out.println(val);
            }
        }
        else
        {
            System.out.println("调用该方法没有实参！");
        }
        return null;
    }
}
public class ProxyTest
{
    public static void main(String[] args)
        throws Exception
    {
        // 创建一个InvocationHandler对象
        InvocationHandler handler = new MyInvokationHandler();
        // 使用指定的InvocationHandler来生成一个动态代理对象
        Person p = (Person)Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class}, handler);
        // 调用动态代理对象的walk()和sayHello()方法
        p.walk();
        p.sayHello("孙悟空");
    }
}

import java.lang.reflect.*;
class Person
{
    //私有的成员变量
    private String name;
    //私有的成员变量
    private int age;
    public String toString()
    {
        return "Person[name:" + name +
        " , age:" + age + " ]";
    }
}
public class FieldTest
{
    public static void main(String[] args)
        throws Exception
    {
        // 创建一个Person对象
        Person p = new Person();
        // 获取Person类对应的Class对象
        Class<Person> personClazz = Person.class;
        // 获取Person的名为name的成员变量
        // 使用getDeclaredField()方法表明可获取各种访问控制符的成员变量
        Field nameField = personClazz.getDeclaredField("name");
        // 设置通过反射访问 name 成员变量时 取消访问权限检查
        nameField.setAccessible(true);
        // 调用set()方法为p对象的name成员变量设置值
        nameField.set(p , "小明");

        // 获取Person类名为age的成员变量
        Field ageField = personClazz.getDeclaredField("age");
        // 通过反射访问 age 成员变量时 取消访问权限检查
        // (要在getter和setter方法之前设置)
        ageField.setAccessible(true);
        // 调用setInt()方法为p对象的age成员变量设置值
        ageField.setInt(p , 30);
        // 获取p对象的age成员变量的值
        System.out.println("p对象的age成员变量的值:"+ageField.getInt(p));
        System.out.println(p);
    }
}

import java.lang.reflect.*;

public class ArrayTest1
{
    public static void main(String args[])
    {
        try
        {
            // 创建一个元素类型为String ，长度为10的数组
            Object arr = Array.newInstance(String.class, 10);
            // 依次为arr数组中index为5、6的元素赋值
            Array.set(arr, 5, "这是一个字符串");
            Array.set(arr, 6, "这还是一个字符串");
            // 依次取出arr数组中index为5、6的元素的值
            Object book1 = Array.get(arr , 5);
            Object book2 = Array.get(arr , 6);
            // 输出arr数组中index为5、6的元素
            System.out.println(book1);
            System.out.println(book2);
        }
        catch (Throwable e)
        {
            System.err.println(e);
        }
    }
}

import java.lang.reflect.*;

public class ArrayTest2
{
    public static void main(String args[])
    {
        /*
          创建一个三维数组。
          根据前面介绍数组时讲的：三维数组也是一维数组，
          是数组元素是二维数组的一维数组，
          因此可以认为arr是长度为3的一维数组
        */
        Object arr = Array.newInstance(String.class, 3, 4, 10);//代码段1
        // 获取三维数组arr中index为2的元素，该元素应该是二维数组
        Object arrObj = Array.get(arr, 2);
        // 使用Array为二维数组的数组元素赋值。二维数组的数组元素是一维数组，
        // 所以传入Array的set()方法的第三个参数是一维数组。
             // 代码段2
        Array.set(arrObj , 2 , new String[]
        {
            "这是一个字符串",
            "这又是一个字符串"
        });

        // 获取二维数组arrObj中index为3的元素，该元素应该是一维数组。
        Object anArr  = Array.get(arrObj, 3);
        Array.set(anArr , 8  , "这还是一个字符串");
        // 将arr强制类型转换为三维数组
        String[][][] cast = (String[][][])arr;
        // 获取cast三维数组中指定元素的值
        System.out.println(cast[2][3][8]);
        System.out.println(cast[2][2][0]);
        System.out.println(cast[2][2][1]);
    }
}

import java.lang.reflect.*;
import java.util.*;

class Test
{
    public void replace(String str, List<String> list){}
}
public class MethodParameterTest
{
    public static void main(String[] args)throws Exception
    {
        // 获取String的类
        Class<Test> clazz = Test.class;
        // 获取String类的带两个参数的replace()方法
        Method replace = clazz.getMethod("replace"
            , String.class, List.class);
        // 获取指定方法的参数个数
        System.out.println("replace方法参数个数：" + replace.getParameterCount());
        // 获取replace的所有参数信息
        Parameter[] parameters = replace.getParameters();
        int index = 1;
        // 遍历所有参数
        for (Parameter p : parameters)
        {
            if (p.isNamePresent())
            {
                System.out.println("---第" + index++ + "个参数信息---");
                System.out.println("参数名：" + p.getName());
                System.out.println("形参类型：" + p.getType());
                System.out.println("泛型类型：" + p.getParameterizedType());
            }
        }
    }
}

//获取选中节点所在的 Treepath
TreePath path = tree.getselectionPath();
//获取指定 Treepath的最后一个节点
TreeNode target = (TreeNode) path.getLastPathcomponent();

//获取选中的节点
TreeNode target =(TreeNode) tree.getLastselectedPathComponent();

//将一个节点数组转换成 Treepath对象
TreePath tp = new TreePath(nodes);

import java.awt.BorderLayout;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;

public class EditJTree {
    JFrame jf;
    JTree tree;
    // 上面JTree对象对应的model
    DefaultTreeModel model;
    // 定义几个初始节点
    DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
    DefaultMutableTreeNode guangdong = new DefaultMutableTreeNode("广东");
    DefaultMutableTreeNode guangxi = new DefaultMutableTreeNode("广西");
    DefaultMutableTreeNode foshan = new DefaultMutableTreeNode("佛山");
    DefaultMutableTreeNode shantou = new DefaultMutableTreeNode("汕头");
    DefaultMutableTreeNode guilin = new DefaultMutableTreeNode("桂林");
    DefaultMutableTreeNode nanning = new DefaultMutableTreeNode("南宁");
    // 定义需要被拖动的TreePath
    TreePath movePath;
    JButton addSiblingButton = new JButton("添加兄弟节点");
    JButton addChildButton = new JButton("添加子节点");
    JButton deleteButton = new JButton("删除节点");
    JButton editButton = new JButton("编辑当前节点");

    public void init() {
        guangdong.add(foshan);
        guangdong.add(shantou);
        guangxi.add(guilin);
        guangxi.add(nanning);
        root.add(guangdong);
        root.add(guangxi);
        jf = new JFrame("可编辑节点的树");
        tree = new JTree(root);
        // 获取JTree对应的TreeModel对象
        model = (DefaultTreeModel) tree.getModel();
        // 设置JTree可编辑
        tree.setEditable(true);
        MouseListener ml = new MouseAdapter() {
            // 按下鼠标时获得被拖动的节点
            public void mousePressed(MouseEvent e) {
                // 如果需要唯一确定某个节点，必须通过TreePath来获取。
                TreePath tp = tree.getPathForLocation(e.getX(), e.getY());
                if (tp != null) {
                    movePath = tp;
                }
            }

            // 鼠标松开时获得需要拖到哪个父节点
            public void mouseReleased(MouseEvent e) {
                // 根据鼠标松开时的TreePath来获取TreePath
                TreePath tp = tree.getPathForLocation(e.getX(), e.getY());
                if (tp != null && movePath != null) {
                    // 阻止向子节点拖动
                    if (movePath.isDescendant(tp) && movePath != tp) {
                        JOptionPane.showMessageDialog(jf, "目标节点是被移动节点的子节点，无法移动！", "非法操作", JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    // 既不是向子节点移动，而且鼠标按下、松开的不是同一个节点
                    else if (movePath != tp) {
                        // add方法先将该节点从原父节下删除，再添加到新父节点下
                        ((DefaultMutableTreeNode) tp.getLastPathComponent())
                                .add((DefaultMutableTreeNode) movePath.getLastPathComponent());
                        movePath = null;
                        tree.updateUI();
                    }
                }
            }
        };
        // 为JTree添加鼠标监听器
        tree.addMouseListener(ml);
        JPanel panel = new JPanel();
        // 实现添加兄弟节点的监听器
        addSiblingButton.addActionListener(event -> {
            // 获取选中节点
            DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
            // 如果节点为空，直接返回
            if (selectedNode == null)
                return;
            // 获取该选中节点的父节点
            DefaultMutableTreeNode parent = (DefaultMutableTreeNode) selectedNode.getParent();
            // 如果父节点为空，直接返回
            if (parent == null)
                return;
            // 创建一个新节点
            DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新节点");
            // 获取选中节点的选中索引
            int selectedIndex = parent.getIndex(selectedNode);
            // 在选中位置插入新节点
            model.insertNodeInto(newNode, parent, selectedIndex + 1);
            // --------下面代码实现显示新节点（自动展开父节点）-------
            // 获取从根节点到新节点的所有节点
            TreeNode[] nodes = model.getPathToRoot(newNode);
            // 使用指定的节点数组来创建TreePath
            TreePath path = new TreePath(nodes);
            // 显示指定TreePath
            tree.scrollPathToVisible(path);
        });
        panel.add(addSiblingButton);
        // 实现添加子节点的监听器
        addChildButton.addActionListener(event -> {
            // 获取选中节点
            DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
            // 如果节点为空，直接返回
            if (selectedNode == null)
                return;
            // 创建一个新节点
            DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新节点");
            // 通过model来添加新节点，则无须通过调用JTree的updateUI方法
            // model.insertNodeInto(newNode, selectedNode
            // , selectedNode.getChildCount());
            // 通过节点添加新节点，则需要调用tree的updateUI方法
            selectedNode.add(newNode);
            // --------下面代码实现显示新节点（自动展开父节点）-------
            TreeNode[] nodes = model.getPathToRoot(newNode);
            TreePath path = new TreePath(nodes);
            tree.scrollPathToVisible(path);
            tree.updateUI();
        });
        panel.add(addChildButton);
        // 实现删除节点的监听器
        deleteButton.addActionListener(event -> {
            DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
            if (selectedNode != null && selectedNode.getParent() != null) {
                // 删除指定节点
                model.removeNodeFromParent(selectedNode);
            }
        });
        panel.add(deleteButton);
        // 实现编辑节点的监听器
        editButton.addActionListener(event -> {
            TreePath selectedPath = tree.getSelectionPath();
            if (selectedPath != null) {
                // 编辑选中节点
                tree.startEditingAtPath(selectedPath);
            }
        });
        panel.add(editButton);
        jf.add(new JScrollPane(tree));
        jf.add(panel, BorderLayout.SOUTH);
        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }

    public static void main(String[] args) {
        new EditJTree().init();
    }
}

import javax.swing.*;
import javax.swing.tree.*;

public class SimpleJTree {
    JFrame jf = new JFrame("简单树");
    JTree tree;
    DefaultMutableTreeNode root;
    DefaultMutableTreeNode guangdong;
    DefaultMutableTreeNode guangxi;
    DefaultMutableTreeNode foshan;
    DefaultMutableTreeNode shantou;
    DefaultMutableTreeNode guilin;
    DefaultMutableTreeNode nanning;

    public void init() {
        // 依次创建树中所有节点
        root = new DefaultMutableTreeNode("中国");
        guangdong = new DefaultMutableTreeNode("广东");
        guangxi = new DefaultMutableTreeNode("广西");
        foshan = new DefaultMutableTreeNode("佛山");
        shantou = new DefaultMutableTreeNode("汕头");
        guilin = new DefaultMutableTreeNode("桂林");
        nanning = new DefaultMutableTreeNode("南宁");
        // 通过add()方法建立树节点之间的父子关系
        guangdong.add(foshan);
        guangdong.add(shantou);
        guangxi.add(guilin);
        guangxi.add(nanning);
        root.add(guangdong);
        root.add(guangxi);
        // 以根节点创建树
        tree = new JTree(root); // ①
        jf.add(new JScrollPane(tree));
        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }

    public static void main(String[] args) {
        new SimpleJTree().init();
    }
}

//没有连接线
tree.putClientProperty("JTree.lineStyle","None");

//设置是否显示根节点的“展开、折叠”图标，默认是fase
tree.setShowsRootHandles(true);

//设置根节点是否可见，默认是true
tree.setRootvisible(false);