import java.awt.*;
import javax.swing.*;

public class SwingDndSupport {
    JFrame jf = new JFrame("Swing的拖放支持");
    JTextArea srcTxt = new JTextArea(8, 30);
    JTextField jtf = new JTextField(34);

    public void init() {
        srcTxt.append("Swing的拖放支持.\n");
        srcTxt.append("将该文本域的内容拖入其他程序.\n");
        // 启动文本域和单行文本框的拖放支持
        srcTxt.setDragEnabled(true);
        jtf.setDragEnabled(true);
        jf.add(new JScrollPane(srcTxt));
        jf.add(jtf, BorderLayout.SOUTH);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }

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

srcTxt.setDragEnabled(true);
jtf.setDragEnabled(true);

//允许直接将一个co1or对象拖入该 jTextArea对象，并赋给它的 foreground属性
jTextArea.setTransferHandler(new TransferHandler("foreground"));

import java.awt.*;
import javax.swing.*;

public class TransferHandlerTest {
    private JFrame jf = new JFrame("测试TransferHandler");
    JColorChooser chooser = new JColorChooser();
    JTextArea txt = new JTextArea("测试TransferHandler\n" + "直接将上面颜色拖入以改变文本颜色");

    public void init() {
        // 启动颜色选择器面板和文本域的拖放功能
        chooser.setDragEnabled(true);
        txt.setDragEnabled(true);
        jf.add(chooser, BorderLayout.SOUTH);
        // 允许直接将一个Color对象拖入该JTextArea对象
        // 并赋给它的foreground属性
        txt.setTransferHandler(new TransferHandler("foreground"));
        jf.add(new JScrollPane(txt));
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }

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

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

// 定义可重复注解
@Repeatable(Annos.class)
@interface Anno {}
@Retention(value=RetentionPolicy.RUNTIME)
@interface Annos {
    Anno[] value();
}
// 使用4个注解修饰该类
@SuppressWarnings(value="unchecked")
@Deprecated
// 使用重复注解修饰该类
@Anno
@Anno
public class ClassTest
{
    // 为该类定义一个私有的构造器
    private ClassTest()
    {
    }
    // 定义一个有参数的构造器
    public ClassTest(String name)
    {
        System.out.println("执行有参数的构造器");
    }
    // 定义一个无参数的info方法
    public void info()
    {
        System.out.println("执行无参数的info方法");
    }
    // 定义一个有参数的info方法
    public void info(String str)
    {
        System.out.println("执行有参数的info方法"
            + "，其str参数值：" + str);
    }
    // 定义一个测试用的内部类
    class Inner
    {
    }
    public static void main(String[] args)
        throws Exception
    {
        // 下面代码可以获取ClassTest对应的Class
        // 获取该Class对象所对应类的全部构造器
        Class<ClassTest> clazz = ClassTest.class;
        Constructor[] ctors = clazz.getDeclaredConstructors();
        System.out.println("ClassTest的全部构造器如下：");
        for (Constructor c : ctors)
        {
            System.out.println(c);
        }
        // 获取该Class对象所对应类的全部public构造器
        Constructor[] publicCtors = clazz.getConstructors();
        System.out.println("ClassTest的全部public构造器如下：");
        for (Constructor c : publicCtors)
        {
            System.out.println(c);
        }
        // 获取该Class对象所对应类的全部public方法
        Method[] mtds = clazz.getMethods();
        System.out.println("ClassTest的全部public方法如下：");
        for (Method md : mtds)
        {
            System.out.println(md);
        }
        // 获取该Class对象所对应类的指定方法
        System.out.println("ClassTest里带一个字符串参数的info()方法为："
            // 获取该Class对象所对应类的上的全部注解
            + clazz.getMethod("info" , String.class));
        Annotation[] anns = clazz.getAnnotations();
        System.out.println("ClassTest的全部Annotation如下：");
        for (Annotation an : anns)
        {
            System.out.println(an);
        }
        System.out.println("该Class元素上的@SuppressWarnings注解为："
            + Arrays.toString(clazz.getAnnotationsByType(SuppressWarnings.class)));
        System.out.println("该Class元素上的@Anno注解为："
            // 获取该Class对象所对应类的全部内部类
            + Arrays.toString(clazz.getAnnotationsByType(Anno.class)));
        Class<?>[] inners = clazz.getDeclaredClasses();
        System.out.println("ClassTest的全部内部类如下：");
        for (Class c : inners)
        {
            System.out.println(c);
        }
        // 使用Class.forName方法加载ClassTest的Inner内部类
        // 通过getDeclaringClass()访问该类所在的外部类
        Class inClazz = Class.forName("ClassTest$Inner");
        System.out.println("inClazz对应类的外部类为：" +
            inClazz.getDeclaringClass());
        System.out.println("ClassTest的包为：" + clazz.getPackage());
        System.out.println("ClassTest的父类为：" + clazz.getSuperclass());
    }
}

import java.sql.*;
import java.util.*;
import java.net.*;

public class URLClassLoaderTest
{
    private static Connection conn;
    // 定义一个获取数据库连接方法
    public static Connection getConn(String url ,
        String user , String pass) throws Exception
    {
        if (conn == null)
        {
            // 创建一个URL数组
            URL[] urls = {new URL(
                "file:mysql-connector-java-5.1.30-bin.jar")};
            // 以默认的ClassLoader作为父ClassLoader，创建URLClassLoader
            URLClassLoader myClassLoader = new URLClassLoader(urls);
            // 加载MySQL的JDBC驱动，并创建默认实例
            Driver driver = (Driver)myClassLoader.
                loadClass("com.mysql.jdbc.Driver").newInstance();
            // 创建一个设置JDBC连接属性的Properties对象
            Properties props = new Properties();
            // 至少需要为该对象传入user和password两个属性
            props.setProperty("user" , user);
            props.setProperty("password" , pass);
            // 调用Driver对象的connect方法来取得数据库连接
            conn = driver.connect(url , props);
        }
        return conn;
    }
    public static void main(String[] args)throws Exception
    {
        System.out.println(getConn("jdbc:mysql://localhost:3306/mysql"
            , "root" , "root"));
    }
}

import java.io.*;
import java.lang.reflect.*;

public class CompileClassLoader extends ClassLoader
{
    // 读取一个文件的内容
    private byte[] getBytes(String filename)
        throws IOException
    {
        File file = new File(filename);
        long len = file.length();
        byte[] raw = new byte[(int)len];
        try(
            FileInputStream fin = new FileInputStream(file))
        {
            // 一次读取class文件的全部二进制数据
            int r = fin.read(raw);
            if(r != len)
            throw new IOException("无法读取全部文件："
                + r + " != " + len);
            return raw;
        }
    }
    // 定义编译指定Java文件的方法
    private boolean compile(String javaFile)
        throws IOException
    {
        System.out.println("CompileClassLoader:正在编译 "
            + javaFile + "...");
        // 调用系统的javac命令
        Process p = Runtime.getRuntime().exec("javac " + javaFile);
        try
        {
            // 其他线程都等待这个线程完成
            p.waitFor();
        }
        catch(InterruptedException ie)
        {
            System.out.println(ie);
        }
        // 获取javac线程的退出值
        int ret = p.exitValue();
        // 返回编译是否成功
        return ret == 0;
    }
    // 重写ClassLoader的findClass方法
    protected Class<?> findClass(String name)
        throws ClassNotFoundException
    {
        Class clazz = null;
        // 将包路径中的点（.）替换成斜线（/）。
        String fileStub = name.replace("." , "/");
        String javaFilename = fileStub + ".java";
        String classFilename = fileStub + ".class";
        File javaFile = new File(javaFilename);
        File classFile = new File(classFilename);
        // 当指定Java源文件存在，且class文件不存在、或者Java源文件
        // 的修改时间比class文件修改时间更晚，重新编译
        if(javaFile.exists() && (!classFile.exists()
            || javaFile.lastModified() > classFile.lastModified()))
        {
            try
            {
                // 如果编译失败，或者该Class文件不存在
                if(!compile(javaFilename) || !classFile.exists())
                {
                    throw new ClassNotFoundException(
                        "ClassNotFoundExcetpion:" + javaFilename);
                }
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
        // 如果class文件存在，系统负责将该文件转换成Class对象
        if (classFile.exists())
        {
            try
            {
                // 将class文件的二进制数据读入数组
                byte[] raw = getBytes(classFilename);
                // 调用ClassLoader的defineClass方法将二进制数据转换成Class对象
                clazz = defineClass(name,raw,0,raw.length);
            }
            catch(IOException ie)
            {
                ie.printStackTrace();
            }
        }
        // 如果clazz为null，表明加载失败，则抛出异常
        if(clazz == null)
        {
            throw new ClassNotFoundException(name);
        }
        return clazz;
    }
    // 定义一个主方法
    public static void main(String[] args) throws Exception
    {
        // 如果运行该程序时没有参数，即没有目标类
        if (args.length < 1)
        {
            System.out.println("缺少目标类，请按如下格式运行Java源文件：");
            System.out.println("java CompileClassLoader ClassName");
        }
        // 第一个参数是需要运行的类
        String progClass = args[0];
        // 剩下的参数将作为运行目标类时的参数，
        // 将这些参数复制到一个新数组中
        String[] progArgs = new String[args.length-1];
        System.arraycopy(args , 1 , progArgs
            , 0 , progArgs.length);
        CompileClassLoader ccl = new CompileClassLoader();
        // 加载需要运行的类
        Class<?> clazz = ccl.loadClass(progClass);
        // 获取需要运行的类的主方法
        Method main = clazz.getMethod("main" , (new String[0]).getClass());
        Object[] argsArray = {progArgs};
        main.invoke(null,argsArray);
    }
}

public class Hello
{
    public static void main(String[] args)
    {
        for (String arg : args)
        {
            System.out.println("运行Hello的参数：" + arg);
        }
    }
}

import java.util.*;
import java.net.*;
import java.io.*;

public class ClassLoaderPropTest {
    public static void main(String[] args) throws IOException {
        // 获取系统类加载器
        ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器：" + systemLoader);
        /*
         * 获取系统类加载器的加载路径——通常由CLASSPATH环境变量指定 如果操作系统没有指定CLASSPATH环境变量，默认以当前路径作为
         * 系统类加载器的加载路径
         */
        Enumeration<URL> em1 = systemLoader.getResources("");
        while (em1.hasMoreElements()) {
            System.out.println(em1.nextElement());
        }
        // 获取系统类加载器的父类加载器：得到扩展类加载器
        ClassLoader extensionLader = systemLoader.getParent();
        System.out.println("扩展类加载器：" + extensionLader);
        System.out.println("扩展类加载器的加载路径：" + System.getProperty("java.ext.dirs"));
        System.out.println("扩展类加载器的parent: " + extensionLader.getParent());
    }
}

import java.net.*;

public class BootstrapTest
{
    public static void main(String[] args)
    {
        // 获取根类加载器所加载的全部URL数组
        URL[] urls = sun.misc.Launcher.
        getBootstrapClassPath().getURLs();
        // 遍历、输出根类加载器加载的全部URL
        for (int i = 0; i < urls.length; i++)
        {
            System.out.println(urls[i].toExternalForm());
        }
    }
}

import java.awt.*;
import javax.swing.*;

public class JLayeredPaneTest {
    JFrame jf = new JFrame("测试JLayeredPane");
    JLayeredPane layeredPane = new JLayeredPane();

    public void init() {
        // 向layeredPane中添加3个组件
        layeredPane.add(new ContentPanel(10, 20, "疯狂Java讲义", "ico/java.png"), JLayeredPane.MODAL_LAYER);
        layeredPane.add(new ContentPanel(100, 60, "疯狂Android讲义", "ico/android.png"), JLayeredPane.DEFAULT_LAYER);
        layeredPane.add(new ContentPanel(190, 100, "轻量级Java EE企业应用实战", "ico/ee.png"), 4);
        layeredPane.setPreferredSize(new Dimension(400, 300));
        layeredPane.setVisible(true);
        jf.add(layeredPane);
        jf.pack();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }

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

// 扩展了JPanel类，可以直接创建一个放在指定位置，
// 且有指定标题、放置指定图标的JPanel对象
class ContentPanel extends JPanel {
    private static final long serialVersionUID = 4535201982849108665L;

    public ContentPanel(int xPos, int yPos, String title, String ico) {
        setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
        JLabel label = new JLabel(new ImageIcon(ico));
        add(label);
        setBounds(xPos, yPos, 160, 220); // ①    
    }
}

import java.beans.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class JInternalFrameTest {
    final int DESKTOP_WIDTH = 480;
    final int DESKTOP_HEIGHT = 360;
    final int FRAME_DISTANCE = 30;
    JFrame jf = new JFrame("MDI界面");
    // 定义一个虚拟桌面
    private MyJDesktopPane desktop = new MyJDesktopPane();
    // 保存下一个内部窗口的坐标点
    private int nextFrameX;
    private int nextFrameY;
    // 定义内部窗口为虚拟桌面的1/2大小
    private int width = DESKTOP_WIDTH / 2;
    private int height = DESKTOP_HEIGHT / 2;
    // 为主窗口定义两个菜单
    JMenu fileMenu = new JMenu("文件");
    JMenu windowMenu = new JMenu("窗口");
    // 定义newAction用于创建菜单和工具按钮
    Action newAction = new AbstractAction("新建", new ImageIcon("ico/new.png")) {
        private static final long serialVersionUID = 7504047155791213931L;

        public void actionPerformed(ActionEvent event) {
            // 创建内部窗口
            final JInternalFrame iframe = new JInternalFrame("新文档", true, // 可改变大小
                    true, // 可关闭
                    true, // 可最大化
                    true); // 可最小化
            iframe.add(new JScrollPane(new JTextArea(8, 40)));
            // 将内部窗口添加到虚拟桌面中
            desktop.add(iframe);
            // 设置内部窗口的原始位置（内部窗口默认大小是0X0，放在0,0位置）
            iframe.reshape(nextFrameX, nextFrameY, width, height);
            // 使该窗口可见，并尝试选中它
            iframe.show();
            // 计算下一个内部窗口的位置
            nextFrameX += FRAME_DISTANCE;
            nextFrameY += FRAME_DISTANCE;
            if (nextFrameX + width > desktop.getWidth())
                nextFrameX = 0;
            if (nextFrameY + height > desktop.getHeight())
                nextFrameY = 0;
        }
    };
    // 定义exitAction用于创建菜单和工具按钮
    Action exitAction = new AbstractAction("退出", new ImageIcon("ico/exit.png")) {
        private static final long serialVersionUID = -254393382364931601L;

        public void actionPerformed(ActionEvent event) {
            System.exit(0);
        }
    };

    public void init() {
        // 为窗口安装菜单条和工具条
        JMenuBar menuBar = new JMenuBar();
        JToolBar toolBar = new JToolBar();
        jf.setJMenuBar(menuBar);
        menuBar.add(fileMenu);
        fileMenu.add(newAction);
        fileMenu.add(exitAction);
        toolBar.add(newAction);
        toolBar.add(exitAction);
        menuBar.add(windowMenu);
        JMenuItem nextItem = new JMenuItem("下一个");
        nextItem.addActionListener(event -> desktop.selectNextWindow());
        windowMenu.add(nextItem);
        JMenuItem cascadeItem = new JMenuItem("级联");
        cascadeItem.addActionListener(event ->
        // 级联显示窗口，内部窗口的大小是外部窗口的0.75
        desktop.cascadeWindows(FRAME_DISTANCE, 0.75));
        windowMenu.add(cascadeItem);
        JMenuItem tileItem = new JMenuItem("平铺");
        // 平铺显示所有内部窗口
        tileItem.addActionListener(event -> desktop.tileWindows());
        windowMenu.add(tileItem);
        final JCheckBoxMenuItem dragOutlineItem = new JCheckBoxMenuItem("仅显示拖动窗口的轮廓");
        dragOutlineItem.addActionListener(event ->
        // 根据该菜单项是否选择来决定采用哪种拖动模式
        desktop.setDragMode(
                dragOutlineItem.isSelected() ? JDesktopPane.OUTLINE_DRAG_MODE : JDesktopPane.LIVE_DRAG_MODE)); // ①
        windowMenu.add(dragOutlineItem);
        desktop.setPreferredSize(new Dimension(480, 360));
        // 将虚拟桌面添加到顶级JFrame容器中
        jf.add(desktop);
        jf.add(toolBar, BorderLayout.NORTH);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }

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

class MyJDesktopPane extends JDesktopPane {
    // 将所有窗口以级联方式显示，
    // 其中offset是两个窗口的位移距离， s
    // cale是内部窗口与JDesktopPane的大小比例
    public void cascadeWindows(int offset, double scale) {
        // 定义级联显示窗口时内部窗口的大小
        int width = (int) (getWidth() * scale);
        int height = (int) (getHeight() * scale);
        // 用于保存级联窗口时每个窗口的位置
        int x = 0;
        int y = 0;
        for (JInternalFrame frame : getAllFrames()) {
            try {
                // 取消内部窗口的最大化，最小化
                frame.setMaximum(false);
                frame.setIcon(false);
                // 把窗口重新放置在指定位置
                frame.reshape(x, y, width, height);
                x += offset;
                y += offset;
                // 如果到了虚拟桌面边界
                if (x + width > getWidth())
                    x = 0;
                if (y + height > getHeight())
                    y = 0;
            } catch (PropertyVetoException e) {
            }
        }
    }

    // 将所有窗口以平铺方式显示
    public void tileWindows() {
        // 统计所有窗口
        int frameCount = 0;
        for (JInternalFrame frame : getAllFrames()) {
            frameCount++;
        }
        // 计算需要多少行、多少列才可以平铺所有窗口
        int rows = (int) Math.sqrt(frameCount);
        int cols = frameCount / rows;
        // 需要额外增加到其他列中的窗口
        int extra = frameCount % rows;
        // 计算平铺时内部窗口的大小
        int width = getWidth() / cols;
        int height = getHeight() / rows;
        // 用于保存平铺窗口时每个窗口在横向、纵向上的索引
        int x = 0;
        int y = 0;
        for (JInternalFrame frame : getAllFrames()) {
            try {
                // 取消内部窗口的最大化，最小化
                frame.setMaximum(false);
                frame.setIcon(false);
                // 将窗口放在指定位置
                frame.reshape(x * width, y * height, width, height);
                y++;
                // 每排完一列窗口
                if (y == rows) {
                    // 开始排放下一列窗口
                    y = 0;
                    x++;
                    // 如果额外多出的窗口与剩下的列数相等，
                    // 则后面所有列都需要多排列一个窗口
                    if (extra == cols - x) {
                        rows++;
                        height = getHeight() / rows;
                    }
                }
            } catch (PropertyVetoException e) {
            }
        }
    }

    // 选中下一个非图标窗口
    public void selectNextWindow() {
        JInternalFrame[] frames = getAllFrames();
        for (int i = 0; i < frames.length; i++) {
            if (frames[i].isSelected()) {
                // 找出下一个非最小化的窗口，尝试选中它，
                // 如果选中失败，则继续尝试选中下一个窗口
                int next = (i + 1) % frames.length;
                while (next != i) {
                    // 如果该窗口不是处于最小化状态
                    if (!frames[next].isIcon()) {
                        try {
                            frames[next].setSelected(true);
                            frames[next].toFront();
                            frames[i].toBack();
                            return;
                        } catch (PropertyVetoException e) {
                        }
                    }
                    next = (next + 1) % frames.length;
                }
            }
        }
    }
}

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class InternalDialogTest {
    private JFrame jf = new JFrame("测试内部对话框");
    private JDesktopPane desktop = new JDesktopPane();
    private JButton internalBn = new JButton("内部窗口的对话框");
    private JButton deskBn = new JButton("虚拟桌面的对话框");
    // 定义一个内部窗口，该窗口可拖动，但不可最大化、最小化、关闭
    private JInternalFrame iframe = new JInternalFrame("内部窗口");

    public void init() {
        // 向内部窗口中添加组件
        iframe.add(new JScrollPane(new JTextArea(8, 40)));
        desktop.setPreferredSize(new Dimension(400, 300));
        // 把虚拟桌面添加到JFrame窗口中
        jf.add(desktop);
        // 设置内部窗口的大小、位置
        iframe.reshape(0, 0, 300, 200);
        // 显示并选中内部窗口
        iframe.show();
        desktop.add(iframe);
        JPanel jp = new JPanel();
        deskBn.addActionListener(event ->
        // 弹出内部对话框，以虚拟桌面作为父组件
        JOptionPane.showInternalMessageDialog(desktop, "属于虚拟桌面的对话框"));
        internalBn.addActionListener(event ->
        // 弹出内部对话框，以内部窗口作为父组件
        JOptionPane.showInternalMessageDialog(iframe, "属于内部窗口的对话框"));
        jp.add(deskBn);
        jp.add(internalBn);
        jf.add(jp, BorderLayout.SOUTH);
        jf.pack();
        jf.setVisible(true);
    }

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

JTabbedPane tabPane = new JTabbedPane (JTabbedPane.LEFT,JTabbedPane.WRAP_TAB_LAYOUT);

// 设置第三个Tab页面处于显示状态
tabPane.setSelectedIndex(2);
//设置最后一个Tab页面处于显示状态
tabPane.setSelectedIndex(tabPanel.getTabCount()-1);

tabPane.addChangeListener(listener);

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTabbedPane;

public class JTabbedPaneTest {
    JFrame jf = new JFrame("测试Tab页面");
    // 创建一个Tab页面的标签放在左边，采用换行布局策略的JTabbedPane
    JTabbedPane tabbedPane = new JTabbedPane(JTabbedPane.LEFT, JTabbedPane.WRAP_TAB_LAYOUT);
    ImageIcon icon = new ImageIcon("ico/close.gif");
    String[] layouts = { "换行布局", "滚动条布局" };
    String[] positions = { "左边", "顶部", "右边", "底部" };
    Map<String, String> books = new LinkedHashMap<>();

    public void init() {
        books.put("疯狂Java讲义", "java.png");
        books.put("轻量级Java EE企业应用实战", "ee.png");
        books.put("疯狂Ajax讲义", "ajax.png");
        books.put("疯狂Android讲义", "android.png");
        books.put("经典Java EE企业应用实战", "classic.png");
        String tip = "可看到本书的封面照片";
        // 向JTabbedPane中添加5个标签页面，指定了标题、图标和提示
        // 但该标签页面的组件为null
        for (String bookName : books.keySet()) {
            tabbedPane.addTab(bookName, icon, null, tip);
        }
        jf.add(tabbedPane, BorderLayout.CENTER);
        // 为JTabbedPane添加事件监听器
        tabbedPane.addChangeListener(event -> {
            // 如果被选择的组件依然是空
            if (tabbedPane.getSelectedComponent() == null) {
                // 获取所选标签页
                int n = tabbedPane.getSelectedIndex();
                // 为指定标前页加载内容
                loadTab(n);
            }
        });
        // 系统默认选择第一页，加载第一页内容
        loadTab(0);
        tabbedPane.setPreferredSize(new Dimension(500, 300));
        // 增加控制标签布局、标签位置的单选按钮
        JPanel buttonPanel = new JPanel();
        ChangeAction action = new ChangeAction();
        buttonPanel.add(new ButtonPanel(action, "选择标签布局策略", layouts));
        buttonPanel.add(new ButtonPanel(action, "选择标签位置", positions));
        jf.add(buttonPanel, BorderLayout.SOUTH);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }

    // 为指定标签页加载内容
    private void loadTab(int n) {
        String title = tabbedPane.getTitleAt(n);
        // 根据标签页的标题获取对应图书封面
        ImageIcon bookImage = new ImageIcon("ico/" + books.get(title));
        tabbedPane.setComponentAt(n, new JLabel(bookImage));
        // 改变标签页的图标
        tabbedPane.setIconAt(n, new ImageIcon("ico/open.gif"));
    }

    // 定义改变标签页的布局策略，放置位置的监听器
    class ChangeAction implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            JRadioButton source = (JRadioButton) event.getSource();
            String selection = source.getActionCommand();
            // 设置标签页的标题的布局策略
            if (selection.equals(layouts[0])) {
                tabbedPane.setTabLayoutPolicy(JTabbedPane.WRAP_TAB_LAYOUT);
            } else if (selection.equals(layouts[1])) {
                tabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
            }
            // 设置标签页上的标题的放置位置
            else if (selection.equals(positions[0])) {
                tabbedPane.setTabPlacement(JTabbedPane.LEFT);
            } else if (selection.equals(positions[1])) {
                tabbedPane.setTabPlacement(JTabbedPane.TOP);
            } else if (selection.equals(positions[2])) {
                tabbedPane.setTabPlacement(JTabbedPane.RIGHT);
            } else if (selection.equals(positions[3])) {
                tabbedPane.setTabPlacement(JTabbedPane.BOTTOM);
            }
        }
    }

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

// 定义一个JPanel类扩展类，该类的对象包含多个纵向排列的JRadioButton控件
// 且JPanel扩展类可以指定一个字符串作为TitledBorder
class ButtonPanel extends JPanel {
    private static final long serialVersionUID = -6408828937684129034L;
    private ButtonGroup group;

    public ButtonPanel(JTabbedPaneTest.ChangeAction action, String title, String[] labels) {
        setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
        setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
        group = new ButtonGroup();
        for (int i = 0; labels != null && i < labels.length; i++) {
            JRadioButton b = new JRadioButton(labels[i]);
            b.setActionCommand(labels[i]);
            add(b);
            // 添加事件监听器
            b.addActionListener(action);
            group.add(b);
            b.setSelected(i == 0);
        }
    }
}

new JSplitPane(方向，左/上组件，右/下组件);

//打开JSplitPane的连续布局特性
jSplitPane.setContinuousLayout(true);

//打开“一触即展”特性
jSplitPane.setOneTouchExpandable(true);

import java.awt.Dimension;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;

class Book {
    private String name;
    private Icon ico;
    private String desc;

    public Book() {
    }

    public Book(String name, Icon ico, String desc) {
        this.name = name;
        this.ico = ico;
        this.desc = desc;
    }

    // name的setter和getter方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    // ico的setter和getter方法
    public void setIco(Icon ico) {
        this.ico = ico;
    }

    public Icon getIco() {
        return this.ico;
    }

    // desc的setter和getter方法
    public void setDesc(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return this.desc;
    }

    public String toString() {
        return name;
    }
}

public class SplitPaneTest {
    Book[] books = new Book[] { new Book("疯狂Java讲义", new ImageIcon("ico/java.png"), "国内关于Java编程最全面的图书\n看得懂，学得会"),
            new Book("轻量级Java EE企业应用实战", new ImageIcon("ico/ee.png"), "SSH整合开发的经典图书，值得拥有"),
            new Book("疯狂Android讲义", new ImageIcon("ico/android.png"), "全面介绍Android平台应用程序\n开发的各方面知识") };
    JFrame jf = new JFrame("测试JSplitPane");
    JList<Book> bookList = new JList<>(books);
    JLabel bookCover = new JLabel();
    JTextArea bookDesc = new JTextArea();

    public void init() {
        // 为三个组件设置最佳大小
        bookList.setPreferredSize(new Dimension(150, 300));
        bookCover.setPreferredSize(new Dimension(300, 150));
        bookDesc.setPreferredSize(new Dimension(300, 150));
        // 为下拉列表添加事件监听器
        bookList.addListSelectionListener(event -> {
            Book book = (Book) bookList.getSelectedValue();
            bookCover.setIcon(book.getIco());
            bookDesc.setText(book.getDesc());
        });
        // 创建一个垂直的分割面板，
        // 将bookCover放在上面，将bookDesc放在下面， 支持连续布局
        JSplitPane left = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true, bookCover, new JScrollPane(bookDesc));
        // 打开“一触即展”的特性
        left.setOneTouchExpandable(true);
        // 下面代码设置分割条的大小。
        // left.setDividerSize(50);
        // 设置该分割面板根据所包含组件的最佳大小来调整布局
        left.resetToPreferredSizes();
        // 创建一个水平的分割面板
        // 将left组件放在左边，将bookList组件放在右边
        JSplitPane content = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, left, bookList);
        jf.add(content);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }

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