版本1

80.源码80，部件程序，表单程序，一对多表多方子表数据维护部件，运行时同时显示主表与子表，对子表提供录入、修改、删除操作功能。提供安全性、域完整性、实体完整性及参照完整性保护。对主表只提供删除操作功能。

/**

 * 程序文件名：dataTenance7.java

 * 作者：程学先 

 * 功能：一对多表多方子表数据维护部件，运行时同时显示主表与子表，对子表提供录入、修改、删除操作功能。

 * 对主表只提供删除操作功能，提供安全性、域完整性、实体完整性及参照完整性保护。

 * 在主表中删除一条记录时会提问是否同时删除子表中相匹配的记录，在肯定后删除子表中相关记录。

 * 关键字段名为子表的关键字，是识别与区分子表记录的主要标志，不允许重复，不允许为空，

 * 可以是单一字段，也可以是多个字段，如果是多字段，以英文逗号分隔。

 * 外键指主表与子表中同名字段，可以是单个字段，也可以是多字段。如果是多字段，以英文逗号分隔。

 * 在子表窗口中用组合框表示外键数据，组合框中数据全部来自主表，不能添加，

 * 保证在子表中录入数据时不出现破坏参照完整性的情况。

 * 当用鼠标点击主表某一条记录时，子表中组合框内显示相关外键数据，

 * 此时只需要修改子表非外键数据就可进行数据录入。

 * 输入子表非外键数据后再输入其他数据可修改子表中记录。

 * 子表允许借用工具程序deviseTool.java、completeTool.java、

 * secureTool.java等定义界面中的控件及其位置大小参数、定义数据完整性条件、定义数据安全要求。

 * 所有数据存放在一个文件中，文件名在参数中带入。

 * 完成日期：2014年1月20日

 * 被调用语句：dataTenance7.means(parameter);

 * 必须提供的参数：主表名，子表名，子表关键字（可多个），子表外键（即主表主键，可多个字段名）

 * 可选择提供的参数：“窗口宽”、“窗口高” 、“要求按钮号表”等均指子表窗口中参数。

 * 当子表字段数较少时，建议一定要改变窗口的宽度与高度。主表可停留在窗口任何位置。

 * 本部件预设的子表按钮控件“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“存盘”、“清屏”、

 * “修改存盘”、“删除”、“退出”共 10 个。

 * 通过“要求按钮号表”提供子表所需要显示的按钮在该部件原设计的界面 中的顺序号，各按钮号用逗号分隔。 

 * 每录入一条记录后必须点击“存盘”按钮。

 * 如果存在image字段，在点击“存盘”按钮后，将提问图片文件名，之后将新记录填入表内。

 * 每修改一条记录，必须点击“修改存盘”按钮，将改后记录填入表内。

 * 如果存在image字段，在点击“存盘”按钮后，将提问图片文件名，之后将新记录填入表内。

 * 每删除一条记录，必须点击“删除”按钮，将改后记录填入表内。

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

public class dataTenance7 extends JFrame {

static dataTenance7 frame1 = null;

static dataTenance7 frame2 = null;

static JTextField[] 文本框 = null;

private static Connection cont4; // 连接数据库

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String 主表名;

private static String 表名 = ""; // 数据表名

private static int 窗口宽 = main1.窗口宽;

private static int 窗口宽1 = 300;

private static int 窗口高 = main1.窗口高 - 100;

private static int 列数 = 0;

private static int 列数2 = 0, 当前列号 = 0; // 数据表列数

private static String[] 列名 = null; // 主表列名

private static String[] 列名0 = null; // 中文列名

private static String[] 列名2 = null; // 子表列名

private static String 字段名字串 = "";

private static String 字段名字串2 = "", 限只读字段号表 = "";

private static String[] 列数据类型 = null; // 存放当前记录各字段数据类型的数组

private static String[] 列数据类型2 = null; // 存放当前记录各字段数据类型的数组

private static int[] 列数据宽度 = null; // 存放当前记录各字段数据宽度的数组

private static int[] 列数据宽度2 = null; // 存放当前记录各字段数据宽度的数组

private static int 记录条数 = 0;

private static int 记录条数1 = 0;

private static int 记录条数2 = 0;

private static JTable 表格;

static DefaultTableModel 表格模型;

private static String[][] 表格数据 = null;

private static String[][] 表格数据2 = null;

private static String[] 文本数组值2 = null;

static String[][] 备份数据 = null;

private static String 要求按钮号表 = "";

private static int 实际按钮数 = 0;

private static String 要求字段号表 = "";

private static String 要求字段号表2 = "";

// private static String[] 一条空记录 = null;

private static String[] 一条空记录2 = null;

private static String[] 关键字段名 = null;// 存放关键字字段名的数组

private static int[] 关键字序号 = null;

private static String[] 外键名 = null;// 存放外键字段名的数组

private static String 外键序号集2 = "";

private static int[] 外键序号 = null; // 子表中外键在子表中序号

private static int[] 外键序号0 = null; // 主表中外键在子表中序号

private static int[] 外键序号1 = null; // 子表中外键在主表中序号

private static String s1 = "", s2 = "";

private static int b = 0, c = 0;

private static int 控件个数 = 0;

private static JLabel[] 图片数组 = null;

private static int 字符宽度 = 15, 字符高度 = 20;

private static String[] 按钮集;

private static JButton 第一条, 下一条, 最后一条, 上一条, 浏览, 存盘, 清屏, 修改存盘, 删除, 退出;

private static ArrayList<String> list = new ArrayList<String>();

private static ArrayList<String> list0 = new ArrayList<String>();

private static String[][] 位置参数表 = null;

private static String[][] 标签位置 = null;

private static String[][] 完整性参数表 = null;

private static String[][] 安全性参数表 = null;

private static String[][] 字典数据 = new String[0][0];

private static int 位置参数条数 = 0, 完整性参数条数 = 0, 安全性参数条数 = 0;

public static String username = main1.username;

public static int 字号 = 9, 颜色 = 5;

private static String 大数据类型 = main1.文本数据类型 + main1.图形数据类型;

private static int 起始左边距 = 0;

private static int 起始到顶距 = 0;

private static int[] 文本数组号2 = null;

private static int 行间距离 = 0;

private static JPanel panel2 = new JPanel(false); // 定义面板

private static int 原窗口宽 = 窗口宽;

private static int 文本区宽度 = 0;

private static int 大数据个数 = 0;// 是否已经定义了按钮位置标志

private static int 列名长度 = 0;

private static JTextArea[] 文本域 = null;

private static JComboBox[] 组合框 = null;

private static JTextComponent[] 文本数组2 = null;

private static String[][] 代码表数据 = null;

private static String 表名表 = "";

private static String 字典表名 = "";

private static int[][] 按钮位置 = null;

private static JButton[] 按钮数组 = new JButton[15];

public static String[] sw = new String[11];

static int 按钮数 = 0, 按钮宽 = 0;

private static int 按钮定义标志;

private static HashSet set01 = new HashSet();

public static String sd0;

static void means(String parameter[]) {

列数2 = 0;

当前列号 = 0;

字段名字串 = "";

字段名字串2 = "";

记录条数2 = 0;

记录条数1 = 0;

要求按钮号表 = "";

实际按钮数 = 0;

要求字段号表 = "";

要求字段号表2 = "";

s1 = "";

s2 = "";

b = 0;

c = 0;

控件个数 = 0;

字符宽度 = 18;

字符高度 = 20;

位置参数条数 = 0;

完整性参数条数 = 0;

安全性参数条数 = 0;

字号 = 9;

颜色 = 5;

起始左边距 = 0;

起始到顶距 = 0;

窗口宽 = main1.窗口宽;

窗口宽1 = 300;

窗口高 = main1.窗口高 - 100;

行间距离 = 0;

原窗口宽 = 窗口宽;

文本区宽度 = 0;

大数据个数 = 0;

列名长度 = 0;

表名表 = "";

字典表名 = "";

按钮定义标志 = 0;

list0 = new ArrayList<String>();

字典数据 = new String[0][0];

username = main1.username;

按钮宽 = 0;

sw = new String[11];

sw[1] = main1.sw1 + "";

sw[2] = main1.sw2;

sw[3] = main1.sw3;

sw[4] = main1.sw4;

sw[5] = main1.sw5;

sw[6] = main1.sw6;

sw[7] = main1.sw7;

sw[8] = main1.sw8;

sw[10] = main1.sw10;

main1.sw1 = 0;

main1.sw2 = "";

main1.sw3 = "";

main1.sw4 = "";

main1.sw5 = "";

main1.sw6 = "";

main1.sw7 = "";

main1.sw8 = "";

main1.sw9 = "";

main1.sw10 = "";

String 按钮集01[] = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘", "清屏",

"修改存盘", "删除", "退出" };

按钮集 = new String[按钮集01.length];

按钮数 = 0;

for (int i0 = 0; i0 < 按钮集01.length; i0++)

按钮集[i0] = 按钮集01[i0];

if (parameter[11].length() > 0) {

要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号

要求按钮号表 = 要求按钮号表.replaceAll("；", ";");

要求按钮号表 = 要求按钮号表.replaceAll("。", ";");

要求按钮号表 = 要求按钮号表.replaceAll(":", ";");

要求按钮号表 = 要求按钮号表.replaceAll("：", ";");

if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求

String s601[] = 要求按钮号表.split(",");

要求按钮号表 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (s601[i01].indexOf(";") > 0) {

String s602[] = s601[i01].split(";");

按钮集[Integer.parseInt((s602[0]))] = s602[1];

要求按钮号表 = 要求按钮号表 + "," + s602[0];

} else {

要求按钮号表 = 要求按钮号表 + "," + s601[i01];

}

}

} else {

String s601[] = 要求按钮号表.split(",");

要求按钮号表 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (i01 == 0)

要求按钮号表 = s601[i01];

else

要求按钮号表 = 要求按钮号表 + "," + s601[i01];

}

}

} else {

要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号

for (int i1 = 0; i1 < 按钮集.length; i1++) {

if (i1 == 0)

要求按钮号表 = 要求按钮号表 + i1;

else

要求按钮号表 = 要求按钮号表 + "," + i1;

}

}

要求按钮号表 = "," + 要求按钮号表 + ",";

要求按钮号表 = 要求按钮号表.replaceAll(",,", ",");

按钮数 = 按钮集.length; // 可以供选择的按钮数

按钮位置 = new int[按钮数][15];

int m1, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);// 宽度参数

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

窗口宽 = m1;

原窗口宽 = m1;

窗口高 = m2;

}

} catch (Exception e2) {

}

frame1 = new dataTenance7();

frame1.setTitle("主表数据记录");

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null); // 关闭布局管理器

panel2 = new JPanel(true);

frame2 = new dataTenance7();

frame2.setTitle("子表数据维护窗口                           作者：程学先");

frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame2.getContentPane().setLayout(null); // 关闭布局管理器

frame2.getContentPane().add(panel2, null); // 安装面板

list = new ArrayList<String>();

大数据类型 = main1.文本数据类型 + main1.图形数据类型;

按钮数组 = new JButton[20];

panel2.setLayout(null);

主表名 = parameter[2]; // 数据表名

表名表 = "," + parameter[0] + ",";

表名 = parameter[4]; // 数据表名

String[] t1 = parameter[0].split(","); // 表名数组

字段名字串2 = parameter[19];

String[] t2 = parameter[19].split(","); // 字段名数组

字典表名 = "";

if (表名表.lastIndexOf(表名 + "字典表") >= 0)

for (int i = 0; i < t1.length; i++)

if (t1[i].lastIndexOf(表名 + "字典表") >= 0) {

字典表名 = t1[i];

数据表查询数据0011(); // 查询字典表

}

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

关键字段名 = parameter[6].split(",");

外键名 = parameter[7].split(",");

要求字段号表 = parameter[8];

要求字段号表2 = parameter[9];

限只读字段号表 = "," + parameter[9] + ",";

关键字序号 = new int[关键字段名.length];

外键序号 = new int[外键名.length];

外键序号0 = new int[外键名.length];

String 字段名字串0 = "";

if (要求字段号表2.length() > 0) {

String[] t3 = 要求字段号表2.split(","); // 字段号数组

for (int i = 0; i < t3.length; i++) {

if (i > 0)

字段名字串0 = 字段名字串0 + "," + t2[Integer.parseInt(t3[i])];

else

字段名字串0 = t2[Integer.parseInt(t3[i])];

}

字段名字串2 = 字段名字串0;

for (int i = 0; i < 关键字段名.length; i++)

if (("," + 字段名字串2 + ",").indexOf("," + 关键字段名[i] + ",") < 0)

字段名字串2 = 字段名字串2 + "," + 关键字段名[i];

}

t2 = 字段名字串2.split(",");

文本数组号2 = new int[t2.length];

标签位置 = new String[t2.length][6];

位置参数表 = new String[t2.length][15];

按钮位置 = new int[按钮数][15];

if (parameter[5].length() > 1) { // 接口参数表文件

File file1 = new File(parameter[5]);

try {

if (file1.exists()) {

FileReader fr = new FileReader(file1);

BufferedReader br = new BufferedReader(fr);

String tempStr = null;

int d2 = 0;

int k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1) // 参数由completeTool等三个程序产生

list0.add(tempStr); // 将文件内容全部读到集合中，先统计参数中不同类型数据条数

}

String sk = "";

for (int i = 0; i < list0.size(); i++) {

sk = list0.get(i);

if (d2 == 0) { // 参数由completeTool等三个程序产生

list.add(sk);// 将文件内容读到集合中，先统计参数中不同类型数据条数

if (sk.substring(0, 2).equals("1,"))

位置参数条数++;

if (sk.substring(0, 2).equals("2,"))

安全性参数条数++;

if (sk.substring(0, 2).equals("3,"))

完整性参数条数++;

}

} // 以上完成对参数表数据分类统计条数

实际按钮数 = k3;

if (k3 > 0) {

按钮定义标志 = 1;

}

if (位置参数条数 > 0) {

位置参数表 = new String[位置参数条数][13];

标签位置 = new String[位置参数条数][6];// 0、1字段左边距到顶距，2字段类型

} else {

位置参数表 = new String[t2.length][13];

标签位置 = new String[t2.length][6];

} // 0、1字段左边距到顶距，2字段类型

安全性参数表 = new String[安全性参数条数][4];

完整性参数表 = new String[完整性参数条数][6];

int m3 = 0;

m1 = 0;

m2 = 0;

int y = 2, n1 = 0;

String s = "";

s2 = ",";

窗口宽 = 0;

for (int i = 0; i < list.size(); i++) {

s = list.get(i); // 再取出接口参数

if (d2 == 0) {

if (s.substring(0, 2).equals("1,")) { // 位置参数

位置参数表[m1] = s.substring(2, s.length()).split(

"。");

位置参数表[m1][1] = "";

位置参数表[m1][2] = 位置参数表[m1][5];

标签位置[m1][0] = Integer.parseInt(位置参数表[m1][3])

+ Integer.parseInt(位置参数表[m1][6]) + "";// 字段左边距

标签位置[m1][1] = 位置参数表[m1][7]; // 字段到顶距

if (Integer.parseInt(位置参数表[m1][5])

+ Integer.parseInt(标签位置[m1][1]) > 起始到顶距)

起始到顶距 = Integer.parseInt(位置参数表[m1][5])

+ Integer.parseInt(标签位置[m1][1]);

if (Integer.parseInt(位置参数表[m1][4])

+ Integer.parseInt(位置参数表[m1][6]) + 80 > 窗口宽)

窗口宽 = Integer.parseInt(位置参数表[m1][4])

+ Integer.parseInt(位置参数表[m1][6])

+ 80;

标签位置[m1][2] = ""; // 图形代码

标签位置[m1][3] = ""; // 代码表名

标签位置[m1][4] = ""; // 字段类型（普通字段、文本、图形）

s2 = s2 + 位置参数表[m1][0] + ","; // 字段名表

m1++;

位置参数条数 = m1; // 重定义位置参数条数

} else if (s.substring(0, 2).equals("2,")) {// 安全参数

y = 2;

n1 = 0;

int n0 = 0;

String[] sf = s.split("。");

安全性参数表[m2][0] = sf[0];

安全性参数表[m2][1] = sf[1]; // 表名或字段名

安全性参数表[m2][2] = sf[2]; // 权限

sf = 安全性参数表[m2][0].split(",");

安全性参数表[m2][0] = sf[1]; // 用户名

if ((安全性参数表[m2][0].equalsIgnoreCase(username))

&& (安全性参数表[m2][2].length() > 0)

&& (安全性参数表[m2][2].indexOf("a") < 0)

&& ((安全性参数表[m2][1].length() == 0)

|| (安全性参数表[m2][1].equals("*")) || (安全性参数表[m2][1]

.toLowerCase()

.equalsIgnoreCase(表名

.toLowerCase())))) { // 字段名为空、为星号、为表名表示是全表单权限，决定按钮显示否

if (安全性参数表[m2][2].indexOf("i") < 0) { // 不包含i录入权

要求按钮号表 = 要求按钮号表.replaceAll("5,", "");

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("u") < 0) { // 不包含u修改权

要求按钮号表 = 要求按钮号表.replaceAll("7,", "");

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("d") < 0) { // 不包含d删除权

要求按钮号表 = 要求按钮号表.replaceAll("8,", "");

n0 = 1;

}

n0 = 1;

} // 以下对字段安全要求进行处理

else if ((安全性参数表[m2][0]

.equalsIgnoreCase(username))

&& (安全性参数表[m2][2].length() > 0)

&& (安全性参数表[m2][2].indexOf("a") < 0) && // 权限内容不空,无a

(安全性参数表[m2][2].indexOf("d") < 0)) { // 如果任何一个字段不包含d删除权

要求按钮号表 = 要求按钮号表.replaceAll("8,", ""); // 去掉删除按钮

n0 = 1;

} else if ((安全性参数表[m2][0]

.equalsIgnoreCase(username))

&& (安全性参数表[m2][2].length() > 0)

&& (安全性参数表[m2][2].indexOf("a") < 0)

&& // 权限内容不空,无a

(安全性参数表[m2][2].indexOf("i") < 0)

&& (安全性参数表[m2][2].indexOf("u") < 0)) { // 如果任何一个字段不包含iu权

安全性参数表[m2][0] = "只读";

安全性参数表[m2][2] = "q,";

}

if (n0 == 0) {

m2++;

安全性参数条数 = m2; // 重定义安全性参数条数

}

} else if (s.substring(0, 2).equals("3,")) { // 完整性参数

y = 2;

n1 = 0;

for (int k = 2; k < s.length(); k++)

if (s.substring(k, k + 1).equals("。")) {

完整性参数表[m3][n1] = s.substring(y, k);

y = k + 1;

n1++;

}

完整性参数表[m3][n1] = s.substring(y, s.length());

if (完整性参数表[m3][3].isEmpty())

完整性参数表[m3][3] = "";

m3++;

完整性参数条数 = m3; // 重定义完整性参数条数

}

}

文本数组号2 = new int[位置参数表.length];

文本数组值2 = new String[位置参数表.length];

}

if (位置参数条数 > 0) {

字段名字串2 = "";

for (int i = 0; i < 位置参数条数; i++) {

if (i == 0)

字段名字串2 = 位置参数表[i][0];

else

字段名字串2 = 字段名字串2 + "," + 位置参数表[i][0];

}

}

}

} catch (IOException e2) {

JOptionPane.showMessageDialog(null, "打开文件错！");

}

} else { // 无接口参数表文件，根据选定的字段情况处理

位置参数表 = new String[t2.length][13];

标签位置 = new String[t2.length][6];// 0、1字段左边距到顶距，2字段类型

安全性参数表 = new String[0][4];

完整性参数表 = new String[0][6];

文本数组号2 = new int[t2.length];

文本数组值2 = new String[t2.length];

}

for (int i = 0; i < 安全性参数条数; i++) {

t2 = 字段名字串2.split(",");

for (int j = 0; j < t2.length; j++) {

if (安全性参数表[i][1].toLowerCase().indexOf(t2[j].toLowerCase()) >= 0) { // 字段名相同

if (安全性参数表[i][0].equals("只读"))

限只读字段号表 = 限只读字段号表 + j + ",";

安全性参数表[i][1] = j + "";

}

}

}

if (窗口宽 == 0)

窗口宽 = 原窗口宽;

数据表查询结构001(表名); // 得到数据表结构，产生全部字段名、数据类型、宽度

数据表查询数据001(表名); // 求当前表中所有数据

if (位置参数条数 == 0)

计算文本框001();

计算文本框002(); // 是否已经定义了按钮位置

安装文本框002();

String sd = "";

for (int i0 = 0; i0 < 记录条数2; i0++) {

sd = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++) {

if (文本数组号2[i] == 关键字序号[j]) {

if (表格数据2[i0][文本数组号2[i]] == null) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + 表格数据2[i0][文本数组号2[i]].trim() + ",";

break;

}

}

}

set01.add(sd);

}

第一条 = new JButton(按钮集[0]);

第一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

记录条数1 = 0;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") >= 0) {

String s3 = 表格数据2[记录条数1][文本数组号2[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]

+ ",") < 0))

if (! 标签位置[i][4].equals("列表框")) {

文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)

if ((文本数组2[i].getText() == null)

|| (文本数组2[i].getText().trim()

.length() < 1))

文本数组2[i].setText("0");

}

}

}

下一条.setEnabled(true);

上一条.setEnabled(false);

}

});

if (按钮位置[0][0] > 0) {

第一条.setBounds(按钮位置[0][0], 按钮位置[0][1], 按钮位置[0][2], 按钮位置[0][3]);

panel2.add(第一条);

}

下一条 = new JButton(按钮集[1]);

下一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 < 记录条数2 - 1) {

记录条数1++;

if (记录条数1 == 记录条数2 - 1)

下一条.setEnabled(false);

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]

+ ",") >= 0) {

String s3 = 表格数据2[记录条数1][文本数组号2[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = {};

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",") < 0))

if (! 标签位置[i][4].equals("列表框")) {

文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)

if ((文本数组2[i].getText() == null)

|| (文本数组2[i].getText().trim()

.length() < 1))

文本数组2[i].setText("0");

}

}

}

}

上一条.setEnabled(true);

}

});

if (按钮位置[1][0] > 0) {

下一条.setBounds(按钮位置[1][0], 按钮位置[1][1], 按钮位置[1][2], 按钮位置[1][3]);

panel2.add(下一条);

}

最后一条 = new JButton(按钮集[2]);

最后一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数2 > 1)

记录条数1 = 记录条数2 - 1;

else

记录条数1 = 0;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") >= 0) {

String s3 = 表格数据2[记录条数1][文本数组号2[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]

+ ",") < 0))

if (! 标签位置[i][4].equals("列表框")) {

文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)

if ((文本数组2[i].getText() == null)

|| (文本数组2[i].getText().trim()

.length() < 1))

文本数组2[i].setText("0");

}

}

}

下一条.setEnabled(false);

上一条.setEnabled(true);

}

});

if (按钮位置[2][0] > 0) {

最后一条.setBounds(按钮位置[2][0], 按钮位置[2][1], 按钮位置[2][2], 按钮位置[2][3]);

panel2.add(最后一条);

}

上一条 = new JButton(按钮集[3]);

上一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 > 0) {

记录条数1--;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]

+ ",") >= 0) {

String s3 = 表格数据2[记录条数1][文本数组号2[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",") < 0))

if (! 标签位置[i][4].equals("列表框")) {

文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)

if ((文本数组2[i].getText() == null)

|| (文本数组2[i].getText().trim()

.length() < 1))

文本数组2[i].setText("0");

}

}

}

下一条.setEnabled(true);

} else

上一条.setEnabled(false);

}

});

if (按钮位置[3][0] > 0) {

上一条.setBounds(按钮位置[3][0], 按钮位置[3][1], 按钮位置[3][2], 按钮位置[3][3]);

panel2.add(上一条);

上一条.setEnabled(false);

}

浏览 = new JButton(按钮集[4]);

浏览.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (浏览.getText().trim().equals("浏览")) {

浏览.setText("转当前行");

备份数据 = new String[记录条数2][列数2];

int[] n = new int[列数据宽度2.length];

for (int i = 0; i < 记录条数2; i++)

for (int j = 0; j < 列数2; j++) {

备份数据[i][j] = 表格数据2[i][j];

if (备份数据[i][j] == null)

备份数据[i][j] = "";

if (备份数据[i][j].length() > 50)

备份数据[i][j] = 备份数据[i][j].substring(0, 50);

}

for (int j = 0; j < 列数2; j++) {

n[j] = 列数据宽度2[j];

if (n[j] > 50)

n[j] = 50;

}

tableTenance.tableModel(窗口宽, 窗口高, 列名2, n, 备份数据, 列数据类型2);

} else {

浏览.setText("浏览");

记录条数1 = main1.当前行行号; // 记录指针

for (int i = 0; i < 控件个数; i++) {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]

+ ",") < 0))

文本数组2[i].setText(表格数据2[main1.当前行行号][文本数组号2[i]]);

}

}

}

});

if (按钮位置[4][0] > 0) {

浏览.setBounds(按钮位置[4][0], 按钮位置[4][1], 按钮位置[4][2], 按钮位置[4][3]);

panel2.add(浏览);

}

存盘 = new JButton(按钮集[5]);

存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int[] x0 = new int[控件个数];

String[] s0 = new String[控件个数];

int b = 0;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0) {

if ((标签位置[i][4].equals("组合框"))

|| (标签位置[i][4].equals("列表框"))) {

当前列号 = i;

if (标签位置[i][4].equals("组合框"))

文本数组值2[i] = (String) 组合框[当前列号]

.getSelectedItem();

if (文本数组值2[i] == null)

文本数组值2[i] = " ";

} else {

文本数组值2[i] = 文本数组2[i].getText().trim();

if (文本数组值2[i] == null) {

文本数组值2[i] = " ";

文本数组2[i].setText(一条空记录2[i]);

}

}

} else {

文本数组值2[i] = "?";

}

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++) {

if (文本数组号2[i] == 关键字序号[j]) {

if ((文本数组值2[i] == null)

|| (文本数组值2[i].trim().length() == 0))

kd0 = 1;

sd = sd + 文本数组值2[i].trim() + ",";

break;

}

}

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

set01.add(sd);

if (set01.size() == kd) {

JOptionPane.showMessageDialog(null, "关键字重复，请修改后重新生成！");

return;

}

set01.remove(sd); // 本句是准备生成SQL语句，在执行成功后再加到set中

sd0 = sd;

c = 0;

for (int i = 0; i < 控件个数; i++)

if (! 完整性检查(c, i)) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

cont4 = main1.getConn();

try {

记录条数2++;

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "insert into " + 表名 + "(";

for (int j = 0; j < 控件个数; j++) {

int a1 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j

+ ",") >= 0)

&& (安全性参数表[i][2].indexOf("i") < 0))

a1 = 1;

}

if (a1 == 0)

if (main1.图形数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[j]] + ",") < 0)

s1 = s1 + 列名2[文本数组号2[j]] + ",";

}

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

sd = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++) {

if (文本数组号2[i] == 关键字序号[j]) {

if ((文本数组值2[i] == null)

|| (文本数组值2[i].trim().length() == 0)) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + 文本数组值2[i].trim() + ",";

break;

}

}

}

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 文本数组2.length; i++)

if (文本数组号2[i] == 关键字序号[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[j]

+ ",") >= 0) {

if (文本数组值2[i].length() < 1)

文本数组值2[i] = "0";

s2 = s2 + 关键字段名[j] + "=" + 文本数组值2[i];

} else

s2 = s2 + 关键字段名[j] + "='"

+ 文本数组值2[i].trim() + "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

d1: for (int j = 0; j < 控件个数; j++) {

int a2 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j

+ ",") >= 0)

&& (安全性参数表[i][2].indexOf("i") < 0)) {

a2 = 1;

continue d1;

}

}

if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[j]]

+ ",") >= 0) {

s1 = s1 + 文本数组值2[j] + ",";

} else if (文本数组值2[j].trim().equals("?")) {

s0[b] = "update " + 表名 + " set " + 列名2[文本数组号2[j]]

+ " = ?" + " where " + s2;

x0[b] = j;

b++;

} else {

s1 = s1 + "'" + 文本数组值2[j].trim() + "',";

}

}

s1 = s1.substring(0, s1.length() - 1) + ")";

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

记录条数2++;

set01.add(sd0); // 添加新记录成功后将关键字加入set

for (int j = 0; j < 文本数组2.length; j++) {

表格数据2[记录条数2][j] = "";

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

for (int i = 0; i < b; i++)

图片存盘(s0[i], x0[i]);

for (int i = 0; i < 控件个数; i++)

if ((main1.图形数据类型

.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0))

文本数组2[i].setText(一条空记录2[i]);

}

});

if (按钮位置[5][0] > 0) {

存盘.setBounds(按钮位置[5][0], 按钮位置[5][1], 按钮位置[5][2], 按钮位置[5][3]);

panel2.add(存盘);

}

清屏 = new JButton(按钮集[6]);

清屏.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < 控件个数; i++) {

if ((main1.图形数据类型

.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0))

文本数组2[i].setText(一条空记录2[i]);

}

}

});

if (按钮位置[6][0] > 0) {

清屏.setBounds(按钮位置[6][0], 按钮位置[6][1], 按钮位置[6][2], 按钮位置[6][3]);

panel2.add(清屏);

}

修改存盘 = new JButton(按钮集[7]);

修改存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

for (int i = 0; i < 控件个数; i++)

if (! 完整性检查(c, i)) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

String[] s0 = new String[控件个数];

int b = 0;

int[] x0 = new int[控件个数];

for (int i = 0; i < 文本数组2.length; i++)

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0) {

if ((标签位置[i][4].equals("组合框"))

|| (标签位置[i][4].equals("列表框"))) {

当前列号 = i;

if (标签位置[i][4].equals("组合框"))

文本数组值2[i] = (String) 组合框[当前列号]

.getSelectedItem();

if (文本数组值2[i] == null)

文本数组值2[i] = " ";

} else {

文本数组值2[i] = 文本数组2[i].getText().trim();

if (文本数组值2[i] == null) {

文本数组值2[i] = " ";

文本数组2[i].setText(一条空记录2[i]);

}

}

} else {

文本数组值2[i] = "?";

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++)

if (文本数组号2[i] == 关键字序号[j]) {

if ((文本数组值2[i] == null)

|| (文本数组值2[i].trim().length() == 0))

kd0 = 1;

sd = sd + 文本数组值2[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请改为生成数据录入语句！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 文本数组2.length; i++)

if (文本数组号2[i] == 关键字序号[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[j] + ",") >= 0) {

if (文本数组值2[i].length() < 1)

文本数组值2[i] = "0";

s2 = s2 + 关键字段名[j] + "=" + 文本数组值2[i];

} else

s2 = s2 + 关键字段名[j] + "='" + 文本数组值2[i].trim()

+ "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "update " + 表名 + " set ";

d2: for (int j = 0; j < 文本数组2.length; j++) {

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j

+ ",") >= 0)

&& (安全性参数表[i][2].indexOf("u") < 0))

continue d2;

}

if (! 文本数组值2[j].trim().equals("?")) {

s1 = s1 + 列名2[文本数组号2[j]] + "=";

if (main1.数字数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[j]] + ",") >= 0)

s1 = s1 + 文本数组值2[j];

else

s1 = s1 + "'" + 文本数组值2[j].trim() + "'";

s1 = s1 + ",";

} else {

s0[b] = "update " + 表名 + " set " + 列名2[文本数组号2[j]]

+ "=? where " + s2;

x0[b] = j;

b++;

}

}

s1 = s1.substring(0, s1.length() - 1) + " where " + s2;

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

for (int k = 0; k < 文本数组2.length; k++) {

表格数据2[记录条数1][文本数组号2[k]] = 文本数组值2[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

for (int i = 0; i < b; i++)

图片存盘(s0[i], x0[i]);

}

});

if (按钮位置[7][0] > 0) {

修改存盘.setBounds(按钮位置[7][0], 按钮位置[7][1], 按钮位置[7][2], 按钮位置[7][3]);

panel2.add(修改存盘);

}

删除 = new JButton(按钮集[8]);

删除.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0)

文本数组值2[i] = 文本数组2[i].getText().trim();

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++)

if (文本数组号2[i] == 关键字序号[j]) {

if ((文本数组值2[i] == null)

|| (文本数组值2[i].trim().length() == 0))

kd0 = 1;

sd = sd + 文本数组值2[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请修改后重新生成！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++)

if (文本数组号2[i] == 关键字序号[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[j] + ",") >= 0)

s2 = s2 + 关键字段名[j] + "=" + 文本数组值2[i];

else

s2 = s2 + 关键字段名[j] + "='" + 文本数组值2[i].trim()

+ "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn(); // 连接数据库

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + 表名 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

deleteData(记录条数1);

set01.remove(sd0);

for (int i = 0; i < 控件个数; i++) {

if (记录条数1 == 记录条数2 - 1)

if (main1.图形数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",") < 0)

文本数组2[i].setText(一条空记录2[i]);

else if (main1.图形数据类型.lastIndexOf(","

+ 列数据类型2[文本数组号2[i]] + ",") < 0) {

文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);

}

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if (按钮位置[8][0] > 0) {

删除.setBounds(按钮位置[8][0], 按钮位置[8][1], 按钮位置[8][2], 按钮位置[8][3]);

panel2.add(删除);

}

退出 = new JButton(按钮集[9]);

按钮数组[9] = 退出;

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((sw[2].length() > 0) && (sw[3].length() > 0)

&& (sw[4].length() > 0))

WorkflowDrivek1.means(sw);

panel2.setVisible(false);

frame2.setVisible(false);

frame2.dispose();

}

});

if (按钮位置[9][0] > 0) {

退出.setBounds(按钮位置[9][0], 按钮位置[9][1], 按钮位置[9][2], 按钮位置[9][3]);

panel2.add(退出);

}

if ((sw[3].length() > 0) && (sw[4].length() > 0))

for (int i = 0; i < 控件个数; i++) {

文本数组2[i].setText(表格数据2[0][文本数组号2[i]]);

}

if (窗口高 - 起始到顶距 - 行间距离 - 100 < 0)

窗口高 = 起始到顶距 + 行间距离 + 100;

int w1, h1;

if (1200 - 窗口宽 > 0)

w1 = (1000 - 窗口宽) / 2;

else

w1 = 0;

if (600 - 窗口高 > 0)

h1 = (600 - 窗口高) / 2;

else

h1 = 0;

if (窗口高 < 起始到顶距 + 20)

窗口高 = 起始到顶距 + 20;

panel2.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 20);

frame2.setBounds(w1 + 300, h1 + 100, 窗口宽, 窗口高); // 主程序窗口位置大小

frame2.setVisible(true); // 安装窗口

表格模型 = new DefaultTableModel(表格数据, 列名0);

表格 = new JTable(表格模型);

表格.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

表格.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

int w0 = 0;

for (int i = 0; i < 列数; i++) {

TableColumn tc = 表格.getColumn(列名0[i]);

JTableHeader header = 表格.getTableHeader();

tc.setPreferredWidth(列数据宽度[i] * 10);

tc.setMaxWidth(列数据宽度[i] * 10);

tc.sizeWidthToFit();

w0 = w0 + 列数据宽度[i] * 10;

if (w0 > 窗口宽1)

break;

}

表格.addMouseListener(new MouseAdapter() { // 为表格添加鼠标事件监听器

public void mouseClicked(MouseEvent e) { // 发生了点击事件

int 选中行号 = 表格.getSelectedRow(); // 获得被选中行的索引

for (int i = 0; i < 外键序号.length; i++) {

组合框[外键序号[i]].setSelectedItem(表格数据[选中行号][外键序号0[i]]);

}

}

});

final JScrollPane scrollPane = new JScrollPane();

scrollPane.setBounds(10, 10, 300, 窗口高 - 260);

scrollPane.setViewportView(表格);

frame1.add(scrollPane, BorderLayout.CENTER);

frame1.setBounds(10, 10, 350, 窗口高 - 100); // 主程序窗口位置大小

frame1.setVisible(true); // 安装窗口

JButton 删除0 = new JButton("删除当前记录");

删除0.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int 选中行号 = 表格.getSelectedRow();

s2 = "";

for (int j = 0; j < 外键名.length; j++) {

for (int i = 0; i < 列名.length; i++)

if (i == 外键序号0[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[i] + ",") >= 0)

s2 = s2 + 外键名[j] + "="

+ 表格模型.getValueAt(选中行号, i).toString();

else

s2 = s2 + 外键名[j] + "='"

+ 表格模型.getValueAt(选中行号, i).toString()

+ "'";

break;

}

if (j < 外键名.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

if (JOptionPane.showConfirmDialog(null, "是否删除子表中相关记录？") == 0) {

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + 表名 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + 主表名 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

deleteData(记录条数1);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

删除0.setBounds(10, 窗口高 - 200, 150, 20);

frame1.add(删除0);

JButton 退出0 = new JButton("退出");

退出0.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame1.setVisible(false);

frame1.dispose();

frame1.setVisible(false);

frame1.dispose();

frame2.dispose();

frame2.setVisible(false);

frame2.dispose();

}

});

退出0.setBounds(160, 窗口高 - 200, 150, 20);

frame1.add(退出0);

}

static void 计算文本框001() { // 如果没有接口参数表，计算控件位置、大小参数

if (位置参数条数 > 0)

return;

int 行间距离 = 0;

int 起始左边距 = 10;

位置参数条数 = 列数2;

文本区宽度 = 窗口宽 - 80;

起始到顶距 = 20;

int y1 = 起始左边距;

int y2 = 起始到顶距;

int 最大标签宽度 = 0;

if ((大数据个数 == 0) && (列数2 * 字符高度 < 窗口高 - 120)) {

行间距离 = (窗口高 - 150 - 列数2 * 字符高度) / (列数2 + 1);

for (int j = 0; j < 列数2; j++)

if (位置参数表[j][1].length() > 最大标签宽度)

最大标签宽度 = 位置参数表[j][1].length();

for (int j = 0; j < 列数2; j++) {

位置参数表[j][6] = y1 + ""; // 标签左边

位置参数表[j][7] = y2 + ""; // 标签到顶

位置参数表[j][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度

位置参数表[j][2] = 字符高度 + ""; // 标签高度

标签位置[j][0] = (y1 + 最大标签宽度 * 字符宽度) + ""; // 字段左边

标签位置[j][1] = y2 + ""; // 字段到顶

位置参数表[j][4] = (文本区宽度 - Integer.parseInt(标签位置[j][0])) + ""; // 字段宽度

位置参数表[j][5] = 字符高度 + ""; // 字段高度

位置参数表[j][8] = "宋体";

位置参数表[j][9] = "10"; // 字号

位置参数表[j][10] = "5"; // 颜色

标签位置[j][2] = "2"; // 图形代号

y2 = y2 + 字符高度 + 行间距离;

起始到顶距 = y2;

}

} else // 字段比较多，或者有大数据

{

y1 = 起始左边距; // 当前位置

y2 = 起始到顶距;

int 当前行行号 = 1;

for (int j = 0; j < 列数2; j++) { // 先处理非大数据

列名长度 = 位置参数表[j][1].length(); // 翻译后字段名宽度

if (大数据类型.lastIndexOf("," + 列数据类型2[j] + ",") < 0) {

if ((y1 + (列名长度 + 列数据宽度2[j]) * 字符宽度) > 文本区宽度) { // 如果放不下，换行

当前行行号++;

y1 = 起始左边距;

y2 = y2 + 字符高度;

}

位置参数表[j][6] = y1 + ""; // 标签左边

位置参数表[j][7] = y2 + ""; // 标签到顶

位置参数表[j][3] = 列名长度 * 字符宽度 + ""; // 标签宽度

if ((y1 == 起始左边距) && (列名长度 > 最大标签宽度))

最大标签宽度 = 列名长度;

位置参数表[j][2] = 字符高度 + ""; // 标签高度

标签位置[j][0] = (y1 + 列名长度 * 字符宽度) + ""; // 字段左边

标签位置[j][1] = y2 + ""; // 字段到顶

位置参数表[j][4] = 列数据宽度2[j] * 字符宽度 + ""; // 字段宽度

位置参数表[j][5] = 字符高度 + ""; // 字段高度

位置参数表[j][8] = "宋体";

位置参数表[j][9] = "10"; // 字号

位置参数表[j][10] = "5"; // 颜色

标签位置[j][2] = "2"; // 图形代号

y1 = y1 + 列名长度 * 字符宽度 + 列数据宽度2[j] * 字符宽度;

}

}

if (大数据个数 == 0)

行间距离 = (窗口高 - 150) / (当前行行号 + 1) - 字符高度;

else

行间距离 = 0;

if (行间距离 < 0)

行间距离 = 0;

int z = 0; // 每行左移数值

int z1 = 0; // 每行下移数值

int z3 = 0; // 最后一个非大数据字段号

for (int j = 0; j < 列数2; j++) { // 先处理非大数据位置调整

if (大数据类型.lastIndexOf("," + 列数据类型2[j] + ",") < 0) {

if (Integer.parseInt(位置参数表[j][6]) == 起始左边距) { // 每行第一列

z = 最大标签宽度 * 字符宽度 - Integer.parseInt(位置参数表[j][3]); // 修正标签宽度

z1 = z1 + 行间距离;

if (j > 0)

位置参数表[z3][4] = (文本区宽度 - Integer

.parseInt(标签位置[z3][0])) + "";

}

位置参数表[j][6] = (Integer.parseInt(位置参数表[j][6]) + z) + ""; // 标签左边

标签位置[j][0] = (Integer.parseInt(标签位置[j][0]) + z) + ""; // 字段左边

位置参数表[j][7] = (Integer.parseInt(位置参数表[j][7]) + z1) + ""; // 标签到顶

标签位置[j][1] = (Integer.parseInt(标签位置[j][1]) + z1) + ""; // 字段到顶

y2 = Integer.parseInt(标签位置[j][1]);

z3 = j;

}

}

位置参数表[z3][4] = (文本区宽度 - Integer.parseInt(标签位置[z3][0])) + "";

起始到顶距 = y2;

if (大数据个数 > 0) {

y2 = y2 + 字符高度; // 剩下空间高度

int z2 = (窗口高 - y2 - 120) / 大数据个数; // 大数据高度

for (int i3 = 0; i3 < 列数2; i3++) { // 处理大数据位置

if (大数据类型.lastIndexOf("," + 列数据类型2[i3] + ",") >= 0) {

位置参数表[i3][6] = 起始左边距 + ""; // 标签左边

位置参数表[i3][7] = y2 + ""; // 标签到顶

位置参数表[i3][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度

位置参数表[i3][2] = 字符高度 + ""; // 标签高度

标签位置[i3][0] = (起始左边距 + 最大标签宽度 * 字符宽度) + ""; // 字段左边

标签位置[i3][1] = y2 + ""; // 字段到顶

y2 = y2 + z2;

位置参数表[i3][4] = (文本区宽度 - 最大标签宽度 * 字符宽度) + ""; // 字段宽度

位置参数表[i3][5] = z2 + ""; // 字段高度

位置参数表[i3][8] = "宋体";

位置参数表[i3][9] = "10"; // 字号

位置参数表[i3][10] = "5"; // 颜色

标签位置[i3][2] = "2"; // 图形代号

if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[i3] + ",") >= 0)

标签位置[i3][4] = "图像字段"; // 字段类型

else

标签位置[i3][4] = "文本字段"; // 字段类型

// 当前列列号++;

}

}

起始到顶距 = y2 + 字符高度;

}

}

起始到顶距 = y2 + 字符高度;

}

static void 计算文本框002() { // 如果没有接口参数表，计算控件位置、大小参数

if (按钮定义标志 > 0)

return; 

String[] t5 = 要求按钮号表.split(",");

实际按钮数 = t5.length - 1;

按钮位置 = new int[按钮数][15];

for (int j = 0; j < 按钮数; j++) {

按钮位置[j][0] = 0;

按钮位置[j][1] = 0;

按钮位置[j][2] = 0;

按钮位置[j][3] = 0;

}

int 按钮宽度;// ,按钮行数;

按钮宽度 = (int) (字符宽度 * 6.3);

起始左边距 = 20;

if (大数据个数 == 0)

起始到顶距 = 起始到顶距 + 字符高度 * 2;

else

起始到顶距 = 起始到顶距 + 字符高度;

int 一行按钮数 = (窗口宽 - 100) / (int) (6.6 * 字符宽度);

if (一行按钮数 < 1)

一行按钮数 = 1; // 每行最少一个按钮

if (实际按钮数 <= 一行按钮数)

按钮宽度 = (窗口宽 - 100) / 实际按钮数;

else

按钮宽度 = (窗口宽 - 100) / 一行按钮数;

int n = 0, n1 = 0, n3 = 0; // n：当行按钮数，n1：已排按钮数,n3:一行按钮宽

n3 = 一行按钮数 * 按钮宽度;

for (int j = 0; j < 按钮数; j++) {

if (要求按钮号表.lastIndexOf("," + j + ",") >= 0) {

按钮位置[j][0] = 起始左边距;

按钮位置[j][1] = 起始到顶距;

if (按钮集[j].length() > 4) {

按钮位置[j][2] = (int) (按钮集[j].length() * (字符宽度 * 1.2));

n3 = n3 + 按钮位置[j][2] - 按钮宽度;

起始左边距 = 起始左边距 + 按钮位置[j][2];

} else {

按钮位置[j][2] = 按钮宽度;

起始左边距 = 起始左边距 + 按钮宽度;

}

按钮位置[j][3] = 字符高度;

n++;

n1++;

if (实际按钮数 - n1 == 0)

break;

if ((n >= 一行按钮数) && ((实际按钮数 - n1) - 一行按钮数  != 0)) { // 如果按钮换行

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

if ((实际按钮数 - n1) <= 一行按钮数)

按钮宽度 = (窗口宽 - 100) / (实际按钮数 - n1);

else

按钮宽度 = (窗口宽 - 100) / 一行按钮数;

n = 0;

} else if (n >= 一行按钮数) {

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

n = 0;

}

}

}

窗口高 = 起始到顶距 + 字符高度 + 100;

}

static void 数据表查询结构001(String 数据表名001) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + 字段名字串2 + " from " + 数据表名001;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数2 = rsmdt4.getColumnCount();

列名2 = new String[列数2];

列数据类型2 = new String[列数2];

列数据宽度2 = new int[列数2];

一条空记录2 = new String[列数2];

大数据个数 = 0;

for (int i = 0; i < 列数2; i++) {

列名2[i] = rsmdt4.getColumnName(i + 1);

列数据宽度2[i] = rsmdt4.getColumnDisplaySize(i + 1);

列数据类型2[i] = rsmdt4.getColumnTypeName(i + 1);

if (标签位置[i][3] == null)

标签位置[i][3] = "";

if (标签位置[i][4] == null)

标签位置[i][4] = "";

if ((标签位置[i][3].length() < 1)

&& ((表名表.lastIndexOf("," + 列名2[i] + "表,") >= 0) && (列名2[i]

.indexOf("代码") >= 0))) {

标签位置[i][3] = 列名2[i] + "表";

标签位置[i][4] = "组合框";

列数据宽度2[i] = 列数据宽度2[i] + 10;

} else if ((标签位置[i][3].length() < 1)

&& ((表名表.lastIndexOf("," + 列名2[i] + "代码表,") >= 0) && (列名2[i]

.indexOf("代码") < 0))) {

标签位置[i][3] = 列名2[i] + "代码表";

标签位置[i][4] = "组合框";

列数据宽度2[i] = 列数据宽度2[i] + 10;

}

位置参数表[i][0] = 列名2[i];

if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() != 0))

for (int j = 0; j < 字典数据.length; j++) {

if (列名2[i].toLowerCase().equalsIgnoreCase(

字典数据[j][0].toLowerCase()))

位置参数表[i][1] = 字典数据[j][1]; // 完成字典名（标签）改变

else if (列名2[i].toLowerCase().equalsIgnoreCase(

字典数据[j][1].toLowerCase()))

位置参数表[i][1] = 字典数据[j][0]; // 完成字典名（标签）改变

}

if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() == 0))

位置参数表[i][1] = 列名2[i];

if (标签位置[i][4].length() < 1)

if (main1.文本数据类型.indexOf("," + 列数据类型2[i] + ",") >= 0) {

标签位置[i][4] = "文本字段";

大数据个数++;

} else if (列数据类型2[i].equalsIgnoreCase("image")) {

标签位置[i][4] = "图像字段";

大数据个数++;

} else

标签位置[i][4] = "普通字段";

if (列数据类型2[i].indexOf("datetime") == 0)

一条空记录2[i] = "2001-01-01 00:00:00.000";

else if (列数据类型2[i].indexOf("smalldatetime") == 0)

一条空记录2[i] = "2001-01-01 00:00:00";

else if (列数据类型2[i].indexOf("datetime2") == 0)

一条空记录2[i] = "2001-01-01 00:00:00.0000000";

else if (列数据类型2[i].indexOf("datetimeoffset") == 0)

一条空记录2[i] = "2001-01-01 00:00:00.0000000 +08:00";

else if (列数据类型2[i].indexOf("date") == 0)

一条空记录2[i] = "2001-01-01";

else if (列数据类型2[i].indexOf("time") == 0)

一条空记录2[i] = "00:00:00";

else if (列数据类型2[i].indexOf("money") >= 0)

一条空记录2[i] = "0.0000";

else if (main1.小数型数据类型.lastIndexOf("," + 列数据类型2[i] + ",") >= 0)

一条空记录2[i] = "0.00";

else if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[i] + ",") >= 0)

一条空记录2[i] = "0";

else

一条空记录2[i] = "";

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

外键序号集2 = ",";

字段名字串 = "";

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select * from " + 主表名;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[列数];

for (int i = 0; i < 列数; i++) {

列名[i] = rsmdt4.getColumnName(i + 1);

if ((要求字段号表.trim().length() > 0)

&& (("," + 要求字段号表 + ",").indexOf("," + i + ",") >= 0))

字段名字串 = 字段名字串 + 列名[i] + ",";

else if (要求字段号表.trim().length() == 0)

字段名字串 = 字段名字串 + 列名[i] + ",";

}

字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + 字段名字串 + " from " + 主表名;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[列数];

列名0 = new String[列数];

列数据类型 = new String[列数];

列数据宽度 = new int[列数];

for (int i = 0; i < 列数; i++) {

列名[i] = rsmdt4.getColumnName(i + 1);

列名0[i] = 列名[i];

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

for (int i = 0; i < 字典数据.length; i++) {

for (int j = 0; j < 列名.length; j++) {

if (列名[j].equals(字典数据[i][0]))

列名0[j] = 字典数据[i][1];

else if (列名[j].equals(字典数据[i][1]))

列名0[j] = 字典数据[i][0];

}

}

for (int j = 0; j < 列名.length; j++) {

for (int i = 0; i < 字典数据.length; i++) {

if (列名[j].equals(字典数据[i][0]))

列名0[j] = 字典数据[i][1];

else if (列名[j].equals(字典数据[i][1]))

列名0[j] = 字典数据[i][0];

}

}

for (int i1 = 0; i1 < 列名.length; i1++) {// 主表中外键在主表中序号

for (int j1 = 0; j1 < 外键名.length; j1++)

if (列名[i1].toLowerCase().trim()

.equals(外键名[j1].toLowerCase().trim()))

外键序号0[j1] = i1;

}

外键序号1 = new int[列名2.length];

for (int i1 = 0; i1 < 列名2.length; i1++) {

for (int j1 = 0; j1 < 关键字段名.length; j1++) {

if (列名2[i1].toLowerCase().trim()

.equals(关键字段名[j1].toLowerCase().trim()))

关键字序号[j1] = i1;

}

for (int j1 = 0; j1 < 外键名.length; j1++) { // 子表中外键在子表中序号

if (列名2[i1].toLowerCase().trim()

.equals(外键名[j1].toLowerCase().trim())) {

外键序号[j1] = i1; // 外键在子表中序号

外键序号集2 = 外键序号集2 + i1 + ",";

}

}

}

for (int i1 = 0; i1 < 列名2.length; i1++) {

for (int j1 = 0; j1 < 外键名.length; j1++) { // 子表中外键在子表中序号

if (列名2[i1].toLowerCase().trim()

.equals(外键名[j1].toLowerCase().trim()))

for (int i2 = 0; i2 < 列名.length; i2++) {

if (列名[i2].toLowerCase().trim()

.equals(外键名[j1].toLowerCase().trim()))

外键序号1[i1] = i2; // 子表中外键在主表中序号

}

}

}

}

static void 数据表查询数据001(String 数据表名001) { // 查数据表数据

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + 字段名字串2 + "  from " + 数据表名001;

if ((sw[3].length() > 0) && (sw[4].length() > 0))

s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";

rs = stat4.executeQuery(s1);

rs.last();

记录条数2 = rs.getRow();

String[][] 表格数据0 = new String[记录条数2][列数2];

表格数据2 = new String[记录条数2 + 300][列数2];

rsmdt4 = rs.getMetaData();

int c = 0;

int b = 0;

while (c < 记录条数2) {

rs.absolute(c + 1);

while (b < 列数2) {

表格数据0[c][b] = rs.getString(b + 1);

表格数据2[c][b] = 表格数据0[c][b];

b++;

}

c++;

b = 0;

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

for (int i = 0; i < 记录条数2; i++)

for (int j = 0; j < 列数2; j++)

表格数据2[i][j] = 表格数据0[i][j];

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select " + 字段名字串 + " from " + 主表名;

ResultSet rs = stat4.executeQuery(s1);

rs.last();

记录条数 = rs.getRow();

表格数据 = new String[记录条数][列数];

rs.absolute(1);

c = 0;

b = 0;

while (c < 记录条数) {

rs.absolute(c + 1);

while (b < 列数) {

表格数据[c][b] = rs.getString(b + 1);

b++;

}

c++;

b = 0;

}

rs.close();

stat4.close();

} catch (Exception e) {

e.printStackTrace();

}

}

static void 数据表查询数据0011() { // 查询字典表

int 记录条数5 = 0;

try {

if (字典表名.length() > 0) {

cont4 = main1.getConn();// 连接数据库

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + 字典表名;

rs = stat4.executeQuery(s1);

rs.last();

记录条数5 = rs.getRow();

字典数据 = new String[记录条数5][2];

rs.absolute(1);

String s4 = "";

String s5 = "";

for (int i = 1; i <= 记录条数5; i++) {

rs.absolute(i);

s4 = rs.getString(1).trim();

字典数据[i - 1][0] = s4;

s5 = rs.getString(2).trim();

字典数据[i - 1][1] = s5;

}

rs.close(); // 关闭查询结果集

stat4.close();

cont4.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！");

}

}

static void 数据表查询数据0012(String 代码表名0, String 列名9, int j9) { // 查代码表数据

try {

if (列名9.indexOf("代码") >= 0) {

s2 = 列名9.substring(0, 列名9.length() - 2);

s1 = "select " + 列名9 + "," + s2 + " from " + 代码表名0;

} else if (表名表.lastIndexOf("," + 列名9 + "代码表,") >= 0) {

s2 = 列名9.substring(0, 列名9.length() - 2);

s1 = "select " + 列名9 + "," + 列名9 + "代码" + " from " + 列名9

+ "代码表";

}

cont4 = main1.getConn();// 连接数据库

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stat4.executeQuery(s1);

rs.last();

int numberOfColumns = rs.getRow();

rs.beforeFirst();

代码表数据[j9] = new String[numberOfColumns];

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

代码表数据[j9][i - 1] = rs.getString(1).trim();

}

rs.close();

stat4.close(); // 关闭连接

cont4.close();

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

}

static void 安装文本框002() {

文本框 = new JTextField[位置参数条数];

文本域 = new JTextArea[位置参数条数];

图片数组 = new JLabel[位置参数条数];

组合框 = new JComboBox[位置参数条数];

文本数组2 = new JTextComponent[位置参数条数];

文本数组号2 = new int[位置参数条数];

代码表数据 = new String[位置参数条数][2];

控件个数 = 位置参数条数;

for (int j = 0; j < 控件个数; j++) {

JLabel 标签 = new JLabel(位置参数表[j][1], 11);

标签.setBounds(Integer.parseInt(位置参数表[j][6]),

Integer.parseInt(位置参数表[j][7]),

Integer.parseInt(位置参数表[j][3]),

Integer.parseInt(位置参数表[j][2]));

Font font = new Font(位置参数表[j][8], Font.BOLD,

Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小

String s01 = 位置参数表[j][10];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01);

标签.setFont(font);

color1(s02, 标签);// 设置颜色

panel2.add(标签);

if ((标签位置[j][4].equals("普通字段"))

&& ((外键序号集2.indexOf("," + j + ",") < 0))) {

文本框[j] = new JTextField("");

文本框[j].setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

Font font1 = new Font(位置参数表[j][8], Font.BOLD,

Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小

String s011 = 位置参数表[j][10];

int s021 = 5;

if ((s011 != null) && (s011.length() > 0)

&& (s011.compareTo("0") >= 0)

&& (s011.compareTo("9") <= 0))

s021 = Integer.parseInt(s011);

文本框[j].setFont(font1);

color2(s021, 文本框[j]);// 设置颜色

if (限只读字段号表.indexOf("," + j + ",") >= 0) {

文本框[j].setEditable(false);

}

panel2.add((Component) 文本框[j]);

文本框[j].addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent arg0) {// 鼠标按下事件

c = 0;

}

});

文本框[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {// 获得焦点

Object s0 = arg0.getSource();

String s1 = s0.toString();

String s2 = "";

for (int i = 0; i < 控件个数; i++) {

s2 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

}

public void focusLost(final FocusEvent arg1) {// 失去焦点

if (c > 0)

return;

Object s0 = arg1.getSource();

String s1 = s0.toString().substring(10, 33);

String s2 = "";

for (int i = 0; i < 控件个数; i++) {

s2 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

if ((c == 0) && (! 完整性检查(c, b))) {

文本框[c].requestFocus(true); // 返回原来文本框

return;

}

}

});

文本框[j].setText(一条空记录2[j]);

文本数组2[j] = (JTextComponent) 文本框[j];

文本数组号2[j] = j;

} // 普通字段

else if (标签位置[j][4].equals("文本字段")) {

文本域[j] = new JTextArea("   ", Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

JScrollPane 文本域滚动条 = new JScrollPane(文本域[j]);

文本域滚动条.setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

Font font1 = new Font(位置参数表[j][8], Font.BOLD,

Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小

String s011 = 位置参数表[j][10];

int s021 = 5;

if ((s011 != null) && (s011.length() > 0)

&& (s011.compareTo("0") >= 0)

&& (s011.compareTo("9") <= 0))

s021 = Integer.parseInt(s011);

文本域[j].setFont(font1);

color3(s021, 文本域[j]);// 设置颜色

panel2.add((Component) 文本域滚动条);

文本域[j].setText(一条空记录2[j]);

文本数组2[j] = (JTextComponent) 文本域[j];

文本数组号2[j] = j;

} else if (标签位置[j][4].equals("图像字段")) {

JLabel 图片框 = new JLabel("   ");

图片框.setBackground(Color.BLUE);

图片框.setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

panel2.add(new JScrollPane(图片框));

panel2.add(图片框);

图片数组[j] = 图片框;

文本数组2[j] = (JTextComponent) 文本域[j];

文本数组号2[j] = j;

} else if (标签位置[j][4].equals("组合框")) {

组合框[j] = new JComboBox();

文本框[j] = new JTextField();

组合框[j].setEditable(true);// 确定 JComboBox 字段是否可编辑

组合框[j].setEnabled(true); // 启用组合框以便可以选择项

panel2.add((Component) 组合框[j]);

组合框[j].setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

数据表查询数据0012(标签位置[j][3], 位置参数表[j][0], j);

for (int i = 0; i < 代码表数据[j].length; i++) {

组合框[j].addItem(代码表数据[j][i]);

}

文本数组2[j] = (JTextComponent) 组合框[j].getEditor()

.getEditorComponent(); // 控件个数

文本数组2[j].setText(""); // 控件个数

文本数组号2[j] = j;

} else if (外键序号集2.indexOf("," + j + ",") >= 0) {

组合框[j] = new JComboBox();

文本框[j] = new JTextField();

组合框[j].setEditable(false);// 确定 JComboBox 字段是否可编辑

组合框[j].setEnabled(true); // 启用组合框以便可以选择项

panel2.add((Component) 组合框[j]);

组合框[j].setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

for (int i = 0; i < 表格数据.length; i++) {

组合框[j].addItem(表格数据[i][外键序号1[j]]);

}

文本数组2[j] = (JTextComponent) 组合框[j].getEditor()

.getEditorComponent(); // 控件个数

文本数组2[j].setText(""); // 控件个数

文本数组号2[j] = j;

组合框[j].addActionListener(new ActionListener() {// 组合框响应事件

public void actionPerformed(ActionEvent event) {

int b0 = 0;

String s0 = "";

String s10 = event.toString();

for (int i = 0; i < 控件个数; i++) {

s0 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s10.indexOf(s0) > 0) {

b0 = i;

break;

}

}

for (int i = 0; i < 外键序号.length; i++) {

if (外键序号[i] != b0)

组合框[外键序号[i]].setSelectedIndex(组合框[b0]

.getSelectedIndex());

表格.editCellAt(组合框[b0].getSelectedIndex(), 外键序号1[b0]);

}

}

});

}

}

}

public static void deleteData(int pos) {

if (pos == 记录条数2 - 1)

记录条数1--;

for (int i = pos; i < 记录条数2 - 1; i++) {

for (int j = 0; j < 控件个数 - 1; j++) {

表格数据2[i][j] = 表格数据2[i + 1][j];

}

}

记录条数2--;

}

static void color1(int c, JLabel fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color2(int c, JTextField fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color3(int c, JTextArea fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

public static void 图片存盘(String s0, int k) {

for (int i = 0; i < 文本数组2.length; i++)

cont4 = main1.getConn();

try {

PreparedStatement pst4 = cont4.prepareStatement(s0);

int k2 = 1;

String s5 = "";

final JFileChooser fc = new JFileChooser(".\\");

fc.showDialog(new JLabel(), "请选择图片字段" + 列名2[文本数组号2[k]] + "的文件名");

if (fc.getSelectedFile() != null)

s5 = fc.getSelectedFile().toString();

else {

JOptionPane.showMessageDialog(null, "未选择图片文件，原图不变！");

return;

}

FileInputStream f1 = new FileInputStream(s5); // 指定图片文件名，包括路径

pst4.setBinaryStream(k2, f1, f1.available());

k2++;

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

byte[] c0 = new byte[s5.length()];

Icon icon = new ImageIcon(c0);

图片数组[k].setOpaque(true);

图片数组[k].setBackground(Color.PINK);

图片数组[k].setIcon(icon);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

} catch (IOException e3) {

JOptionPane.showMessageDialog(null, "文件读取出错！");

}

}

public static boolean 完整性检查(int c1, int b1) {

c = c1;

b = b1;

int bz1 = 0;

String sb = "", bz = "";

String[] sb1 = null;

try {

for (int i1 = 0; i1 < 完整性参数条数; i1++) {

if (完整性参数表[i1][0].toLowerCase().trim()

.equals(位置参数表[b][0].toLowerCase().trim())) { // 当前字段,获得焦点时记录

bz1 = main1.数字数据类型.indexOf("," + 列数据类型2[文本数组号2[b]] + ",");

if (bz1 >= 0) { // 数字数据类型

if ((完整性参数表[i1][1].trim().length() > 0)

&& (Double.parseDouble(文本框[b].getText()) > Double

.parseDouble(完整性参数表[i1][1]))) {

bz = 文本框[b].getText() + ">最大值"

+ Double.parseDouble(完整性参数表[i1][1]);

c = b;

} else if ((完整性参数表[i1][2].trim().length() > 0)

&& (Double.parseDouble(文本框[b].getText()) < Double

.parseDouble(完整性参数表[i1][2]))) {

bz = 文本框[b].getText() + "<最小值" + 完整性参数表[i1][2];

c = b;

} else if ((完整性参数表[i1][3].trim().length() > 0)) {

if (完整性参数表[i1][3].indexOf("-") > 0) {

sb1 = 完整性参数表[i1][3].split("-");

if ((Double.parseDouble(文本框[b].getText()) < Double

.parseDouble(sb1[0]))) {

bz = 文本框[b].getText() + "<范围下限" + sb1[0];

c = b;

}

if ((Double.parseDouble(文本框[b].getText()) > Double

.parseDouble(sb1[1]))) {

bz = 文本框[b].getText() + ">范围上限" + sb1[1];

c = b;

}

} else if (完整性参数表[i1][3].indexOf("[") >= 0) {

bz = 完整性参数表[i1][3].trim().substring(1,

完整性参数表[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (文本框[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (文本框[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

} else if (完整性参数表[i1][3].indexOf(",") > 0) {

if (("," + 完整性参数表[i1][3] + ",").indexOf(","

+ 文本框[b].getText() + ",") < 0) {

c = b;

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

}

}

} else if (完整性参数表[i1][4].trim().length() > 0) {

int[][] m = new int[2][控件个数];

for (int i = 0; i < 控件个数; i++) { // 按列名长度从大到小排序

m[0][i] = i;

m[1][i] = 位置参数表[i][0].length();

}

int d = 0, e = 0;

for (int i = 0; i < m[1].length; i++)

for (int j = i + 1; j < m[1].length; j++)

if (m[1][i] < m[1][j]) {

e = m[0][i];

m[0][i] = m[0][j];

m[0][j] = e;

e = m[1][i];

m[1][i] = m[1][j];

m[1][j] = e;

}

sb = 完整性参数表[i1][4];

for (int i = 0; i < m[1].length; i++)

sb = sb.replaceAll(位置参数表[m[0][b]][0],

文本框[m[0][b]].getText());

if (! tenanceEval.tenanceeval(sb)) {

bz = 文本框[b].getText() + "不满足条件："

+ 完整性参数表[i1][4];

c = b;

}

} else

c = 0;

} 

else if (main1.文字数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[b]]

+ ",") >= 0) { // 字符类型

if ((完整性参数表[i1][3].trim().length() > 0)) {

if (完整性参数表[i1][3].indexOf("[") >= 0) {

bz = 完整性参数表[i1][3].trim().substring(1,

完整性参数表[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (文本框[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (文本框[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

} else if (完整性参数表[i1][3].indexOf(",") > 0) {

if (("," + 完整性参数表[i1][3] + ",").indexOf(","

+ 文本框[b].getText() + ",") < 0) {

c = b;

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

}

}

} else

c = 0;

}

}

if (bz.length() > 0)

break;

}

} catch (Exception e1) {

JOptionPane.showMessageDialog(null, "数据完整性约束条件设置不满足格式要求，请修改接口参数表！"

+ e1);

}

if (bz.length() > 0) {

if (c > 0) {

JOptionPane.showMessageDialog(null, "填入的数据违反数据完整性约束条件。请检查！"

+ bz);

bz = "";

return false;

}

}

return true;

}

   }

81.源码81，部件程序，表单程序，用于多对多表之间联系表的数据维护。

/**

 * 程序文件名：dataTenance8.java

 * 作者：程学先 

 * 程序功能：多对多表之间联系表的数据维护。

 * 多对多表称为主表1和主表2，本程序只适应每表主键均为单字段情况。

 * 多对多关系之间应当存在一个联系表，其主键为二个多方关系的主键，分别为多方表外键。

 * 向联系表录入数据时外键数据来自多方表，应当率先自动填入，

 * 操作者只录入联系自身属性值，这样既减少工作量且有效减少出错可能，是实现参照完整性保护常见手段。

 * 本程序要求首先确定从多方表取主键数据到联系表的条件，例如在学生表中设定：专业='计算机技术'

 * 在课程表中确定：课号='2'。注意均采用单引号。

 * 之后，自动查找联系表中与之同名的字段，从多方表满足条件的记录中取出关键字数据填到表格中，

 * 将原联系表中非关键字字段数据填入表格，显示在窗口中。

 * 再由操作者填写其他新的数据，完成后将表格数据区分添加方式或修改方式录入到数据表中。

 * 完成日期：2014年1月20日

 * 被调用语句：dataTenance8.means(parameter);

 * 必须提供的参数：“主表1表名”、“主表2表名”、联系“表名”、联系表“关键字段名”。

 * 可选择输入的参数：多方表名1相关的"条件表达式1"、多方表2相关的"条件表达式2"、“窗口宽”、“窗口高” 等。

 * 联系表主键必须分别是二个多方表的主键，且同名。

 * 本部件预设的按钮控件“从表格删除”、“存入数据库”、“表格更新”、“退出”共 4个。

 * 从表格删除指从显示的临时表格中删除，当时不删除数据表中数据。

 * 全部录入、修改、删除完成后必须点击“存入数据库”按钮完成数据录入操作。

 * 如果重新设置条件表达式，需要点击“表格更新”按钮重建表格，表格中原有数据将删除。

 */

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableColumn;

public class dataTenance8 extends JFrame 

{

  static dataTenance8 frame1=new dataTenance8();

static JTextField 文本框1;

static JTextField 文本框2;

private static JLabel fl1,fl2;

private static Connection cont4; 

private static Statement stat4;   

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;  

private static String 主表名1; 

private static String 主表名2; 

private static String 表名 ; 

private static int 窗口宽 =main1.窗口宽;

private static int 窗口高 = main1.窗口高;

private static int 列数; 

private static int 列数1; 

private static int 列数2; 

private static String[] 列名; 

private static String[] 列名1; 

private static String[] 列名2; 

private static String[] 列数据类型; 

private static String[] 列数据类型1; 

private static String[] 列数据类型2; 

private static int[] 列数据宽度; 

private static int[] 列数据宽度1; 

private static int[] 列数据宽度2; 

private static int 记录条数=0;

private static int 记录条数1=0;

private static int 记录条数2=0;

private static String[][] 表格数据;

private static String[][] 表格数据1;

private static String[][] 表格数据2;

private static String[][] 表格数据3;

private static String 键盘输入字串="";

private static JTable 表格;

static DefaultTableModel 表格模型;

private static String[] 关键字段名;

private static String[] 关键字段值;

private static int[] 关键字序号; 

private static int 关键字序号1; 

private static int 关键字序号2; 

private static String 条件表达式1="",条件表达式2="";

private static String s1="",s2="",s3="";//,s4=""; 

private static int b = 0, c = 0,行号=0,列号3=0;

private static String[] 按钮集={"从表格删除","存入数据库","更新表格","退出"};

private static  JButton 从表格删除,存入数据库,退出;

static int 按钮数=0,按钮宽=0;

private static String 要求按钮号表;

private static int 字符宽度=15,字符高度=20;   

static int 起始左边距;

static int 文本域高度;

private static int 按钮位置[][];

static int 大数据个数;

private static int 按钮定义标志,实际按钮数;

 static void means(String parameter[])  {

frame1=new dataTenance8();

窗口宽 =main1.窗口宽;

窗口高 = main1.窗口高;

记录条数=0;记录条数1=0;记录条数2=0;

键盘输入字串="";文本域高度=0;

s1="";s2="";s3=""; b = 0; c = 0;行号=0;列号3=0;

字符宽度=15;字符高度=20; 按钮定义标志=0;实际按钮数=0;

  String[] 按钮集01={"从表格删除","存入数据库","更新表格","退出"};

   按钮集=new String[按钮集01.length];

   按钮数=0;

   for (int i0=0;i0<按钮集01.length;i0++)

     按钮集[i0]= 按钮集01[i0];

if (parameter[11].length()>0){

要求按钮号表=parameter[11] ;// 需要显示的按钮的顺序号

要求按钮号表=要求按钮号表.replaceAll("；",";");

要求按钮号表=要求按钮号表.replaceAll("。",";");

要求按钮号表=要求按钮号表.replaceAll(":",";");

要求按钮号表=要求按钮号表.replaceAll("：",";");

if (要求按钮号表.indexOf(";")>0){   //如果有按钮更名要求

String s601[]=要求按钮号表.split(",");

要求按钮号表="";

for (int i01=0;i01<s601.length;i01++){

if (s601[i01].indexOf(";")>0){

String s602[]=s601[i01].split(";");

按钮集[Integer.parseInt((s602[0]))]=s602[1];

要求按钮号表=要求按钮号表+","+s602[0];//只留号，去更名

}

else {

要求按钮号表=要求按钮号表+","+s601[i01];//只留号，原无更名

}

}

}   //如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样

else {

String s601[]=要求按钮号表.split(",");

要求按钮号表="";

for (int i01=0;i01<s601.length;i01++){

          if (i01==0) 要求按钮号表=s601[i01];

          else 要求按钮号表=要求按钮号表+","+s601[i01];

   }

}

}

else {

要求按钮号表="";  //没输入要求按钮号，定全部按钮号

for (int i1=0;i1<按钮集.length;i1++){

if (i1==0) 要求按钮号表=要求按钮号表+i1;

else 要求按钮号表=要求按钮号表+","+i1;

}

}

要求按钮号表=","+要求按钮号表+",";

要求按钮号表=要求按钮号表.replaceAll(",,",",");

按钮数=按钮集.length;    //可以供选择的按钮数

窗口宽=main1.窗口宽;  窗口高=main1.窗口高;

int m1,m2;

try{

if (parameter[17].length()==0) {

m1=0;m2=0;

}

else {

m1=Integer.parseInt(parameter[17]) ;//宽度参数

m2=Integer.parseInt(parameter[18]) ;

}

if (m1>0){

if (m2<80){

m1=m1*10;

m2=m2*10;

}

   窗口宽=m1 ;

   窗口高=m2 ;

}

}catch(Exception e2){}

主表名1=parameter[2] ; // 数据表名

主表名2=parameter[3] ; 

表名=parameter[4] ; 

    if (parameter[6].length()<=0){

       JOptionPane.showMessageDialog( null, "缺少关键字，请说明关键字字段后再运行。");

       return;

    }

关键字段名=parameter[6].split(",");

条件表达式1=parameter[13] ; 

条件表达式2=parameter[14] ;

关键字序号=new int[关键字段名.length];

frame1.setTitle("多对多表数据维护程序                           作者：程学先");  

frame1.setBounds(0, 0,窗口宽, 窗口高);   

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);   

       fl1=new JLabel(主表名1+"条件表达式");

       fl1.setBounds(30,20,120, 20);

       frame1.add(fl1);  //定义文本框的标签

       文本框1 = new JTextField(条件表达式1,20);  

       文本框1.setBounds(150,20,200, 20);

       frame1.add(文本框1);       //加入文本框

       fl2=new JLabel(主表名2+"条件表达式");

       fl2.setBounds(350,20,120, 20);

       frame1.add(fl2);  

       文本框2 = new JTextField(条件表达式2,20);  

       文本框2.setBounds(470,20,200, 20);

       frame1.add(文本框2);       //加入文本框

计算文本框002();

if ((条件表达式1.trim().length()>0)&&(条件表达式2.trim().length()>0))

refresh();

从表格删除 = new JButton(按钮集[0]);

从表格删除.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int 选中行号 = 表格.getSelectedRow(); 

         if (选中行号 != -1) 

             表格模型.removeRow(选中行号);

 }

});

if (要求按钮号表.lastIndexOf(",0,")>=0){

从表格删除.setBounds(按钮位置[0][0],按钮位置[0][1],按钮位置[0][2],按钮位置[0][3]);          

frame1.add(从表格删除);

}

存入数据库 = new JButton(按钮集[1]);

存入数据库.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String 类型=main1.数字数据类型; 

  try{

   cont4=main1.getConn();

   stat4 = cont4.createStatement(

             ResultSet.TYPE_SCROLL_INSENSITIVE,   

                      ResultSet.CONCUR_UPDATABLE);  

   记录条数1=表格模型.getRowCount(); 

                int f0=0;

   for (int i=0;i<记录条数1;i++)  { 

                   f0=0;

       s3="";

       for (int j=0;j<关键字序号.length;j++){

       s3=s3+表格模型.getValueAt(i,关键字序号[j]).toString().trim();

       }

       for (int i1=0;i1<记录条数;i1++){

    if (关键字段值[i1].toLowerCase().trim().equals(s3.toLowerCase().trim())){

    f0=1;

    break;

    }

       }

    if (f0==0){  

                   s1="insert into "+表名+" (";

                   for (int k1=0;k1<列名.length;k1++)

                    s1=s1+列名[k1]+",";   

                   s1=s1.substring(0,s1.length()-1)+" ) values (";

// System.out.println("0s1="+s1);

               for (int j=0;j<列名.length;j++){

              if (类型.lastIndexOf(","+列数据类型[j]+",")>=0){

              if ((表格模型.getValueAt(i,j)==null)||

              (表格模型.getValueAt(i,j).toString().trim().length()<1))

              s1=s1+"0";

              else s1=s1+表格模型.getValueAt(i,j).toString().trim();

              }

              else{

              if (表格模型.getValueAt(i,j)==null) 

              s1=s1+"' '";

            else s1=s1+"'"+表格模型.getValueAt(i,j).toString().trim()+"'";

                  }

               if (j!=列名.length-1) s1=s1+",";

               }

                s1=s1+")";

                stat4.executeUpdate(s1);

    }

    else {  

               s1="update "+表名+" set ";

               for (int k1=0;k1<列名.length;k1++){

                s1=s1+列名[k1]+"="; 

                    if (类型.lastIndexOf(","+列数据类型[k1]+",")>=0){

                 if ((表格模型.getValueAt(i,k1)==null) ||

                 (表格模型.getValueAt(i,k1).toString().trim().length()<1))

                 s1=s1+"0";

                 else s1=s1+表格模型.getValueAt(i,k1).toString().trim();

                }

                else{

                  if (表格模型.getValueAt(i,k1)==null)   s1=s1+"' '";

                  else s1=s1+"'"+表格模型.getValueAt(i,k1).toString().trim()+"'";

              }

              if (k1!=列名.length-1) s1=s1+",";

           }

                 s2=" where ";

             for (int k=0;k<关键字序号.length;k++){

            s2=s2+关键字段名[k]+"='"+表格数据[i][关键字序号[k]]+"'";

            if (k<关键字段名.length-1) s2=s2+" and ";

             }

               s1=s1+s2;

                stat4.executeUpdate(s1);

       }

   }

 stat4.close();     //关闭连接

       cont4.close();

  }

     catch(SQLException e1) 

     {

    JOptionPane.showMessageDialog( null, "操作出错，请检查数据表名是否重复，录入语句是否正确！"+s1);

     } 

}

});

if (要求按钮号表.lastIndexOf(",1,")>=0){

存入数据库.setBounds(按钮位置[1][0],按钮位置[1][1],按钮位置[1][2],按钮位置[1][3]);          

frame1.add(存入数据库);

}

 

JButton 更新表格 = new JButton(按钮集[2]);

更新表格.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

条件表达式1=文本框1.getText(); 

条件表达式2=文本框2.getText();

refresh();

}

});

if (要求按钮号表.lastIndexOf(",2,")>=0){

更新表格.setBounds(按钮位置[2][0],按钮位置[2][1],按钮位置[2][2],按钮位置[2][3]);          

frame1.add(更新表格);

}

退出 = new JButton(按钮集[3]);

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

  frame1.setVisible(false); 

    frame1.dispose();

}

});

if (要求按钮号表.lastIndexOf(",3,")>=0){

退出.setBounds(按钮位置[3][0],按钮位置[3][1],按钮位置[3][2],按钮位置[3][3]);          

frame1.add(退出);

}

    frame1.setVisible(true);  

}

static void 计算文本框002(){   //如果没有接口参数表，计算控件位置、大小参数

int 起始到顶距=0;

//计算按钮位置

if (按钮定义标志>0) return; 

要求按钮号表=",0,1,2,3,";

String [] t5=要求按钮号表.split(",");

实际按钮数=t5.length - 1;

按钮位置=new int[按钮数][15];

for (int j = 0; j < 按钮数; j++){

按钮位置[j][0]=0;   

按钮位置[j][1]=0; 

按钮位置[j][2]=0;

按钮位置[j][3]=0;

   }

int 按钮宽度;

按钮宽度=(int)(字符宽度*12);

起始左边距=20;

if (大数据个数==0)

    起始到顶距=起始到顶距+字符高度*2;

else 起始到顶距=起始到顶距+字符高度;

int 一行按钮数=(窗口宽-30)/(int)(6.6*字符宽度);

if (一行按钮数<1) 一行按钮数=1;    //每行最少一个按钮

if (实际按钮数<=一行按钮数)  按钮宽度=(窗口宽-60)/实际按钮数;

else 按钮宽度=(窗口宽-60)/一行按钮数; 

      int n=0,n1=0,n3=0;   //n：当行按钮数，n1：已排按钮数,n3:一行按钮宽

      n3=一行按钮数*按钮宽度;

for (int j = 0; j < 按钮数; j++){ 

   if (要求按钮号表.lastIndexOf(","+j+",")>=0){

按钮位置[j][0]=起始左边距;   

按钮位置[j][1]=起始到顶距; 

if (按钮集[j].length()>4) {

按钮位置[j][2]=(int)(按钮集[j].length()*(字符宽度*2));

n3=n3+按钮位置[j][2]-按钮宽度;

起始左边距=起始左边距+按钮位置[j][2];

}

else {

按钮位置[j][2]=按钮宽度;   

起始左边距=起始左边距+按钮宽度;

}

按钮位置[j][3]=字符高度;

n++;

n1++;

            if (实际按钮数-n1==0) break;

     if ((n>=一行按钮数)&&((实际按钮数-n1)-一行按钮数!=0)) {  //如果按钮换行

        起始左边距=20;

        起始到顶距=起始到顶距+字符高度+20;

  if ((实际按钮数-n1)<=一行按钮数)  按钮宽度=(窗口宽-60)/(实际按钮数-n1);

  else 按钮宽度=(窗口宽-60)/一行按钮数;  

        n=0;

       }

     else if (n>=一行按钮数){  

    起始左边距=20;

    起始到顶距=起始到顶距+字符高度+20;

      n=0;

       }

}

}

窗口高=起始到顶距+字符高度+100;

}

 

  public static  void refresh(){

try

{ 

cont4=main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE); 

s1 = "select * from " + 主表名1; 

if (条件表达式1.length()>0)

s1=s1+" where "+条件表达式1;

rs = stat4.executeQuery(s1);

rs.last(); 

记录条数1 = rs.getRow();

rsmdt4 = rs.getMetaData();

列数1 = rsmdt4.getColumnCount();

列名1 = new String[列数1]; 

列数据类型1 = new String[列数1]; 

列数据宽度1 = new int[列数1]; 

表格数据1= new String[记录条数1][列数1]; 

for (int i=0;i<列数1;i++) {

    列名1[i] = rsmdt4.getColumnName(i + 1);     

列数据类型1[i] = rsmdt4.getColumnTypeName(i + 1);

列数据宽度1[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

      for (int j = 0; j< 关键字段名.length; j++)

        for (int i=0;i<列数1;i++){

           if (关键字段名[j].toLowerCase().trim().equals(列名1[i].toLowerCase().trim())) {

              关键字序号1 = i;   

               break;

           }

           }

rs.absolute(1); 

c = 0; 

b = 0; 

while (c < 记录条数1)

{

rs.absolute(c + 1); 

while (b < 列数1)

{

表格数据1[c][b] = rs.getString(b + 1); 

b++;

}

c++;

b = 0;

}

      rs.close();

     stat4.close();

     cont4.close();

  } catch (SQLException e)

{

JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1);

}

     if (主表名2.length()>0){

try

{ 

cont4=main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE); 

s1 = "select * from " + 主表名2; 

if (条件表达式2.length()>0)

s1=s1+" where "+条件表达式2;

rs = stat4.executeQuery(s1);

rs.last(); 

记录条数2 = rs.getRow();

rsmdt4 = rs.getMetaData();

列数2 = rsmdt4.getColumnCount();

列名2 = new String[列数2]; 

列数据类型2 = new String[列数2]; 

列数据宽度2 = new int[列数2]; 

表格数据2= new String[记录条数2][列数2]; 

for (int i=0;i<列数2;i++) {

    列名2[i] = rsmdt4.getColumnName(i + 1);     

列数据类型2[i] = rsmdt4.getColumnTypeName(i + 1);

列数据宽度2[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

      for (int j = 0; j< 关键字段名.length; j++)

        for (int i=0;i<列数2;i++){

           if (关键字段名[j].toLowerCase().trim().equals(列名2[i].toLowerCase().trim())) {

              关键字序号2 = i;  

               break;

           }

           }

rs.absolute(1); 

c = 0; 

b = 0; 

while (c < 记录条数2)

{

rs.absolute(c + 1); 

while (b < 列数2)

{

表格数据2[c][b] = rs.getString(b + 1); 

b++;

}

c++;

b = 0;

}

      rs.close();

     stat4.close();

     cont4.close();

  } catch (SQLException e)

{

JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1);

}

     }

  try

{ 

cont4=main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE); 

s1 = "select * from " + 表名; 

rs = stat4.executeQuery(s1);

rs.last(); 

记录条数 = rs.getRow();

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[列数]; 

列数据类型 = new String[列数]; 

列数据宽度 = new int[列数]; 

表格数据3=new String[记录条数][列数];

for (int i=0;i<列数;i++) {

    列名[i] = rsmdt4.getColumnName(i + 1);     

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

}   

      for (int j = 0; j< 关键字段名.length; j++)

        for (int i=0;i<列数;i++){

           if (关键字段名[j].toLowerCase().trim().equals(列名[i].toLowerCase().trim())) {

               关键字序号[j] = i;  

               break;

           }

      }

rs.absolute(1); 

c = 0; 

b = 0; 

while (c < 记录条数){

rs.absolute(c + 1); 

while (b < 列数) {

表格数据3[c][b] = rs.getString(b + 1); 

b++;

}

c++;

b = 0;

}

关键字段值=new String[记录条数];

for (int j=0;j<记录条数;j++){

关键字段值[j]="";

for (int i=0;i<关键字段名.length;i++){

关键字段值[j]=关键字段值[j]+表格数据3[j][关键字序号[i]].trim();

}

}

      rs.close();

     stat4.close();

     cont4.close();

  } catch (SQLException e)

{

JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1);

}

       if (记录条数2==0)

表格数据=new String[记录条数1][列数];

else 表格数据=new String[记录条数1*记录条数2][列数];

             for (int i=0;i<记录条数1;i++)

            for (int j=0;j<列数;j++)

            表格数据[i][j]="";

             if (记录条数2>0)

            for (int i=0;i<记录条数1;i++)

            for (int j=0;j<记录条数2;j++){

            表格数据[i][关键字序号[0]]=表格数据1[i][关键字序号1];

                表格数据[i][关键字序号[1]]=表格数据2[j][关键字序号2];

             }

             else

            for (int i=0;i<记录条数1;i++){

            表格数据[i][关键字序号[0]]=表格数据1[i][关键字序号1];

             }

             for (int i=0;i<表格数据.length;i++)

            for (int j=0;j<表格数据3.length;j++)

            if ((表格数据[i][关键字序号[0]].trim()+表格数据[i][关键字序号[1]].trim())

            .equals(表格数据3[j][关键字序号[0]]+表格数据3[j][关键字序号[1]])){

            for (int k=0;k<列数;k++){

            if ((k!=关键字序号[0])&&(k!=关键字序号[1]))

            表格数据[i][k]=表格数据3[j][k];

            }

            }

 表格模型 = new DefaultTableModel(表格数据,列名);

 表格 = new JTable(表格模型);

 表格.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

 表格.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

 for(int i=0;i<列数;i++) { 

     TableColumn tc = 表格.getColumn(列名[i]);

     if (列名[i].length()>列数据宽度[i]) 列数据宽度[i]=列名[i].length();

     tc.setPreferredWidth(列数据宽度[i]*11);

     tc.setMaxWidth(列数据宽度[i]*11);

     tc.sizeWidthToFit();  

 }

窗口高=650;

 final JScrollPane scrollPane = new JScrollPane();  

 scrollPane.setBounds(30,80,窗口宽-100,窗口高-150);

  frame1.setBounds(10,10,窗口宽,窗口高);

 scrollPane.setViewportView(表格);

 frame1.add(scrollPane, BorderLayout.CENTER); 

表格.addKeyListener(new KeyAdapter()

{ 

public void keyPressed(KeyEvent evt) { 

键盘输入字串=键盘输入字串+evt.getKeyChar();

} 

});

表格.addMouseListener(new MouseAdapter() { 

     public void mouseClicked(MouseEvent e) {

         键盘输入字串="";

    }        

  });

表格.addFocusListener(new FocusAdapter() {  

  public void focusLost(final FocusEvent arg0) { 

行号 = 表格.getSelectedRow();

列号3 = 表格.getSelectedColumn();

表格模型.setValueAt(键盘输入字串, 行号,列号3);

    }

});

  }

}

版本2

80.源码80，部件程序，表单程序，一对多表多方子表数据维护部件，运行时同时显示主表与子表，对子表提供录入、修改、删除操作功能。提供安全性、域完整性、实体完整性及参照完整性保护。对主表只提供删除操作功能。

/** 

 * 程序文件名：dataTenance7.java 

 * 作者：程学先  

 * 功能：一对多表多方子表数据维护部件，运行时同时显示主表与子表，对子表提供录入、修改、删除操作功能。 

 * 对主表只提供删除操作功能，提供安全性、域完整性、实体完整性及参照完整性保护。 

 * 在主表中删除一条记录时会提问是否同时删除子表中相匹配的记录，在肯定后删除子表中相关记录。 

 * 关键字段名为子表的关键字，是识别与区分子表记录的主要标志，不允许重复，不允许为空， 

 * 可以是单一字段，也可以是多个字段，如果是多字段，以英文逗号分隔。 

 * 外键指主表与子表中同名字段，可以是单个字段，也可以是多字段。如果是多字段，以英文逗号分隔。 

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

public class dataTenance7 extends JFrame {

static dataTenance7 frame1 = null;

static dataTenance7 frame2 = null;

static JTextField[] variabl2403 = null;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String variabl2277;

private static String variabl2603 = "";

private static int variabl2483 = main1.variabl2483;

private static int variabl24831 = 300;

private static int variabl2503 = main1.variabl2503 - 100;

private static int variabl2651 = 0;

private static int variabl26512 = 0, variabl1739 = 0;

private static String[] variabl2517 = null;

private static String[] variabl25170 = null;

private static String[] variabl25172 = null;

private static String variabl1325 = "";

private static String variabl13252 = "", variabl2803 = "";

private static String[] variabl1501 = null;

private static String[] variabl15012 = null;

private static int[] variabl1489 = null;

private static int[] variabl14892 = null;

private static int variabl1853 = 0;

private static int variabl18531 = 0;

private static int variabl18532 = 0;

private static JTable variabl2655;

static DefaultTableModel variabl1965;

private static String[][] variabl2197 = null;

private static String[][] variabl21972 = null;

private static String[] variabl14192 = null;

static String[][] variabl1701 = null;

private static String variabl1187 = "";

private static int variabl1371 = 0;

private static String variabl1153 = "";

private static String variabl11532 = "";

private static String[] variabl15072 = null;

private static String[] variabl1525 = null;

private static int[] variabl1287 = null;

private static String[] variabl2379 = null;

private static String variabl15932 = "";

private static int[] variabl2105 = null;

private static int[] variabl21050 = null;

private static int[] variabl21051 = null;

private static String s1 = "", s2 = "";

private static int b = 0, c = 0;

private static int variabl1843 = 0;

private static JLabel[] variabl2165 = null;

private static int variabl1647 = 15, variabl1849 = 20;

private static String[] variabl2405;

private static JButton variabl2375, variabl2325, variabl1971, variabl2255,

variabl2531, variabl2611, variabl2601, variabl1697, variabl2633,

variabl2599;

private static ArrayList<String> list = new ArrayList<String>();

private static ArrayList<String> list0 = new ArrayList<String>();

private static String[][] variabl1323 = null;

private static String[][] variabl1651 = null;

private static String[][] variabl1201 = null;

private static String[][] variabl1197 = null;

private static String[][] variabl1837 = new String[0][0];

private static int variabl1233 = 0, variabl1077 = 0, variabl1069 = 0;

public static String username = main1.username;

public static int variabl2607 = 9, variabl2659 = 5;

private static String variabl1597 = main1.variabl1537 + main1.variabl1539;

private static int variabl3681 = 0;

private static int variabl1459 = 0;

private static int[] variabl14672 = null;

private static int variabl1637 = 0;

private static JPanel panel2 = new JPanel(false);

private static int variabl1745 = variabl2483;

private static int variabl1315 = 0;

private static int variabl1473 = 0;

private static int variabl1925 = 0;

private static JTextArea[] variabl2463 = null;

private static JComboBox[] variabl2359 = null;

private static JTextComponent[] variabl17332 = null;

private static String[][] variabl1431 = null;

private static String variabl2429 = "";

private static String variabl1873 = "";

private static int[][] variabl1885 = null;

private static JButton[] variabl2185 = new JButton[15];

public static String[] sw = new String[11];

static int variabl2851 = 0, variabl2339 = 0;

private static int variabl2833;

private static HashSet set01 = new HashSet();

public static String sd0;

static void means(String parameter[]) {

variabl26512 = 0;

variabl1739 = 0;

variabl1325 = "";

variabl13252 = "";

variabl18532 = 0;

variabl18531 = 0;

variabl1187 = "";

variabl1371 = 0;

variabl1153 = "";

variabl11532 = "";

s1 = "";

s2 = "";

b = 0;

c = 0;

variabl1843 = 0;

variabl1647 = 18;

variabl1849 = 20;

variabl1233 = 0;

variabl1077 = 0;

variabl1069 = 0;

variabl2607 = 9;

variabl2659 = 5;

variabl3681 = 0;

variabl1459 = 0;

variabl2483 = main1.variabl2483;

variabl24831 = 300;

variabl2503 = main1.variabl2503 - 100;

variabl1637 = 0;

variabl1745 = variabl2483;

variabl1315 = 0;

variabl1473 = 0;

variabl1925 = 0;

variabl2429 = "";

variabl1873 = "";

variabl2833 = 0;

list0 = new ArrayList<String>();

variabl1837 = new String[0][0];

username = main1.username;

variabl2339 = 0;

sw = new String[11];

sw[1] = main1.sw1 + "";

sw[2] = main1.sw2;

sw[3] = main1.sw3;

sw[4] = main1.sw4;

sw[5] = main1.sw5;

sw[6] = main1.sw6;

sw[7] = main1.sw7;

sw[8] = main1.sw8;

sw[10] = main1.sw10;

main1.sw1 = 0;

main1.sw2 = "";

main1.sw3 = "";

main1.sw4 = "";

main1.sw5 = "";

main1.sw6 = "";

main1.sw7 = "";

main1.sw8 = "";

main1.sw9 = "";

main1.sw10 = "";

String variabl240501[] = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘",

"清屏", "修改存盘", "删除", "退出" };

variabl2405 = new String[variabl240501.length];

variabl2851 = 0;

for (int i0 = 0; i0 < variabl240501.length; i0++)

variabl2405[i0] = variabl240501[i0];

if (parameter[11].length() > 0) {

variabl1187 = parameter[11];

variabl1187 = variabl1187.replaceAll("；", ";");

variabl1187 = variabl1187.replaceAll("。", ";");

variabl1187 = variabl1187.replaceAll(":", ";");

variabl1187 = variabl1187.replaceAll("：", ";");

if (variabl1187.indexOf(";") > 0) {

String s601[] = variabl1187.split(",");

variabl1187 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (s601[i01].indexOf(";") > 0) {

String s602[] = s601[i01].split(";");

variabl2405[Integer.parseInt((s602[0]))] = s602[1];

variabl1187 = variabl1187 + "," + s602[0];

} else {

variabl1187 = variabl1187 + "," + s601[i01];

}

}

} else {

String s601[] = variabl1187.split(",");

variabl1187 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (i01 == 0)

variabl1187 = s601[i01];

else

variabl1187 = variabl1187 + "," + s601[i01];

}

}

} else {

variabl1187 = "";

for (int i1 = 0; i1 < variabl2405.length; i1++) {

if (i1 == 0)

variabl1187 = variabl1187 + i1;

else

variabl1187 = variabl1187 + "," + i1;

}

}

variabl1187 = "," + variabl1187 + ",";

variabl1187 = variabl1187.replaceAll(",,", ",");

variabl2851 = variabl2405.length;

variabl1885 = new int[variabl2851][15];

int m1, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

variabl2483 = m1;

variabl1745 = m1;

variabl2503 = m2;

}

} catch (Exception e2) {

}

frame1 = new dataTenance7();

frame1.setTitle("主表数据记录");

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

panel2 = new JPanel(true);

frame2 = new dataTenance7();

frame2.setTitle("子表数据维护窗口                           作者：程学先");

frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame2.getContentPane().setLayout(null);

frame2.getContentPane().add(panel2, null);

list = new ArrayList<String>();

variabl1597 = main1.variabl1537 + main1.variabl1539;

variabl2185 = new JButton[20];

panel2.setLayout(null);

variabl2277 = parameter[2];

variabl2429 = "," + parameter[0] + ",";

variabl2603 = parameter[4];

String[] t1 = parameter[0].split(",");

variabl13252 = parameter[19];

String[] t2 = parameter[19].split(",");

variabl1873 = "";

if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0)

for (int i = 0; i < t1.length; i++)

if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0) {

variabl1873 = t1[i];

variabl10091();

}

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

variabl1525 = parameter[6].split(",");

variabl2379 = parameter[7].split(",");

variabl1153 = parameter[8];

variabl11532 = parameter[9];

variabl2803 = "," + parameter[9] + ",";

variabl1287 = new int[variabl1525.length];

variabl2105 = new int[variabl2379.length];

variabl21050 = new int[variabl2379.length];

String variabl13250 = "";

if (variabl11532.length() > 0) {

String[] t3 = variabl11532.split(",");

for (int i = 0; i < t3.length; i++) {

if (i > 0)

variabl13250 = variabl13250 + ","

+ t2[Integer.parseInt(t3[i])];

else

variabl13250 = t2[Integer.parseInt(t3[i])];

}

variabl13252 = variabl13250;

for (int i = 0; i < variabl1525.length; i++)

if (("," + variabl13252 + ",").indexOf("," + variabl1525[i]

+ ",") < 0)

variabl13252 = variabl13252 + "," + variabl1525[i];

}

t2 = variabl13252.split(",");

variabl14672 = new int[t2.length];

variabl1651 = new String[t2.length][6];

variabl1323 = new String[t2.length][15];

variabl1885 = new int[variabl2851][15];

if (parameter[5].length() > 1) {

File file1 = new File(parameter[5]);

try {

if (file1.exists()) {

FileReader fr = new FileReader(file1);

BufferedReader br = new BufferedReader(fr);

String tempStr = null;

int d2 = 0;

int k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1)

list0.add(tempStr);

}

String sk = "";

for (int i = 0; i < list0.size(); i++) {

sk = list0.get(i);

if (d2 == 0) {

list.add(sk);

if (sk.substring(0, 2).equals("1,"))

variabl1233++;

if (sk.substring(0, 2).equals("2,"))

variabl1069++;

if (sk.substring(0, 2).equals("3,"))

variabl1077++;

}

}

variabl1371 = k3;

if (k3 > 0) {

variabl2833 = 1;

}

if (variabl1233 > 0) {

variabl1323 = new String[variabl1233][13];

variabl1651 = new String[variabl1233][6];

} else {

variabl1323 = new String[t2.length][13];

variabl1651 = new String[t2.length][6];

}

variabl1197 = new String[variabl1069][4];

variabl1201 = new String[variabl1077][6];

int m3 = 0;

m1 = 0;

m2 = 0;

int y = 2, n1 = 0;

String s = "";

s2 = ",";

variabl2483 = 0;

for (int i = 0; i < list.size(); i++) {

s = list.get(i);

if (d2 == 0) {

if (s.substring(0, 2).equals("1,")) {

variabl1323[m1] = s.substring(2, s.length())

.split("。");

variabl1323[m1][1] = "";

variabl1323[m1][2] = variabl1323[m1][5];

variabl1651[m1][0] = Integer

.parseInt(variabl1323[m1][3])

+ Integer.parseInt(variabl1323[m1][6])

+ "";

variabl1651[m1][1] = variabl1323[m1][7];

if (Integer.parseInt(variabl1323[m1][5])

+ Integer.parseInt(variabl1651[m1][1]) > variabl1459)

variabl1459 = Integer

.parseInt(variabl1323[m1][5])

+ Integer

.parseInt(variabl1651[m1][1]);

if (Integer.parseInt(variabl1323[m1][4])

+ Integer.parseInt(variabl1323[m1][6])

+ 80 > variabl2483)

variabl2483 = Integer

.parseInt(variabl1323[m1][4])

+ Integer

.parseInt(variabl1323[m1][6])

+ 80;

variabl1651[m1][2] = "";

variabl1651[m1][3] = "";

variabl1651[m1][4] = "";

s2 = s2 + variabl1323[m1][0] + ",";

m1++;

variabl1233 = m1;

} else if (s.substring(0, 2).equals("2,")) {

y = 2;

n1 = 0;

int n0 = 0;

String[] sf = s.split("。");

variabl1197[m2][0] = sf[0];

variabl1197[m2][1] = sf[1];

variabl1197[m2][2] = sf[2];

sf = variabl1197[m2][0].split(",");

variabl1197[m2][0] = sf[1];

if ((variabl1197[m2][0]

.equalsIgnoreCase(username))

&& (variabl1197[m2][2].length() > 0)

&& (variabl1197[m2][2].indexOf("a") < 0)

&& ((variabl1197[m2][1].length() == 0)

|| (variabl1197[m2][1]

.equals("*")) || (variabl1197[m2][1]

.toLowerCase()

.equalsIgnoreCase(variabl2603

.toLowerCase())))) {

if (variabl1197[m2][2].indexOf("i") < 0) {

variabl1187 = variabl1187.replaceAll(

"5,", "");

n0 = 1;

}

if (variabl1197[m2][2].indexOf("u") < 0) {

variabl1187 = variabl1187.replaceAll(

"7,", "");

n0 = 1;

}

if (variabl1197[m2][2].indexOf("d") < 0) {

variabl1187 = variabl1187.replaceAll(

"8,", "");

n0 = 1;

}

n0 = 1;

} else if ((variabl1197[m2][0]

.equalsIgnoreCase(username))

&& (variabl1197[m2][2].length() > 0)

&& (variabl1197[m2][2].indexOf("a") < 0)

&& (variabl1197[m2][2].indexOf("d") < 0)) {

variabl1187 = variabl1187.replaceAll("8,",

"");

n0 = 1;

} else if ((variabl1197[m2][0]

.equalsIgnoreCase(username))

&& (variabl1197[m2][2].length() > 0)

&& (variabl1197[m2][2].indexOf("a") < 0)

&& (variabl1197[m2][2].indexOf("i") < 0)

&& (variabl1197[m2][2].indexOf("u") < 0)) {

variabl1197[m2][0] = "只读";

variabl1197[m2][2] = "q,";

}

if (n0 == 0) {

m2++;

variabl1069 = m2;

}

} else if (s.substring(0, 2).equals("3,")) {

y = 2;

n1 = 0;

for (int k = 2; k < s.length(); k++)

if (s.substring(k, k + 1).equals("。")) {

variabl1201[m3][n1] = s.substring(y, k);

y = k + 1;

n1++;

}

variabl1201[m3][n1] = s

.substring(y, s.length());

if (variabl1201[m3][3].isEmpty())

variabl1201[m3][3] = "";

m3++;

variabl1077 = m3;

}

}

variabl14672 = new int[variabl1323.length];

variabl14192 = new String[variabl1323.length];

}

if (variabl1233 > 0) {

variabl13252 = "";

for (int i = 0; i < variabl1233; i++) {

if (i == 0)

variabl13252 = variabl1323[i][0];

else

variabl13252 = variabl13252 + ","

+ variabl1323[i][0];

}

}

}

} catch (IOException e2) {

JOptionPane.showMessageDialog(null, "打开文件错！");

}

} else {

variabl1323 = new String[t2.length][13];

variabl1651 = new String[t2.length][6];

variabl1197 = new String[0][4];

variabl1201 = new String[0][6];

variabl14672 = new int[t2.length];

variabl14192 = new String[t2.length];

}

for (int i = 0; i < variabl1069; i++) {

t2 = variabl13252.split(",");

for (int j = 0; j < t2.length; j++) {

if (variabl1197[i][1].toLowerCase()

.indexOf(t2[j].toLowerCase()) >= 0) {

if (variabl1197[i][0].equals("只读"))

variabl2803 = variabl2803 + j + ",";

variabl1197[i][1] = j + "";

}

}

}

if (variabl2483 == 0)

variabl2483 = variabl1745;

variabl1005(variabl2603);

variabl1009(variabl2603);

if (variabl1233 == 0)

variabl1037();

variabl2819002();

variabl2817002();

String sd = "";

for (int i0 = 0; i0 < variabl18532; i0++) {

sd = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1843; i++) {

if (variabl14672[i] == variabl1287[j]) {

if (variabl21972[i0][variabl14672[i]] == null) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + variabl21972[i0][variabl14672[i]].trim()

+ ",";

break;

}

}

}

set01.add(sd);

}

variabl2375 = new JButton(variabl2405[0]);

variabl2375.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl18531 = 0;

for (int i = 0; i < variabl1843; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") >= 0) {

String s3 = variabl21972[variabl18531][variabl14672[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl17332[i]

.setText(variabl21972[variabl18531][variabl14672[i]]);

if ((main1.variabl1545.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",")) >= 0)

if ((variabl17332[i].getText() == null)

|| (variabl17332[i].getText()

.trim().length() < 1))

variabl17332[i].setText("0");

}

}

}

variabl2325.setEnabled(true);

variabl2255.setEnabled(false);

}

});

if (variabl1885[0][0] > 0) {

variabl2375.setBounds(variabl1885[0][0], variabl1885[0][1],

variabl1885[0][2], variabl1885[0][3]);

panel2.add(variabl2375);

}

variabl2325 = new JButton(variabl2405[1]);

variabl2325.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 < variabl18532 - 1) {

variabl18531++;

if (variabl18531 == variabl18532 - 1)

variabl2325.setEnabled(false);

for (int i = 0; i < variabl1843; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") >= 0) {

String s3 = variabl21972[variabl18531][variabl14672[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = {};

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl17332[i]

.setText(variabl21972[variabl18531][variabl14672[i]]);

if ((main1.variabl1545.lastIndexOf(","

+ variabl15012[variabl14672[i]]

+ ",")) >= 0)

if ((variabl17332[i].getText() == null)

|| (variabl17332[i].getText()

.trim().length() < 1))

variabl17332[i].setText("0");

}

}

}

}

variabl2255.setEnabled(true);

}

});

if (variabl1885[1][0] > 0) {

variabl2325.setBounds(variabl1885[1][0], variabl1885[1][1],

variabl1885[1][2], variabl1885[1][3]);

panel2.add(variabl2325);

}

variabl1971 = new JButton(variabl2405[2]);

variabl1971.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18532 > 1)

variabl18531 = variabl18532 - 1;

else

variabl18531 = 0;

for (int i = 0; i < variabl1843; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") >= 0) {

String s3 = variabl21972[variabl18531][variabl14672[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl17332[i]

.setText(variabl21972[variabl18531][variabl14672[i]]);

if ((main1.variabl1545.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",")) >= 0)

if ((variabl17332[i].getText() == null)

|| (variabl17332[i].getText()

.trim().length() < 1))

variabl17332[i].setText("0");

}

}

}

variabl2325.setEnabled(false);

variabl2255.setEnabled(true);

}

});

if (variabl1885[2][0] > 0) {

variabl1971.setBounds(variabl1885[2][0], variabl1885[2][1],

variabl1885[2][2], variabl1885[2][3]);

panel2.add(variabl1971);

}

variabl2255 = new JButton(variabl2405[3]);

variabl2255.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 > 0) {

variabl18531--;

for (int i = 0; i < variabl1843; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") >= 0) {

String s3 = variabl21972[variabl18531][variabl14672[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl17332[i]

.setText(variabl21972[variabl18531][variabl14672[i]]);

if ((main1.variabl1545.lastIndexOf(","

+ variabl15012[variabl14672[i]]

+ ",")) >= 0)

if ((variabl17332[i].getText() == null)

|| (variabl17332[i].getText()

.trim().length() < 1))

variabl17332[i].setText("0");

}

}

}

variabl2325.setEnabled(true);

} else

variabl2255.setEnabled(false);

}

});

if (variabl1885[3][0] > 0) {

variabl2255.setBounds(variabl1885[3][0], variabl1885[3][1],

variabl1885[3][2], variabl1885[3][3]);

panel2.add(variabl2255);

variabl2255.setEnabled(false);

}

variabl2531 = new JButton(variabl2405[4]);

variabl2531.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl2531.getText().trim().equals("浏览")) {

variabl2531.setText("转当前行");

variabl1701 = new String[variabl18532][variabl26512];

int[] n = new int[variabl14892.length];

for (int i = 0; i < variabl18532; i++)

for (int j = 0; j < variabl26512; j++) {

variabl1701[i][j] = variabl21972[i][j];

if (variabl1701[i][j] == null)

variabl1701[i][j] = "";

if (variabl1701[i][j].length() > 50)

variabl1701[i][j] = variabl1701[i][j]

.substring(0, 50);

}

for (int j = 0; j < variabl26512; j++) {

n[j] = variabl14892[j];

if (n[j] > 50)

n[j] = 50;

}

tableTenance.tableModel(variabl2483, variabl2503,

variabl25172, n, variabl1701, variabl15012);

} else {

variabl2531.setText("浏览");

variabl18531 = main1.variabl1327;

for (int i = 0; i < variabl1843; i++) {

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

variabl17332[i]

.setText(variabl21972[main1.variabl1327][variabl14672[i]]);

}

}

}

});

if (variabl1885[4][0] > 0) {

variabl2531.setBounds(variabl1885[4][0], variabl1885[4][1],

variabl1885[4][2], variabl1885[4][3]);

panel2.add(variabl2531);

}

variabl2611 = new JButton(variabl2405[5]);

variabl2611.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int[] x0 = new int[variabl1843];

String[] s0 = new String[variabl1843];

int b = 0;

for (int i = 0; i < variabl1843; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0) {

if ((variabl1651[i][4].equals("组合框"))

|| (variabl1651[i][4].equals("列表框"))) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

variabl14192[i] = (String) variabl2359[variabl1739]

.getSelectedItem();

if (variabl14192[i] == null)

variabl14192[i] = " ";

} else {

variabl14192[i] = variabl17332[i].getText().trim();

if (variabl14192[i] == null) {

variabl14192[i] = " ";

variabl17332[i].setText(variabl15072[i]);

}

}

} else {

variabl14192[i] = "?";

}

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1843; i++) {

if (variabl14672[i] == variabl1287[j]) {

if ((variabl14192[i] == null)

|| (variabl14192[i].trim().length() == 0))

kd0 = 1;

sd = sd + variabl14192[i].trim() + ",";

break;

}

}

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

set01.add(sd);

if (set01.size() == kd) {

JOptionPane.showMessageDialog(null, "关键字重复，请修改后重新生成！");

return;

}

set01.remove(sd);

sd0 = sd;

c = 0;

for (int i = 0; i < variabl1843; i++)

if (!variabl3623(c, i)) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

cont4 = main1.getConn();

try {

variabl18532++;

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "insert into " + variabl2603 + "(";

for (int j = 0; j < variabl1843; j++) {

int a1 = 0;

for (int i = 0; i < variabl1069; i++) {

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((("," + variabl1197[i][1] + ",")

.indexOf("," + j + ",") >= 0)

&& (variabl1197[i][2].indexOf("i") < 0))

a1 = 1;

}

if (a1 == 0)

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[j]] + ",") < 0)

s1 = s1 + variabl25172[variabl14672[j]] + ",";

}

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

sd = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1843; i++) {

if (variabl14672[i] == variabl1287[j]) {

if ((variabl14192[i] == null)

|| (variabl14192[i].trim().length() == 0)) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + variabl14192[i].trim() + ",";

break;

}

}

}

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl17332.length; i++)

if (variabl14672[i] == variabl1287[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl15012[j] + ",") >= 0) {

if (variabl14192[i].length() < 1)

variabl14192[i] = "0";

s2 = s2 + variabl1525[j] + "="

+ variabl14192[i];

} else

s2 = s2 + variabl1525[j] + "='"

+ variabl14192[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

d1: for (int j = 0; j < variabl1843; j++) {

int a2 = 0;

for (int i = 0; i < variabl1069; i++) {

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((("," + variabl1197[i][1] + ",")

.indexOf("," + j + ",") >= 0)

&& (variabl1197[i][2].indexOf("i") < 0)) {

a2 = 1;

continue d1;

}

}

if (main1.variabl1545.lastIndexOf(","

+ variabl15012[variabl14672[j]] + ",") >= 0) {

s1 = s1 + variabl14192[j] + ",";

} else if (variabl14192[j].trim().equals("?")) {

s0[b] = "update " + variabl2603 + " set "

+ variabl25172[variabl14672[j]] + " = ?"

+ " where " + s2;

x0[b] = j;

b++;

} else {

s1 = s1 + "'" + variabl14192[j].trim() + "',";

}

}

s1 = s1.substring(0, s1.length() - 1) + ")";

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

variabl18532++;

set01.add(sd0);

for (int j = 0; j < variabl17332.length; j++) {

variabl21972[variabl18532][j] = "";

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

for (int i = 0; i < b; i++)

variabl4063(s0[i], x0[i]);

for (int i = 0; i < variabl1843; i++)

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

variabl17332[i].setText(variabl15072[i]);

}

});

if (variabl1885[5][0] > 0) {

variabl2611.setBounds(variabl1885[5][0], variabl1885[5][1],

variabl1885[5][2], variabl1885[5][3]);

panel2.add(variabl2611);

}

variabl2601 = new JButton(variabl2405[6]);

variabl2601.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < variabl1843; i++) {

if ((main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0))

variabl17332[i].setText(variabl15072[i]);

}

}

});

if (variabl1885[6][0] > 0) {

variabl2601.setBounds(variabl1885[6][0], variabl1885[6][1],

variabl1885[6][2], variabl1885[6][3]);

panel2.add(variabl2601);

}

variabl1697 = new JButton(variabl2405[7]);

variabl1697.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

for (int i = 0; i < variabl1843; i++)

if (!variabl3623(c, i)) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

String[] s0 = new String[variabl1843];

int b = 0;

int[] x0 = new int[variabl1843];

for (int i = 0; i < variabl17332.length; i++)

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0) {

if ((variabl1651[i][4].equals("组合框"))

|| (variabl1651[i][4].equals("列表框"))) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

variabl14192[i] = (String) variabl2359[variabl1739]

.getSelectedItem();

if (variabl14192[i] == null)

variabl14192[i] = " ";

} else {

variabl14192[i] = variabl17332[i].getText().trim();

if (variabl14192[i] == null) {

variabl14192[i] = " ";

variabl17332[i].setText(variabl15072[i]);

}

}

} else {

variabl14192[i] = "?";

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1843; i++)

if (variabl14672[i] == variabl1287[j]) {

if ((variabl14192[i] == null)

|| (variabl14192[i].trim().length() == 0))

kd0 = 1;

sd = sd + variabl14192[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请改为生成数据录入语句！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl17332.length; i++)

if (variabl14672[i] == variabl1287[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl15012[j] + ",") >= 0) {

if (variabl14192[i].length() < 1)

variabl14192[i] = "0";

s2 = s2 + variabl1525[j] + "="

+ variabl14192[i];

} else

s2 = s2 + variabl1525[j] + "='"

+ variabl14192[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "update " + variabl2603 + " set ";

d2: for (int j = 0; j < variabl17332.length; j++) {

for (int i = 0; i < variabl1069; i++) {

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((("," + variabl1197[i][1] + ",")

.indexOf("," + j + ",") >= 0)

&& (variabl1197[i][2].indexOf("u") < 0))

continue d2;

}

if (!variabl14192[j].trim().equals("?")) {

s1 = s1 + variabl25172[variabl14672[j]] + "=";

if (main1.variabl1545.lastIndexOf(","

+ variabl15012[variabl14672[j]] + ",") >= 0)

s1 = s1 + variabl14192[j];

else

s1 = s1 + "'" + variabl14192[j].trim() + "'";

s1 = s1 + ",";

} else {

s0[b] = "update " + variabl2603 + " set "

+ variabl25172[variabl14672[j]]

+ "=? where " + s2;

x0[b] = j;

b++;

}

}

s1 = s1.substring(0, s1.length() - 1) + " where " + s2;

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

for (int k = 0; k < variabl17332.length; k++) {

variabl21972[variabl18531][variabl14672[k]] = variabl14192[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

for (int i = 0; i < b; i++)

variabl4063(s0[i], x0[i]);

}

});

if (variabl1885[7][0] > 0) {

variabl1697.setBounds(variabl1885[7][0], variabl1885[7][1],

variabl1885[7][2], variabl1885[7][3]);

panel2.add(variabl1697);

}

variabl2633 = new JButton(variabl2405[8]);

variabl2633.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < variabl1843; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0)

variabl14192[i] = variabl17332[i].getText().trim();

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1843; i++)

if (variabl14672[i] == variabl1287[j]) {

if ((variabl14192[i] == null)

|| (variabl14192[i].trim().length() == 0))

kd0 = 1;

sd = sd + variabl14192[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请修改后重新生成！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1843; i++)

if (variabl14672[i] == variabl1287[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl15012[j] + ",") >= 0)

s2 = s2 + variabl1525[j] + "="

+ variabl14192[i];

else

s2 = s2 + variabl1525[j] + "='"

+ variabl14192[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + variabl2603 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

deleteData(variabl18531);

set01.remove(sd0);

for (int i = 0; i < variabl1843; i++) {

if (variabl18531 == variabl18532 - 1)

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0)

variabl17332[i].setText(variabl15072[i]);

else if (main1.variabl1539.lastIndexOf(","

+ variabl15012[variabl14672[i]] + ",") < 0) {

variabl17332[i]

.setText(variabl21972[variabl18531][variabl14672[i]]);

}

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if (variabl1885[8][0] > 0) {

variabl2633.setBounds(variabl1885[8][0], variabl1885[8][1],

variabl1885[8][2], variabl1885[8][3]);

panel2.add(variabl2633);

}

variabl2599 = new JButton(variabl2405[9]);

variabl2185[9] = variabl2599;

variabl2599.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((sw[2].length() > 0) && (sw[3].length() > 0)

&& (sw[4].length() > 0))

WorkflowDrivek1.means(sw);

panel2.setVisible(false);

frame2.setVisible(false);

frame2.dispose();

}

});

if (variabl1885[9][0] > 0) {

variabl2599.setBounds(variabl1885[9][0], variabl1885[9][1],

variabl1885[9][2], variabl1885[9][3]);

panel2.add(variabl2599);

}

if ((sw[3].length() > 0) && (sw[4].length() > 0))

for (int i = 0; i < variabl1843; i++) {

variabl17332[i].setText(variabl21972[0][variabl14672[i]]);

}

if (variabl2503 - variabl1459 - variabl1637 - 100 < 0)

variabl2503 = variabl1459 + variabl1637 + 100;

int w1, h1;

if (1200 - variabl2483 > 0)

w1 = (1000 - variabl2483) / 2;

else

w1 = 0;

if (600 - variabl2503 > 0)

h1 = (600 - variabl2503) / 2;

else

h1 = 0;

if (variabl2503 < variabl1459 + 20)

variabl2503 = variabl1459 + 20;

panel2.setBounds(10, 10, variabl2483 - 10, variabl2503 - 20);

frame2.setBounds(w1 + 300, h1 + 100, variabl2483, variabl2503);

frame2.setVisible(true);

variabl1965 = new DefaultTableModel(variabl2197, variabl25170);

variabl2655 = new JTable(variabl1965);

variabl2655.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

variabl2655

.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

int w0 = 0;

for (int i = 0; i < variabl2651; i++) {

TableColumn tc = variabl2655.getColumn(variabl25170[i]);

JTableHeader header = variabl2655.getTableHeader();

tc.setPreferredWidth(variabl1489[i] * 10);

tc.setMaxWidth(variabl1489[i] * 10);

tc.sizeWidthToFit();

w0 = w0 + variabl1489[i] * 10;

if (w0 > variabl24831)

break;

}

variabl2655.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

int variabl1823 = variabl2655.getSelectedRow();

for (int i = 0; i < variabl2105.length; i++) {

variabl2359[variabl2105[i]]

.setSelectedItem(variabl2197[variabl1823][variabl21050[i]]);

}

}

});

final JScrollPane scrollPane = new JScrollPane();

scrollPane.setBounds(10, 10, 300, variabl2503 - 260);

scrollPane.setViewportView(variabl2655);

frame1.add(scrollPane, BorderLayout.CENTER);

frame1.setBounds(10, 10, 350, variabl2503 - 100);

frame1.setVisible(true);

JButton variabl26330 = new JButton("删除当前记录");

variabl26330.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int variabl1823 = variabl2655.getSelectedRow();

s2 = "";

for (int j = 0; j < variabl2379.length; j++) {

for (int i = 0; i < variabl2517.length; i++)

if (i == variabl21050[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[i] + ",") >= 0)

s2 = s2

+ variabl2379[j]

+ "="

+ variabl1965

.getValueAt(variabl1823, i)

.toString();

else

s2 = s2

+ variabl2379[j]

+ "='"

+ variabl1965

.getValueAt(variabl1823, i)

.toString() + "'";

break;

}

if (j < variabl2379.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

if (JOptionPane.showConfirmDialog(null, "是否删除子表中相关记录？") == 0) {

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + variabl2603 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + variabl2277 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

deleteData(variabl18531);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

variabl26330.setBounds(10, variabl2503 - 200, 150, 20);

frame1.add(variabl26330);

JButton variabl25990 = new JButton("退出");

variabl25990.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame1.setVisible(false);

frame1.dispose();

frame1.setVisible(false);

frame1.dispose();

frame2.dispose();

frame2.setVisible(false);

frame2.dispose();

}

});

variabl25990.setBounds(160, variabl2503 - 200, 150, 20);

frame1.add(variabl25990);

}

static void variabl1037() {

if (variabl1233 > 0)

return;

int variabl1637 = 0;

int variabl3681 = 10;

variabl1233 = variabl26512;

variabl1315 = variabl2483 - 80;

variabl1459 = 20;

int y1 = variabl3681;

int y2 = variabl1459;

int variabl1159 = 0;

if ((variabl1473 == 0)

&& (variabl26512 * variabl1849 < variabl2503 - 120)) {

variabl1637 = (variabl2503 - 150 - variabl26512 * variabl1849)

/ (variabl26512 + 1);

for (int j = 0; j < variabl26512; j++)

if (variabl1323[j][1].length() > variabl1159)

variabl1159 = variabl1323[j][1].length();

for (int j = 0; j < variabl26512; j++) {

variabl1323[j][6] = y1 + "";

variabl1323[j][7] = y2 + "";

variabl1323[j][3] = variabl1159 * variabl1647 + "";

variabl1323[j][2] = variabl1849 + "";

variabl1651[j][0] = (y1 + variabl1159 * variabl1647) + "";

variabl1651[j][1] = y2 + "";

variabl1323[j][4] = (variabl1315 - Integer

.parseInt(variabl1651[j][0])) + "";

variabl1323[j][5] = variabl1849 + "";

variabl1323[j][8] = "宋体";

variabl1323[j][9] = "10";

variabl1323[j][10] = "5";

variabl1651[j][2] = "2";

y2 = y2 + variabl1849 + variabl1637;

variabl1459 = y2;

}

} else {

y1 = variabl3681;

y2 = variabl1459;

int variabl1327 = 1;

for (int j = 0; j < variabl26512; j++) {

variabl1925 = variabl1323[j][1].length();

if (variabl1597.lastIndexOf("," + variabl15012[j] + ",") < 0) {

if ((y1 + (variabl1925 + variabl14892[j]) * variabl1647) > variabl1315) {

variabl1327++;

y1 = variabl3681;

y2 = y2 + variabl1849;

}

variabl1323[j][6] = y1 + "";

variabl1323[j][7] = y2 + "";

variabl1323[j][3] = variabl1925 * variabl1647 + "";

if ((y1 == variabl3681) && (variabl1925 > variabl1159))

variabl1159 = variabl1925;

variabl1323[j][2] = variabl1849 + "";

variabl1651[j][0] = (y1 + variabl1925 * variabl1647) + "";

variabl1651[j][1] = y2 + "";

variabl1323[j][4] = variabl14892[j] * variabl1647 + "";

variabl1323[j][5] = variabl1849 + "";

variabl1323[j][8] = "宋体";

variabl1323[j][9] = "10";

variabl1323[j][10] = "5";

variabl1651[j][2] = "2";

y1 = y1 + variabl1925 * variabl1647 + variabl14892[j]

* variabl1647;

}

}

if (variabl1473 == 0)

variabl1637 = (variabl2503 - 150) / (variabl1327 + 1)

- variabl1849;

else

variabl1637 = 0;

if (variabl1637 < 0)

variabl1637 = 0;

int z = 0;

int z1 = 0;

int z3 = 0;

for (int j = 0; j < variabl26512; j++) {

if (variabl1597.lastIndexOf("," + variabl15012[j] + ",") < 0) {

if (Integer.parseInt(variabl1323[j][6]) == variabl3681) {

z = variabl1159 * variabl1647

- Integer.parseInt(variabl1323[j][3]);

z1 = z1 + variabl1637;

if (j > 0)

variabl1323[z3][4] = (variabl1315 - Integer

.parseInt(variabl1651[z3][0])) + "";

}

variabl1323[j][6] = (Integer.parseInt(variabl1323[j][6]) + z)

+ "";

variabl1651[j][0] = (Integer.parseInt(variabl1651[j][0]) + z)

+ "";

variabl1323[j][7] = (Integer.parseInt(variabl1323[j][7]) + z1)

+ "";

variabl1651[j][1] = (Integer.parseInt(variabl1651[j][1]) + z1)

+ "";

y2 = Integer.parseInt(variabl1651[j][1]);

z3 = j;

}

}

variabl1323[z3][4] = (variabl1315 - Integer

.parseInt(variabl1651[z3][0])) + "";

variabl1459 = y2;

if (variabl1473 > 0) {

y2 = y2 + variabl1849;

int z2 = (variabl2503 - y2 - 120) / variabl1473;

for (int i3 = 0; i3 < variabl26512; i3++) {

if (variabl1597.lastIndexOf("," + variabl15012[i3] + ",") >= 0) {

variabl1323[i3][6] = variabl3681 + "";

variabl1323[i3][7] = y2 + "";

variabl1323[i3][3] = variabl1159 * variabl1647 + "";

variabl1323[i3][2] = variabl1849 + "";

variabl1651[i3][0] = (variabl3681 + variabl1159

* variabl1647)

+ "";

variabl1651[i3][1] = y2 + "";

y2 = y2 + z2;

variabl1323[i3][4] = (variabl1315 - variabl1159

* variabl1647)

+ "";

variabl1323[i3][5] = z2 + "";

variabl1323[i3][8] = "宋体";

variabl1323[i3][9] = "10";

variabl1323[i3][10] = "5";

variabl1651[i3][2] = "2";

if (main1.variabl1539.lastIndexOf(","

+ variabl15012[i3] + ",") >= 0)

variabl1651[i3][4] = "图像字段";

else

variabl1651[i3][4] = "文本字段";

}

}

variabl1459 = y2 + variabl1849;

}

}

variabl1459 = y2 + variabl1849;

}

static void variabl2819002() {

if (variabl2833 > 0)

return;

String[] t5 = variabl1187.split(",");

variabl1371 = t5.length - 1;

variabl1885 = new int[variabl2851][15];

for (int j = 0; j < variabl2851; j++) {

variabl1885[j][0] = 0;

variabl1885[j][1] = 0;

variabl1885[j][2] = 0;

variabl1885[j][3] = 0;

}

int variabl1629;

variabl1629 = (int) (variabl1647 * 6.3);

variabl3681 = 20;

if (variabl1473 == 0)

variabl1459 = variabl1459 + variabl1849 * 2;

else

variabl1459 = variabl1459 + variabl1849;

int variabl1505 = (variabl2483 - 100) / (int) (6.6 * variabl1647);

if (variabl1505 < 1)

variabl1505 = 1;

if (variabl1371 <= variabl1505)

variabl1629 = (variabl2483 - 100) / variabl1371;

else

variabl1629 = (variabl2483 - 100) / variabl1505;

int n = 0, n1 = 0, n3 = 0;

n3 = variabl1505 * variabl1629;

for (int j = 0; j < variabl2851; j++) {

if (variabl1187.lastIndexOf("," + j + ",") >= 0) {

variabl1885[j][0] = variabl3681;

variabl1885[j][1] = variabl1459;

if (variabl2405[j].length() > 4) {

variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 1.2));

n3 = n3 + variabl1885[j][2] - variabl1629;

variabl3681 = variabl3681 + variabl1885[j][2];

} else {

variabl1885[j][2] = variabl1629;

variabl3681 = variabl3681 + variabl1629;

}

variabl1885[j][3] = variabl1849;

n++;

n1++;

if (variabl1371 - n1 == 0)

break;

if ((n >= variabl1505)

&& ((variabl1371 - n1) - variabl1505 != 0)) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

if ((variabl1371 - n1) <= variabl1505)

variabl1629 = (variabl2483 - 100) / (variabl1371 - n1);

else

variabl1629 = (variabl2483 - 100) / variabl1505;

n = 0;

} else if (n >= variabl1505) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

n = 0;

}

}

}

variabl2503 = variabl1459 + variabl1849 + 100;

}

static void variabl1005(String variabl1103) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + variabl13252 + " from " + variabl1103;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

variabl26512 = rsmdt4.getColumnCount();

variabl25172 = new String[variabl26512];

variabl15012 = new String[variabl26512];

variabl14892 = new int[variabl26512];

variabl15072 = new String[variabl26512];

variabl1473 = 0;

for (int i = 0; i < variabl26512; i++) {

variabl25172[i] = rsmdt4.getColumnName(i + 1);

variabl14892[i] = rsmdt4.getColumnDisplaySize(i + 1);

variabl15012[i] = rsmdt4.getColumnTypeName(i + 1);

if (variabl1651[i][3] == null)

variabl1651[i][3] = "";

if (variabl1651[i][4] == null)

variabl1651[i][4] = "";

if ((variabl1651[i][3].length() < 1)

&& ((variabl2429.lastIndexOf("," + variabl25172[i]

+ "表,") >= 0) && (variabl25172[i].indexOf("代码") >= 0))) {

variabl1651[i][3] = variabl25172[i] + "表";

variabl1651[i][4] = "组合框";

variabl14892[i] = variabl14892[i] + 10;

} else if ((variabl1651[i][3].length() < 1)

&& ((variabl2429.lastIndexOf("," + variabl25172[i]

+ "代码表,") >= 0) && (variabl25172[i]

.indexOf("代码") < 0))) {

variabl1651[i][3] = variabl25172[i] + "代码表";

variabl1651[i][4] = "组合框";

variabl14892[i] = variabl14892[i] + 10;

}

variabl1323[i][0] = variabl25172[i];

if ((variabl1323[i][1]) == null

|| (variabl1323[i][1].length() != 0))

for (int j = 0; j < variabl1837.length; j++) {

if (variabl25172[i].toLowerCase().equalsIgnoreCase(

variabl1837[j][0].toLowerCase()))

variabl1323[i][1] = variabl1837[j][1];

else if (variabl25172[i].toLowerCase()

.equalsIgnoreCase(

variabl1837[j][1].toLowerCase()))

variabl1323[i][1] = variabl1837[j][0];

}

if ((variabl1323[i][1]) == null

|| (variabl1323[i][1].length() == 0))

variabl1323[i][1] = variabl25172[i];

if (variabl1651[i][4].length() < 1)

if (main1.variabl1537.indexOf("," + variabl15012[i] + ",") >= 0) {

variabl1651[i][4] = "文本字段";

variabl1473++;

} else if (variabl15012[i].equalsIgnoreCase("image")) {

variabl1651[i][4] = "图像字段";

variabl1473++;

} else

variabl1651[i][4] = "普通字段";

if (variabl15012[i].indexOf("datetime") == 0)

variabl15072[i] = "2001-01-01 00:00:00.000";

else if (variabl15012[i].indexOf("smalldatetime") == 0)

variabl15072[i] = "2001-01-01 00:00:00";

else if (variabl15012[i].indexOf("datetime2") == 0)

variabl15072[i] = "2001-01-01 00:00:00.0000000";

else if (variabl15012[i].indexOf("datetimeoffset") == 0)

variabl15072[i] = "2001-01-01 00:00:00.0000000 +08:00";

else if (variabl15012[i].indexOf("date") == 0)

variabl15072[i] = "2001-01-01";

else if (variabl15012[i].indexOf("time") == 0)

variabl15072[i] = "00:00:00";

else if (variabl15012[i].indexOf("money") >= 0)

variabl15072[i] = "0.0000";

else if (main1.variabl1541.lastIndexOf("," + variabl15012[i]

+ ",") >= 0)

variabl15072[i] = "0.00";

else if (main1.variabl1545.lastIndexOf("," + variabl15012[i]

+ ",") >= 0)

variabl15072[i] = "0";

else

variabl15072[i] = "";

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

variabl15932 = ",";

variabl1325 = "";

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select * from " + variabl2277;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

variabl2651 = rsmdt4.getColumnCount();

variabl2517 = new String[variabl2651];

for (int i = 0; i < variabl2651; i++) {

variabl2517[i] = rsmdt4.getColumnName(i + 1);

if ((variabl1153.trim().length() > 0)

&& (("," + variabl1153 + ",").indexOf("," + i + ",") >= 0))

variabl1325 = variabl1325 + variabl2517[i] + ",";

else if (variabl1153.trim().length() == 0)

variabl1325 = variabl1325 + variabl2517[i] + ",";

}

variabl1325 = variabl1325.substring(0, variabl1325.length() - 1);

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + variabl1325 + " from " + variabl2277;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

variabl2651 = rsmdt4.getColumnCount();

variabl2517 = new String[variabl2651];

variabl25170 = new String[variabl2651];

variabl1501 = new String[variabl2651];

variabl1489 = new int[variabl2651];

for (int i = 0; i < variabl2651; i++) {

variabl2517[i] = rsmdt4.getColumnName(i + 1);

variabl25170[i] = variabl2517[i];

variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);

variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

for (int i = 0; i < variabl1837.length; i++) {

for (int j = 0; j < variabl2517.length; j++) {

if (variabl2517[j].equals(variabl1837[i][0]))

variabl25170[j] = variabl1837[i][1];

else if (variabl2517[j].equals(variabl1837[i][1]))

variabl25170[j] = variabl1837[i][0];

}

}

for (int j = 0; j < variabl2517.length; j++) {

for (int i = 0; i < variabl1837.length; i++) {

if (variabl2517[j].equals(variabl1837[i][0]))

variabl25170[j] = variabl1837[i][1];

else if (variabl2517[j].equals(variabl1837[i][1]))

variabl25170[j] = variabl1837[i][0];

}

}

for (int i1 = 0; i1 < variabl2517.length; i1++) {

for (int j1 = 0; j1 < variabl2379.length; j1++)

if (variabl2517[i1].toLowerCase().trim()

.equals(variabl2379[j1].toLowerCase().trim()))

variabl21050[j1] = i1;

}

variabl21051 = new int[variabl25172.length];

for (int i1 = 0; i1 < variabl25172.length; i1++) {

for (int j1 = 0; j1 < variabl1525.length; j1++) {

if (variabl25172[i1].toLowerCase().trim()

.equals(variabl1525[j1].toLowerCase().trim()))

variabl1287[j1] = i1;

}

for (int j1 = 0; j1 < variabl2379.length; j1++) {

if (variabl25172[i1].toLowerCase().trim()

.equals(variabl2379[j1].toLowerCase().trim())) {

variabl2105[j1] = i1;

variabl15932 = variabl15932 + i1 + ",";

}

}

}

for (int i1 = 0; i1 < variabl25172.length; i1++) {

for (int j1 = 0; j1 < variabl2379.length; j1++) {

if (variabl25172[i1].toLowerCase().trim()

.equals(variabl2379[j1].toLowerCase().trim()))

for (int i2 = 0; i2 < variabl2517.length; i2++) {

if (variabl2517[i2].toLowerCase().trim()

.equals(variabl2379[j1].toLowerCase().trim()))

variabl21051[i1] = i2;

}

}

}

}

static void variabl1009(String variabl1103) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + variabl13252 + "  from " + variabl1103;

if ((sw[3].length() > 0) && (sw[4].length() > 0))

s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";

rs = stat4.executeQuery(s1);

rs.last();

variabl18532 = rs.getRow();

String[][] variabl21970 = new String[variabl18532][variabl26512];

variabl21972 = new String[variabl18532 + 300][variabl26512];

rsmdt4 = rs.getMetaData();

int c = 0;

int b = 0;

while (c < variabl18532) {

rs.absolute(c + 1);

while (b < variabl26512) {

variabl21970[c][b] = rs.getString(b + 1);

variabl21972[c][b] = variabl21970[c][b];

b++;

}

c++;

b = 0;

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

for (int i = 0; i < variabl18532; i++)

for (int j = 0; j < variabl26512; j++)

variabl21972[i][j] = variabl21970[i][j];

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select " + variabl1325 + " from " + variabl2277;

ResultSet rs = stat4.executeQuery(s1);

rs.last();

variabl1853 = rs.getRow();

variabl2197 = new String[variabl1853][variabl2651];

rs.absolute(1);

c = 0;

b = 0;

while (c < variabl1853) {

rs.absolute(c + 1);

while (b < variabl2651) {

variabl2197[c][b] = rs.getString(b + 1);

b++;

}

c++;

b = 0;

}

rs.close();

stat4.close();

} catch (Exception e) {

e.printStackTrace();

}

}

static void variabl10091() {

int variabl18535 = 0;

try {

if (variabl1873.length() > 0) {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl1873;

rs = stat4.executeQuery(s1);

rs.last();

variabl18535 = rs.getRow();

variabl1837 = new String[variabl18535][2];

rs.absolute(1);

String s4 = "";

String s5 = "";

for (int i = 1; i <= variabl18535; i++) {

rs.absolute(i);

s4 = rs.getString(1).trim();

variabl1837[i - 1][0] = s4;

s5 = rs.getString(2).trim();

variabl1837[i - 1][1] = s5;

}

rs.close();

stat4.close();

cont4.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！");

}

}

static void variabl10092(String variabl22330, String variabl25179, int j9) {

try {

if (variabl25179.indexOf("代码") >= 0) {

s2 = variabl25179.substring(0, variabl25179.length() - 2);

s1 = "select " + variabl25179 + "," + s2 + " from "

+ variabl22330;

} else if (variabl2429.lastIndexOf("," + variabl25179 + "代码表,") >= 0) {

s2 = variabl25179.substring(0, variabl25179.length() - 2);

s1 = "select " + variabl25179 + "," + variabl25179 + "代码"

+ " from " + variabl25179 + "代码表";

}

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stat4.executeQuery(s1);

rs.last();

int numberOfColumns = rs.getRow();

rs.beforeFirst();

variabl1431[j9] = new String[numberOfColumns];

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

variabl1431[j9][i - 1] = rs.getString(1).trim();

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

}

static void variabl2817002() {

variabl2403 = new JTextField[variabl1233];

variabl2463 = new JTextArea[variabl1233];

variabl2165 = new JLabel[variabl1233];

variabl2359 = new JComboBox[variabl1233];

variabl17332 = new JTextComponent[variabl1233];

variabl14672 = new int[variabl1233];

variabl1431 = new String[variabl1233][2];

variabl1843 = variabl1233;

for (int j = 0; j < variabl1843; j++) {

JLabel variabl2533 = new JLabel(variabl1323[j][1], 11);

variabl2533.setBounds(Integer.parseInt(variabl1323[j][6]),

Integer.parseInt(variabl1323[j][7]),

Integer.parseInt(variabl1323[j][3]),

Integer.parseInt(variabl1323[j][2]));

Font font = new Font(variabl1323[j][8], Font.BOLD,

Integer.parseInt(variabl1323[j][9]));

String s01 = variabl1323[j][10];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01);

variabl2533.setFont(font);

color1(s02, variabl2533);

panel2.add(variabl2533);

if ((variabl1651[j][4].equals("普通字段"))

&& ((variabl15932.indexOf("," + j + ",") < 0))) {

variabl2403[j] = new JTextField("");

variabl2403[j].setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

Font font1 = new Font(variabl1323[j][8], Font.BOLD,

Integer.parseInt(variabl1323[j][9]));

String s011 = variabl1323[j][10];

int s021 = 5;

if ((s011 != null) && (s011.length() > 0)

&& (s011.compareTo("0") >= 0)

&& (s011.compareTo("9") <= 0))

s021 = Integer.parseInt(s011);

variabl2403[j].setFont(font1);

color2(s021, variabl2403[j]);

if (variabl2803.indexOf("," + j + ",") >= 0) {

variabl2403[j].setEditable(false);

}

panel2.add((Component) variabl2403[j]);

variabl2403[j].addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent arg0) {

c = 0;

}

});

variabl2403[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Object s0 = arg0.getSource();

String s1 = s0.toString();

String s2 = "";

for (int i = 0; i < variabl1843; i++) {

s2 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

}

public void focusLost(final FocusEvent arg1) {

if (c > 0)

return;

Object s0 = arg1.getSource();

String s1 = s0.toString().substring(10, 33);

String s2 = "";

for (int i = 0; i < variabl1843; i++) {

s2 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

if ((c == 0) && (!variabl3623(c, b))) {

variabl2403[c].requestFocus(true);

return;

}

}

});

variabl2403[j].setText(variabl15072[j]);

variabl17332[j] = (JTextComponent) variabl2403[j];

variabl14672[j] = j;

} else if (variabl1651[j][4].equals("文本字段")) {

variabl2463[j] = new JTextArea("   ",

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

JScrollPane variabl1147 = new JScrollPane(variabl2463[j]);

variabl1147.setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

Font font1 = new Font(variabl1323[j][8], Font.BOLD,

Integer.parseInt(variabl1323[j][9]));

String s011 = variabl1323[j][10];

int s021 = 5;

if ((s011 != null) && (s011.length() > 0)

&& (s011.compareTo("0") >= 0)

&& (s011.compareTo("9") <= 0))

s021 = Integer.parseInt(s011);

variabl2463[j].setFont(font1);

color3(s021, variabl2463[j]);

panel2.add((Component) variabl1147);

variabl2463[j].setText(variabl15072[j]);

variabl17332[j] = (JTextComponent) variabl2463[j];

variabl14672[j] = j;

} else if (variabl1651[j][4].equals("图像字段")) {

JLabel variabl2407 = new JLabel("   ");

variabl2407.setBackground(Color.BLUE);

variabl2407.setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

panel2.add(new JScrollPane(variabl2407));

panel2.add(variabl2407);

variabl2165[j] = variabl2407;

variabl17332[j] = (JTextComponent) variabl2463[j];

variabl14672[j] = j;

} else if (variabl1651[j][4].equals("组合框")) {

variabl2359[j] = new JComboBox();

variabl2403[j] = new JTextField();

variabl2359[j].setEditable(true);

variabl2359[j].setEnabled(true);

panel2.add((Component) variabl2359[j]);

variabl2359[j].setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

variabl10092(variabl1651[j][3], variabl1323[j][0], j);

for (int i = 0; i < variabl1431[j].length; i++) {

variabl2359[j].addItem(variabl1431[j][i]);

}

variabl17332[j] = (JTextComponent) variabl2359[j].getEditor()

.getEditorComponent();

variabl17332[j].setText("");

variabl14672[j] = j;

} else if (variabl15932.indexOf("," + j + ",") >= 0) {

variabl2359[j] = new JComboBox();

variabl2403[j] = new JTextField();

variabl2359[j].setEditable(false);

variabl2359[j].setEnabled(true);

panel2.add((Component) variabl2359[j]);

variabl2359[j].setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

for (int i = 0; i < variabl2197.length; i++) {

variabl2359[j].addItem(variabl2197[i][variabl21051[j]]);

}

variabl17332[j] = (JTextComponent) variabl2359[j].getEditor()

.getEditorComponent();

variabl17332[j].setText("");

variabl14672[j] = j;

variabl2359[j].addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

int b0 = 0;

String s0 = "";

String s10 = event.toString();

for (int i = 0; i < variabl1843; i++) {

s0 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s10.indexOf(s0) > 0) {

b0 = i;

break;

}

}

for (int i = 0; i < variabl2105.length; i++) {

if (variabl2105[i] != b0)

variabl2359[variabl2105[i]]

.setSelectedIndex(variabl2359[b0]

.getSelectedIndex());

variabl2655.editCellAt(

variabl2359[b0].getSelectedIndex(),

variabl21051[b0]);

}

}

});

}

}

}

public static void deleteData(int pos) {

if (pos == variabl18532 - 1)

variabl18531--;

for (int i = pos; i < variabl18532 - 1; i++) {

for (int j = 0; j < variabl1843 - 1; j++) {

variabl21972[i][j] = variabl21972[i + 1][j];

}

}

variabl18532--;

}

static void color1(int c, JLabel fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color2(int c, JTextField fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color3(int c, JTextArea fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

public static void variabl4063(String s0, int k) {

for (int i = 0; i < variabl17332.length; i++)

cont4 = main1.getConn();

try {

PreparedStatement pst4 = cont4.prepareStatement(s0);

int k2 = 1;

String s5 = "";

final JFileChooser fc = new JFileChooser(".\\");

fc.showDialog(new JLabel(), "请选择图片字段"

+ variabl25172[variabl14672[k]] + "的文件名");

if (fc.getSelectedFile() != null)

s5 = fc.getSelectedFile().toString();

else {

JOptionPane.showMessageDialog(null, "未选择图片文件，原图不变！");

return;

}

FileInputStream f1 = new FileInputStream(s5);

pst4.setBinaryStream(k2, f1, f1.available());

k2++;

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

byte[] c0 = new byte[s5.length()];

Icon icon = new ImageIcon(c0);

variabl2165[k].setOpaque(true);

variabl2165[k].setBackground(Color.PINK);

variabl2165[k].setIcon(icon);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

} catch (IOException e3) {

JOptionPane.showMessageDialog(null, "文件读取出错！");

}

}

public static boolean variabl3623(int c1, int b1) {

c = c1;

b = b1;

int bz1 = 0;

String sb = "", bz = "";

String[] sb1 = null;

try {

for (int i1 = 0; i1 < variabl1077; i1++) {

if (variabl1201[i1][0].toLowerCase().trim()

.equals(variabl1323[b][0].toLowerCase().trim())) {

bz1 = main1.variabl1545.indexOf(","

+ variabl15012[variabl14672[b]] + ",");

if (bz1 >= 0) {

if ((variabl1201[i1][1].trim().length() > 0)

&& (Double

.parseDouble(variabl2403[b].getText()) > Double

.parseDouble(variabl1201[i1][1]))) {

bz = variabl2403[b].getText() + ">最大值"

+ Double.parseDouble(variabl1201[i1][1]);

c = b;

} else if ((variabl1201[i1][2].trim().length() > 0)

&& (Double

.parseDouble(variabl2403[b].getText()) < Double

.parseDouble(variabl1201[i1][2]))) {

bz = variabl2403[b].getText() + "<最小值"

+ variabl1201[i1][2];

c = b;

} else if ((variabl1201[i1][3].trim().length() > 0)) {

if (variabl1201[i1][3].indexOf("-") > 0) {

sb1 = variabl1201[i1][3].split("-");

if ((Double.parseDouble(variabl2403[b]

.getText()) < Double

.parseDouble(sb1[0]))) {

bz = variabl2403[b].getText() + "<范围下限"

+ sb1[0];

c = b;

}

if ((Double.parseDouble(variabl2403[b]

.getText()) > Double

.parseDouble(sb1[1]))) {

bz = variabl2403[b].getText() + ">范围上限"

+ sb1[1];

c = b;

}

} else if (variabl1201[i1][3].indexOf("[") >= 0) {

bz = variabl1201[i1][3].trim().substring(1,

variabl1201[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (variabl2403[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (variabl2403[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

} else if (variabl1201[i1][3].indexOf(",") > 0) {

if (("," + variabl1201[i1][3] + ",")

.indexOf("," + variabl2403[b].getText()

+ ",") < 0) {

c = b;

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

}

}

} else if (variabl1201[i1][4].trim().length() > 0) {

int[][] m = new int[2][variabl1843];

for (int i = 0; i < variabl1843; i++) {

m[0][i] = i;

m[1][i] = variabl1323[i][0].length();

}

int d = 0, e = 0;

for (int i = 0; i < m[1].length; i++)

for (int j = i + 1; j < m[1].length; j++)

if (m[1][i] < m[1][j]) {

e = m[0][i];

m[0][i] = m[0][j];

m[0][j] = e;

e = m[1][i];

m[1][i] = m[1][j];

m[1][j] = e;

}

sb = variabl1201[i1][4];

for (int i = 0; i < m[1].length; i++)

sb = sb.replaceAll(variabl1323[m[0][b]][0],

variabl2403[m[0][b]].getText());

if (!tenanceEval.tenanceeval(sb)) {

bz = variabl2403[b].getText() + "不满足条件："

+ variabl1201[i1][4];

c = b;

}

} else

c = 0;

} else if (main1.variabl1543.lastIndexOf(","

+ variabl15012[variabl14672[b]] + ",") >= 0) {

if ((variabl1201[i1][3].trim().length() > 0)) {

if (variabl1201[i1][3].indexOf("[") >= 0) {

bz = variabl1201[i1][3].trim().substring(1,

variabl1201[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (variabl2403[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (variabl2403[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

} else if (variabl1201[i1][3].indexOf(",") > 0) {

if (("," + variabl1201[i1][3] + ",")

.indexOf("," + variabl2403[b].getText()

+ ",") < 0) {

c = b;

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

}

}

} else

c = 0;

}

}

if (bz.length() > 0)

break;

}

} catch (Exception e1) {

JOptionPane.showMessageDialog(null, "数据完整性约束条件设置不满足格式要求，请修改接口参数表！"

+ e1);

}

if (bz.length() > 0) {

if (c > 0) {

JOptionPane.showMessageDialog(null, "填入的数据违反数据完整性约束条件。请检查！"

+ bz);

bz = "";

return false;

}

}

return true;

}

}

81.源码81，部件程序，表单程序，用于多对多表之间联系表的数据维护。

/** 

 * 程序文件名：dataTenance8.java 

 * 作者：程学先  

 * 程序功能：实现多对多表之间联系表的数据维护。 

 */

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableColumn;

public class dataTenance8 extends JFrame {

static dataTenance8 frame1 = new dataTenance8();

static JTextField variabl24031;

static JTextField variabl24032;

private static JLabel fl1, fl2;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String variabl22771;

private static String variabl22772;

private static String variabl2603;

private static int variabl2483 = main1.variabl2483;

private static int variabl2503 = main1.variabl2503;

private static int variabl2651;

private static int variabl26511;

private static int variabl26512;

private static String[] variabl2517;

private static String[] variabl25171;

private static String[] variabl25172;

private static String[] variabl1501;

private static String[] variabl15011;

private static String[] variabl15012;

private static int[] variabl1489;

private static int[] variabl14891;

private static int[] variabl14892;

private static int variabl1853 = 0;

private static int variabl18531 = 0;

private static int variabl18532 = 0;

private static String[][] variabl2197;

private static String[][] variabl21971;

private static String[][] variabl21972;

private static String[][] variabl21973;

private static String variabl1175 = "";

private static JTable variabl2655;

static DefaultTableModel variabl1965;

private static String[] variabl1525;

private static String[] variabl1377;

private static int[] variabl1287;

private static int variabl12871;

private static int variabl12872;

private static String variabl14131 = "", variabl14132 = "";

private static String s1 = "", s2 = "", s3 = "";

private static int b = 0, c = 0, variabl2593 = 0, variabl25473 = 0;

private static String[] variabl2405 = { "从表格删除", "存入数据库", "更新表格", "退出" };

private static JButton variabl1479, variabl1337, variabl2599;

static int variabl2851 = 0, variabl2339 = 0;

private static String variabl1187;

private static int variabl1647 = 15, variabl1849 = 20;

static int variabl3681;

static int variabl1313;

private static int variabl1885[][];

static int variabl1473;

private static int variabl2833, variabl1371;

static void means(String parameter[]) {

frame1 = new dataTenance8();

variabl2483 = main1.variabl2483;

variabl2503 = main1.variabl2503;

variabl1853 = 0;

variabl18531 = 0;

variabl18532 = 0;

variabl1175 = "";

variabl1313 = 0;

s1 = "";

s2 = "";

s3 = "";

b = 0;

c = 0;

variabl2593 = 0;

variabl25473 = 0;

variabl1647 = 15;

variabl1849 = 20;

variabl2833 = 0;

variabl1371 = 0;

String[] variabl240501 = { "从表格删除", "存入数据库", "更新表格", "退出" };

variabl2405 = new String[variabl240501.length];

variabl2851 = 0;

for (int i0 = 0; i0 < variabl240501.length; i0++)

variabl2405[i0] = variabl240501[i0];

if (parameter[11].length() > 0) {

variabl1187 = parameter[11];

variabl1187 = variabl1187.replaceAll("；", ";");

variabl1187 = variabl1187.replaceAll("。", ";");

variabl1187 = variabl1187.replaceAll(":", ";");

variabl1187 = variabl1187.replaceAll("：", ";");

if (variabl1187.indexOf(";") > 0) {

String s601[] = variabl1187.split(",");

variabl1187 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (s601[i01].indexOf(";") > 0) {

String s602[] = s601[i01].split(";");

variabl2405[Integer.parseInt((s602[0]))] = s602[1];

variabl1187 = variabl1187 + "," + s602[0];

} else {

variabl1187 = variabl1187 + "," + s601[i01];

}

}

} else {

String s601[] = variabl1187.split(",");

variabl1187 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (i01 == 0)

variabl1187 = s601[i01];

else

variabl1187 = variabl1187 + "," + s601[i01];

}

}

} else {

variabl1187 = "";

for (int i1 = 0; i1 < variabl2405.length; i1++) {

if (i1 == 0)

variabl1187 = variabl1187 + i1;

else

variabl1187 = variabl1187 + "," + i1;

}

}

variabl1187 = "," + variabl1187 + ",";

variabl1187 = variabl1187.replaceAll(",,", ",");

variabl2851 = variabl2405.length;

variabl2483 = main1.variabl2483;

variabl2503 = main1.variabl2503;

int m1, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

variabl2483 = m1;

variabl2503 = m2;

}

} catch (Exception e2) {

}

variabl22771 = parameter[2];

variabl22772 = parameter[3];

variabl2603 = parameter[4];

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

variabl1525 = parameter[6].split(",");

variabl14131 = parameter[13];

variabl14132 = parameter[14];

variabl1287 = new int[variabl1525.length];

frame1.setTitle("多对多表数据维护程序                           作者：程学先");

frame1.setBounds(0, 0, variabl2483, variabl2503);

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

fl1 = new JLabel(variabl22771 + "条件表达式");

fl1.setBounds(30, 20, 120, 20);

frame1.add(fl1);

variabl24031 = new JTextField(variabl14131, 20);

variabl24031.setBounds(150, 20, 200, 20);

frame1.add(variabl24031);

fl2 = new JLabel(variabl22772 + "条件表达式");

fl2.setBounds(350, 20, 120, 20);

frame1.add(fl2);

variabl24032 = new JTextField(variabl14132, 20);

variabl24032.setBounds(470, 20, 200, 20);

frame1.add(variabl24032);

variabl2819002();

if ((variabl14131.trim().length() > 0)

&& (variabl14132.trim().length() > 0))

refresh();

variabl1479 = new JButton(variabl2405[0]);

variabl1479.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int variabl1823 = variabl2655.getSelectedRow();

if (variabl1823 != -1)

variabl1965.removeRow(variabl1823);

}

});

if (variabl1187.lastIndexOf(",0,") >= 0) {

variabl1479.setBounds(variabl1885[0][0], variabl1885[0][1],

variabl1885[0][2], variabl1885[0][3]);

frame1.add(variabl1479);

}

variabl1337 = new JButton(variabl2405[1]);

variabl1337.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String variabl2511 = main1.variabl1545;

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

variabl18531 = variabl1965.getRowCount();

int f0 = 0;

for (int i = 0; i < variabl18531; i++) {

f0 = 0;

s3 = "";

for (int j = 0; j < variabl1287.length; j++) {

s3 = s3

+ variabl1965.getValueAt(i, variabl1287[j])

.toString().trim();

}

for (int i1 = 0; i1 < variabl1853; i1++) {

if (variabl1377[i1].toLowerCase().trim()

.equals(s3.toLowerCase().trim())) {

f0 = 1;

break;

}

}

if (f0 == 0) {

s1 = "insert into " + variabl2603 + " (";

for (int k1 = 0; k1 < variabl2517.length; k1++)

s1 = s1 + variabl2517[k1] + ",";

s1 = s1.substring(0, s1.length() - 1)

+ " ) values (";

for (int j = 0; j < variabl2517.length; j++) {

if (variabl2511.lastIndexOf(","

+ variabl1501[j] + ",") >= 0) {

if ((variabl1965.getValueAt(i, j) == null)

|| (variabl1965.getValueAt(i, j)

.toString().trim().length() < 1))

s1 = s1 + "0";

else

s1 = s1

+ variabl1965.getValueAt(i, j)

.toString().trim();

} else {

if (variabl1965.getValueAt(i, j) == null)

s1 = s1 + "' '";

else

s1 = s1

+ "'"

+ variabl1965.getValueAt(i, j)

.toString().trim()

+ "'";

}

if (j != variabl2517.length - 1)

s1 = s1 + ",";

}

s1 = s1 + ")";

stat4.executeUpdate(s1);

} else {

s1 = "update " + variabl2603 + " set ";

for (int k1 = 0; k1 < variabl2517.length; k1++) {

s1 = s1 + variabl2517[k1] + "=";

if (variabl2511.lastIndexOf(","

+ variabl1501[k1] + ",") >= 0) {

if ((variabl1965.getValueAt(i, k1) == null)

|| (variabl1965.getValueAt(i, k1)

.toString().trim().length() < 1))

s1 = s1 + "0";

else

s1 = s1

+ variabl1965.getValueAt(i, k1)

.toString().trim();

} else {

if (variabl1965.getValueAt(i, k1) == null)

s1 = s1 + "' '";

else

s1 = s1

+ "'"

+ variabl1965.getValueAt(i, k1)

.toString().trim()

+ "'";

}

if (k1 != variabl2517.length - 1)

s1 = s1 + ",";

}

s2 = " where ";

for (int k = 0; k < variabl1287.length; k++) {

s2 = s2 + variabl1525[k] + "='"

+ variabl2197[i][variabl1287[k]] + "'";

if (k < variabl1525.length - 1)

s2 = s2 + " and ";

}

s1 = s1 + s2;

stat4.executeUpdate(s1);

}

}

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null,

"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);

}

}

});

if (variabl1187.lastIndexOf(",1,") >= 0) {

variabl1337.setBounds(variabl1885[1][0], variabl1885[1][1],

variabl1885[1][2], variabl1885[1][3]);

frame1.add(variabl1337);

}

JButton variabl1689 = new JButton(variabl2405[2]);

variabl1689.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl14131 = variabl24031.getText();

variabl14132 = variabl24032.getText();

refresh();

}

});

if (variabl1187.lastIndexOf(",2,") >= 0) {

variabl1689.setBounds(variabl1885[2][0], variabl1885[2][1],

variabl1885[2][2], variabl1885[2][3]);

frame1.add(variabl1689);

}

variabl2599 = new JButton(variabl2405[3]);

variabl2599.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame1.setVisible(false);

frame1.dispose();

}

});

if (variabl1187.lastIndexOf(",3,") >= 0) {

variabl2599.setBounds(variabl1885[3][0], variabl1885[3][1],

variabl1885[3][2], variabl1885[3][3]);

frame1.add(variabl2599);

}

frame1.setVisible(true);

}

static void variabl2819002() {

int variabl1459 = 0;

if (variabl2833 > 0)

return;

variabl1187 = ",0,1,2,3,";

String[] t5 = variabl1187.split(",");

variabl1371 = t5.length - 1;

variabl1885 = new int[variabl2851][15];

for (int j = 0; j < variabl2851; j++) {

variabl1885[j][0] = 0;

variabl1885[j][1] = 0;

variabl1885[j][2] = 0;

variabl1885[j][3] = 0;

}

int variabl1629;

variabl1629 = (int) (variabl1647 * 12);

variabl3681 = 20;

if (variabl1473 == 0)

variabl1459 = variabl1459 + variabl1849 * 2;

else

variabl1459 = variabl1459 + variabl1849;

int variabl1505 = (variabl2483 - 30) / (int) (6.6 * variabl1647);

if (variabl1505 < 1)

variabl1505 = 1;

if (variabl1371 <= variabl1505)

variabl1629 = (variabl2483 - 60) / variabl1371;

else

variabl1629 = (variabl2483 - 60) / variabl1505;

int n = 0, n1 = 0, n3 = 0;

n3 = variabl1505 * variabl1629;

for (int j = 0; j < variabl2851; j++) {

if (variabl1187.lastIndexOf("," + j + ",") >= 0) {

variabl1885[j][0] = variabl3681;

variabl1885[j][1] = variabl1459;

if (variabl2405[j].length() > 4) {

variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 2));

n3 = n3 + variabl1885[j][2] - variabl1629;

variabl3681 = variabl3681 + variabl1885[j][2];

} else {

variabl1885[j][2] = variabl1629;

variabl3681 = variabl3681 + variabl1629;

}

variabl1885[j][3] = variabl1849;

n++;

n1++;

if (variabl1371 - n1 == 0)

break;

if ((n >= variabl1505)

&& ((variabl1371 - n1) - variabl1505 != 0)) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

if ((variabl1371 - n1) <= variabl1505)

variabl1629 = (variabl2483 - 60) / (variabl1371 - n1);

else

variabl1629 = (variabl2483 - 60) / variabl1505;

n = 0;

} else if (n >= variabl1505) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

n = 0;

}

}

}

variabl2503 = variabl1459 + variabl1849 + 100;

}

public static void refresh() {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl22771;

if (variabl14131.length() > 0)

s1 = s1 + " where " + variabl14131;

rs = stat4.executeQuery(s1);

rs.last();

variabl18531 = rs.getRow();

rsmdt4 = rs.getMetaData();

variabl26511 = rsmdt4.getColumnCount();

variabl25171 = new String[variabl26511];

variabl15011 = new String[variabl26511];

variabl14891 = new int[variabl26511];

variabl21971 = new String[variabl18531][variabl26511];

for (int i = 0; i < variabl26511; i++) {

variabl25171[i] = rsmdt4.getColumnName(i + 1);

variabl15011[i] = rsmdt4.getColumnTypeName(i + 1);

variabl14891[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

for (int j = 0; j < variabl1525.length; j++)

for (int i = 0; i < variabl26511; i++) {

if (variabl1525[j].toLowerCase().trim()

.equals(variabl25171[i].toLowerCase().trim())) {

variabl12871 = i;

break;

}

}

rs.absolute(1);

c = 0;

b = 0;

while (c < variabl18531) {

rs.absolute(c + 1);

while (b < variabl26511) {

variabl21971[c][b] = rs.getString(b + 1);

b++;

}

c++;

b = 0;

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);

}

if (variabl22772.length() > 0) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl22772;

if (variabl14132.length() > 0)

s1 = s1 + " where " + variabl14132;

rs = stat4.executeQuery(s1);

rs.last();

variabl18532 = rs.getRow();

rsmdt4 = rs.getMetaData();

variabl26512 = rsmdt4.getColumnCount();

variabl25172 = new String[variabl26512];

variabl15012 = new String[variabl26512];

variabl14892 = new int[variabl26512];

variabl21972 = new String[variabl18532][variabl26512];

for (int i = 0; i < variabl26512; i++) {

variabl25172[i] = rsmdt4.getColumnName(i + 1);

variabl15012[i] = rsmdt4.getColumnTypeName(i + 1);

variabl14892[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

for (int j = 0; j < variabl1525.length; j++)

for (int i = 0; i < variabl26512; i++) {

if (variabl1525[j].toLowerCase().trim()

.equals(variabl25172[i].toLowerCase().trim())) {

variabl12872 = i;

break;

}

}

rs.absolute(1);

c = 0;

b = 0;

while (c < variabl18532) {

rs.absolute(c + 1);

while (b < variabl26512) {

variabl21972[c][b] = rs.getString(b + 1);

b++;

}

c++;

b = 0;

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);

}

}

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl2603;

rs = stat4.executeQuery(s1);

rs.last();

variabl1853 = rs.getRow();

rsmdt4 = rs.getMetaData();

variabl2651 = rsmdt4.getColumnCount();

variabl2517 = new String[variabl2651];

variabl1501 = new String[variabl2651];

variabl1489 = new int[variabl2651];

variabl21973 = new String[variabl1853][variabl2651];

for (int i = 0; i < variabl2651; i++) {

variabl2517[i] = rsmdt4.getColumnName(i + 1);

variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);

variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

for (int j = 0; j < variabl1525.length; j++)

for (int i = 0; i < variabl2651; i++) {

if (variabl1525[j].toLowerCase().trim()

.equals(variabl2517[i].toLowerCase().trim())) {

variabl1287[j] = i;

break;

}

}

rs.absolute(1);

c = 0;

b = 0;

while (c < variabl1853) {

rs.absolute(c + 1);

while (b < variabl2651) {

variabl21973[c][b] = rs.getString(b + 1);

b++;

}

c++;

b = 0;

}

variabl1377 = new String[variabl1853];

for (int j = 0; j < variabl1853; j++) {

variabl1377[j] = "";

for (int i = 0; i < variabl1525.length; i++) {

variabl1377[j] = variabl1377[j]

+ variabl21973[j][variabl1287[i]].trim();

}

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);

}

if (variabl18532 == 0)

variabl2197 = new String[variabl18531][variabl2651];

else

variabl2197 = new String[variabl18531 * variabl18532][variabl2651];

for (int i = 0; i < variabl18531; i++)

for (int j = 0; j < variabl2651; j++)

variabl2197[i][j] = "";

if (variabl18532 > 0)

for (int i = 0; i < variabl18531; i++)

for (int j = 0; j < variabl18532; j++) {

variabl2197[i][variabl1287[0]] = variabl21971[i][variabl12871];

variabl2197[i][variabl1287[1]] = variabl21972[j][variabl12872];

}

else

for (int i = 0; i < variabl18531; i++) {

variabl2197[i][variabl1287[0]] = variabl21971[i][variabl12871];

}

for (int i = 0; i < variabl2197.length; i++)

for (int j = 0; j < variabl21973.length; j++)

if ((variabl2197[i][variabl1287[0]].trim() + variabl2197[i][variabl1287[1]]

.trim()).equals(variabl21973[j][variabl1287[0]]

+ variabl21973[j][variabl1287[1]])) {

for (int k = 0; k < variabl2651; k++) {

if ((k != variabl1287[0]) && (k != variabl1287[1]))

variabl2197[i][k] = variabl21973[j][k];

}

}

variabl1965 = new DefaultTableModel(variabl2197, variabl2517);

variabl2655 = new JTable(variabl1965);

variabl2655.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

variabl2655

.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < variabl2651; i++) {

TableColumn tc = variabl2655.getColumn(variabl2517[i]);

if (variabl2517[i].length() > variabl1489[i])

variabl1489[i] = variabl2517[i].length();

tc.setPreferredWidth(variabl1489[i] * 11);

tc.setMaxWidth(variabl1489[i] * 11);

tc.sizeWidthToFit();

}

variabl2503 = 650;

final JScrollPane scrollPane = new JScrollPane();

scrollPane.setBounds(30, 80, variabl2483 - 100, variabl2503 - 150);

frame1.setBounds(10, 10, variabl2483, variabl2503);

scrollPane.setViewportView(variabl2655);

frame1.add(scrollPane, BorderLayout.CENTER);

variabl2655.addKeyListener(new KeyAdapter() {

public void keyPressed(KeyEvent evt) {

variabl1175 = variabl1175 + evt.getKeyChar();

}

});

variabl2655.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl1175 = "";

}

});

variabl2655.addFocusListener(new FocusAdapter() {

public void focusLost(final FocusEvent arg0) {

variabl2593 = variabl2655.getSelectedRow();

variabl25473 = variabl2655.getSelectedColumn();

variabl1965.setValueAt(variabl1175, variabl2593, variabl25473);

}

});

}

}

转载本文请联系原作者获取授权，同时请注明本文来自程学先科学网博客。
链接地址：https://blog.sciencenet.cn/blog-2551-1121511.html

上一篇：管理信息系统软件生产线源码78-79
下一篇：管理信息系统软件生产线源码82-83