pxjfuz984
/
test
forked from p4vsywzlp/test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

table部分修改

Browse Source
branch_zyx
郑亦歆 9 months ago
parent 43656d2b42
commit 8a6015ba57
7 changed files with 443 additions and 319 deletions
Show Stats Download Patch File Download Diff File

132
Supermarket/src/com/lingnan/supermarket/table/InOrderTM.java
Unescape View File

@ -1,107 +1,119 @@
package com.lingnan.supermarket.table;
import java.util.List;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.table.AbstractTableModel;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.InOrder;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dialog.InDialog;
// 定义InOrderTM类，该类继承自AbstractTableModel，用于创建表格模型
public class InOrderTM extends AbstractTableModel{
// 定义列名数组，存储表格的列标题
private String [] columnName = {"订单号","总价","时间","负责人","状态"};
// 创建Production接口的实现类对象，用于操作Production数据
private productionImpl prodDao = new productionImpl();
// 定义一个Vector集合，用于存储InOrder对象，表示订单数据
private Vector<InOrder> InOrders;
// 创建inOrderService接口的实现类对象，用于操作InOrder数据
private inOrderServiceImpl inOrderImpl= new inOrderServiceImpl();
// 定义InOrder对象，用于存储当前操作的订单
private InOrder inOrder ;
// 定义一个String变量，用于存储订单号
String iNumber ;/*订单号*/
// 定义方法allInOrderRecord，用于获取所有订单记录
public void allInOrderRecord() {
//将添加的商品加入到静态变量Vector数组中
// 将添加的商品加入到静态变量Vector数组中
/*prod = InDialog.getProduction();*/
// 调用inOrderImpl的findAllInOrder方法，获取所有订单记录，并赋值给InOrders
InOrders = inOrderImpl.findAllInOrder();
}
//查找分类结果
// 定义方法resultOfFind，根据分类结果获取订单记录
public void resultOfFind(int catalog) {
// 如果分类编号为0，获取所有订单记录
if(catalog==0)
InOrders = inOrderImpl.findAllInOrder();
else
// 否则，根据状态获取订单记录
InOrders = inOrderImpl.FindStatus(catalog);
}
//根据订单查找
// 定义方法resultOfNumber，根据订单号查找订单
public void resultOfNumber(String Number) {
// 初始化InOrders集合
InOrders=new Vector<InOrder>();
// 调用inOrderImpl的findByIdinOrder方法，根据订单号查找订单，并添加到InOrders集合中
inOrder = inOrderImpl.findByIdinOrder(Number);
InOrders.add(inOrder);
}
// 重写getRowCount方法，返回表格模型中的行数
@Override
public int getRowCount() {
return InOrders.size();
return InOrders.size(); // 返回InOrders集合的大小，即行数
}
/* public Float getAllPrice() {
/* public Float getAllPrice() {
return BufferImpl.InBufferAllPrice();
}
*/
// 重写getColumnCount方法，返回表格模型中的列数
@Override
public int getColumnCount() {
return columnName.length;
public int getColumnCount() {
return columnName.length; // 返回列名数组的长度，即列的数量
}
// 重写getValueAt方法，根据行索引和列索引获取表格模型中的值
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
inOrder = InOrders.get(rowIndex);
/* System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
iNumber=inOrder.getiNumber();
if(columnIndex==0) {
return inOrder.getiNumber();
}else if(columnIndex==1) {
return inOrder.getAllInPrice();
}else if(columnIndex==2) {
return inOrder.getInDate();
}else if(columnIndex==3) {
return inOrder.getPrincipal();
}else if(columnIndex==4) {
String status = null;
if(inOrder.getStatus()==1)
inOrder = InOrders.get(rowIndex); // 从InOrders集合中获取指定行索引的InOrder对象
/* // 以下为打印调试信息，已被注释
System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
iNumber=inOrder.getiNumber(); // 将当前订单的订单号赋值给iNumber变量
if(columnIndex==0) { // 如果列索引为0
return inOrder.getiNumber(); // 返回订单号
}else if(columnIndex==1) { // 如果列索引为1
return inOrder.getAllInPrice(); // 返回订单的总价
}else if(columnIndex==2) { // 如果列索引为2
return inOrder.getInDate(); // 返回订单的时间
}else if(columnIndex==3) { // 如果列索引为3
return inOrder.getPrincipal(); // 返回订单的负责人
}else if(columnIndex==4) { // 如果列索引为4
String status = null; // 初始化状态字符串
if(inOrder.getStatus()==1) // 根据订单状态设置状态字符串
status= "已入库";
else if(inOrder.getStatus()==2)
status= "待入库";
else if(inOrder.getStatus()==3)
status= "已取消";
return status;
}else {
return null;
return status; // 返回订单的状态
}else { // 如果列索引不匹配上述任何情况
return null; // 返回null
}
}
public String getINumber() { /*返回要修改或删除的记录*/
return iNumber;
// 定义方法getINumber，返回当前对象的订单号，用于修改或删除记录
public String getINumber() {
return iNumber; // 返回当前对象的订单号
}
// 重写getColumnName方法，根据列索引返回对应的列名
@Override
public String getColumnName(int column) {
return columnName[column];
return columnName[column]; // 返回列名数组中对应索引的列名
}
}

121
Supermarket/src/com/lingnan/supermarket/table/InRecordTM.java
Unescape View File

@ -1,91 +1,96 @@
package com.lingnan.supermarket.table;
import java.util.List;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.table.AbstractTableModel;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.InOrder;
import com.lingnan.supermarket.dto.InRecord;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dialog.InDialog;
// 定义InRecordTM类，该类继承自AbstractTableModel，用于创建表格模型
public class InRecordTM extends AbstractTableModel{
// 定义列名数组，存储表格的列标题
private String [] columnName = {"订单号","id","数量","金额"};
// 创建Production接口的实现类对象，用于操作Production数据
private productionImpl prodDao = new productionImpl();
// 定义一个Vector集合，用于存储InRecord对象
private Vector<InRecord> InRecords;
// 创建InRecord接口的实现类对象，用于操作InRecord数据
private inRecordServiceImpl inRecordImpl = new inRecordServiceImpl();
// 创建InRecord对象，用于存储特定的InRecord记录
private InRecord inRecord= new InRecord();
// 定义一个String类型的变量，用于存储订单号
private String iNumber ;/*订单号*/
// 构造方法，接收订单号参数并初始化iNumber变量
public InRecordTM(String iNumber) {
this.iNumber=iNumber;
}
// 定义方法findInRecordByINumber，用于根据订单号查询InRecord记录
public void findInRecordByINumber() {
//将添加的商品加入到静态变量Vector数组中
// 将添加的商品加入到静态变量Vector数组中
/*prod = InDialog.getProduction();*/
// 调用inRecordImpl的findByIdinRecord方法，根据订单号查询记录，并将结果赋值给InRecords
InRecords = inRecordImpl.findByIdinRecord(iNumber);
}
// 重写getRowCount方法，返回表格模型中的行数
@Override
public int getRowCount() {
return InRecords.size();
return InRecords.size(); // 返回InRecords集合的大小，即行数
}
/* public Float getAllPrice() {
/* public Float getAllPrice() {
return BufferImpl.InBufferAllPrice();
}
*/
// 重写getColumnCount方法，返回表格模型中的列数
@Override
public int getColumnCount() {
return columnName.length;
public int getColumnCount() {
return columnName.length; // 返回列名数组的长度，即列的数量
}
// 重写getValueAt方法，根据行索引和列索引获取表格模型中的值
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
inRecord = InRecords.get(rowIndex);
/* System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
iNumber=inRecord.getiNumber();
if(columnIndex==0) {
return inRecord.getiNumber();
}else if(columnIndex==1) {
return inRecord.getId();
}else if(columnIndex==2) {
return inRecord.getSum();
}else if(columnIndex==3) {
return inRecord.getInPrice();
}else {
return null;
inRecord = InRecords.get(rowIndex); // 从InRecords集合中获取指定行索引的InRecord对象
/* 打印调试信息，已被注释掉
System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
iNumber=inRecord.getiNumber(); // 从InRecord对象中获取订单号并赋值给iNumber变量
if(columnIndex==0) { // 如果列索引为0
return inRecord.getiNumber(); // 返回InRecord对象的订单号
}else if(columnIndex==1) { // 如果列索引为1
return inRecord.getId(); // 返回InRecord对象的ID
}else if(columnIndex==2) { // 如果列索引为2
return inRecord.getSum(); // 返回InRecord对象的数量
}else if(columnIndex==3) { // 如果列索引为3
return inRecord.getInPrice(); // 返回InRecord对象的金额
}else { // 如果列索引不匹配上述任何情况
return null; // 返回null
}
}
public String getINumber() { /*返回要修改或删除的记录*/
return iNumber;
// 定义方法getINumber，返回当前对象的订单号，用于修改或删除记录
public String getINumber() {
return iNumber; // 返回当前对象的订单号
}
// 重写getColumnName方法，根据列索引返回对应的列名
@Override
public String getColumnName(int column) {
return columnName[column];
return columnName[column]; // 返回列名数组中对应索引的列名
}
}

156
Supermarket/src/com/lingnan/supermarket/table/InTableModel.java
Unescape View File

@ -1,99 +1,121 @@
package com.lingnan.supermarket.table;
package com.lingnan.supermarket.table; // 定义包名，表示这个类属于com.lingnan.supermarket.table包
import java.util.List;
import java.util.Vector;
import java.util.List; // 导入Java的List接口，用于存储集合数据
import java.util.Vector; // 导入Java的Vector类，用于存储表格数据
import javax.swing.JFrame;
import javax.swing.table.AbstractTableModel;
import javax.swing.JFrame; // 导入Swing库中的JFrame类，用于创建窗口框架
import javax.swing.table.AbstractTableModel; // 导入Swing库中的AbstractTableModel类，用于创建表格模型
import com.lingnan.supermarket.dto.InOrder; // 导入自定义的InOrder类，但在此代码中未使用
import com.lingnan.supermarket.dto.Production; // 导入自定义的Production类，可能用于表示商品的数据传输对象
import com.lingnan.supermarket.dto.User; // 导入自定义的User类，但在此代码中未使用
import com.lingnan.supermarket.dao.UserService; // 导入UserService接口，但在此代码中未使用
import com.lingnan.supermarket.dao.impl.*; // 导入impl包下的所有类，可能包含数据访问层的实现类
import com.lingnan.supermarket.dialog.InDialog; // 导入自定义的InDialog类，但在此代码中未使用
import com.lingnan.supermarket.dto.InOrder;
public class InTableModel extends AbstractTableModel{ // 定义一个名为InTableModel的类，该类继承自AbstractTableModel类，用于创建表格模型
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dialog.InDialog;
private String [] columnName = {"id","名称","数量","单价","价格","保质期","类别","供应商id"}; // 定义一个字符串数组，用于存储表格的列名
private productionImpl prodDao = new productionImpl(); // 创建productionImpl类的实例，用于访问商品数据
private Vector<Production> v; // 声明一个Vector类型的变量，用于存储商品列表
public class InTableModel extends AbstractTableModel{
private String [] columnName = {"id","名称","数量","单价","价格","保质期","类别","供应商id"};
String id ; // 声明一个String类型的变量，用于存储id，但未初始化和使用
private productionImpl prodDao = new productionImpl();
private Vector<Production> v;
String id ;
public InTableModel(Vector<Production> v) {
System.out.println("调用imtablemodel里面的构造函数");
this.v=v;
public InTableModel(Vector<Production> v) { // 定义一个名为InTableModel的构造函数，接收Vector<Production>类型的参数
System.out.println("调用imtablemodel里面的构造函数"); // 打印信息，表示构造函数被调用
this.v=v; // 将传入的参数v赋值给成员变量v
}
// 定义一个方法getRowCount，用来获取集合v中的元素数量
public int getRowCount() {
return v.size();
return v.size(); // 返回集合v的大小，即元素的数量
}
// 定义一个方法getAllPrice，用来计算集合v中所有Production对象的价格总和
public Float getAllPrice() {
Float allPrice=(float) 0;
for(Production p:v) {
allPrice+=p.getPrice();
Float allPrice=(float) 0; // 初始化总价格为0.0
for(Production p:v) { // 遍历集合v中的每一个Production对象
allPrice+=p.getPrice(); // 将当前Production对象的价格加到总价格上
}
return allPrice;
return allPrice; // 返回计算出的总价格
}
// 重写getColumnCount方法，返回表格模型中的列数
@Override
public int getColumnCount() {
return columnName.length;
public int getColumnCount() {
return columnName.length; // 返回列名数组的长度，即列的数量
}
// 重写getValueAt方法，根据行索引和列索引获取表格模型中的值
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
Production p = v.get(rowIndex);
/* System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
id=p.getId();
if(columnIndex==0) {
return p.getId();
}else if(columnIndex==1) {
return p.getName();
}else if(columnIndex==2) {
return p.getSum();
}else if(columnIndex==3) {
return p.getInPrice() ;
}else if(columnIndex==4) {
return p.getPrice() ;
}else if(columnIndex==5) {
return p.getLife();
}else if(columnIndex==6) {
return p.getName2()+p.getId2();
}else if(columnIndex==7) {
return p.getSupplyId();
}else {
return null;
Production p = v.get(rowIndex); // 根据行索引从集合v中获取对应的Production对象
/* 以下是注释掉的打印语句，用于调试，显示行索引、列索引和用户ID
System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex); */
id=p.getId(); // 将Production对象的ID赋值给id变量
if(columnIndex==0) { // 如果列索引为0
return p.getId(); // 返回Production对象的ID
}else if(columnIndex==1) { // 如果列索引为1
return p.getName(); // 返回Production对象的名称
}else if(columnIndex==2) { // 如果列索引为2
return p.getSum(); // 返回Production对象的Sum属性
}else if(columnIndex==3) { // 如果列索引为3
return p.getInPrice(); // 返回Production对象的InPrice属性
}else if(columnIndex==4) { // 如果列索引为4
return p.getPrice(); // 返回Production对象的Price属性
}else if(columnIndex==5) { // 如果列索引为5
return p.getLife(); // 返回Production对象的Life属性
}else if(columnIndex==6) { // 如果列索引为6
return p.getName2()+p.getId2(); // 返回Production对象的Name2和Id2拼接的字符串
}else if(columnIndex==7) { // 如果列索引为7
return p.getSupplyId(); // 返回Production对象的SupplyId属性
}else { // 如果列索引不匹配上述任何情况
return null; // 返回null
}
}
// 定义一个方法getId，用来获取当前对象的ID属性值
public String getId() { /*返回要修改或删除的记录*/
return id;
return id; // 返回当前对象的id字段值
}
// 重写getColumnName方法，根据列索引返回对应的列名
@Override
public String getColumnName(int column) {
return columnName[column];
return columnName[column]; // 返回存储列名的数组中对应索引的列名
}
}

101
Supermarket/src/com/lingnan/supermarket/table/ProdCatalogTM.java
Unescape View File

@ -1,65 +1,76 @@
package com.lingnan.supermarket.table;
package com.lingnan.supermarket.table; // 定义包名，表示这个类属于com.lingnan.supermarket.table包
import java.util.List;
import java.util.Vector;
import java.util.List; // 导入Java的List接口，用于存储集合数据
import java.util.Vector; // 导入Java的Vector类，用于存储表格数据
import javax.swing.table.AbstractTableModel;
import javax.swing.table.AbstractTableModel; // 导入Swing库中的AbstractTableModel类，用于创建表格模型
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dto.Production; // 导入自定义的Production类，可能用于表示商品的数据传输对象
import com.lingnan.supermarket.dto.User; // 导入自定义的User类，但在此代码中未使用
import com.lingnan.supermarket.dao.UserService; // 导入UserService接口，但在此代码中未使用
import com.lingnan.supermarket.dao.impl.*; // 导入impl包下的所有类，可能包含数据访问层的实现类
public class ProdCatalogTM extends AbstractTableModel{ // 定义一个名为ProdCatalogTM的类，该类继承自AbstractTableModel类，用于创建表格模型
public class ProdCatalogTM extends AbstractTableModel{
private String [] columnName = {"类别id","类别名称","商品id","商品名称"};
private String [] columnName = {"类别id","类别名称","商品id","商品名称"}; // 定义一个字符串数组，用于存储表格的列名
private productionImpl prodDao = new productionImpl();
private Vector<Production> prods;
public void all() {
private productionImpl prodDao = new productionImpl(); // 创建productionImpl类的实例，用于访问商品数据
private Vector<Production> prods; // 声明一个Vector类型的变量，用于存储商品列表
public void all() { // 定义一个名为all的方法，无参数
//查找全部数据
prods = prodDao.findAllproduction();
prods = prodDao.findAllproduction(); // 调用prodDao的findAllproduction方法，获取所有商品并赋值给prods变量
}
public void ById2(Production p) {
public void ById2(Production p) { // 定义一个名为ById2的方法，接收Production类型的参数
//查找全部数据
prods = prodDao.findProductionById2(p.getId2());
prods = prodDao.findProductionById2(p.getId2()); // 调用prodDao的findProductionById2方法，根据id2获取商品并赋值给prods变量
}
@Override
public int getRowCount() {
return prods.size();
@Override // 标记该方法重写了父类的方法
public int getRowCount() { // 重写AbstractTableModel类的getRowCount方法，用于获取表格的行数
return prods.size(); // 返回prods的大小，即商品的数量
}
@Override
public int getColumnCount() {
return columnName.length;
@Override // 标记该方法重写了父类的方法
public int getColumnCount() { // 重写AbstractTableModel类的getColumnCount方法，用于获取表格的列数
return columnName.length; // 返回列名数组的长度，即表格的列数
}
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
Production prod = prods.get(rowIndex);
/* System.out.println( "id="+users.get(rowIndex).getId());
@Override // 标记该方法重写了父类的方法
public Object getValueAt(int rowIndex, int columnIndex) { // 重写AbstractTableModel类的getValueAt方法，用于获取表格中指定位置的值
Production prod = prods.get(rowIndex); // 从prods中获取指定行的商品
/* 以下三行代码被注释掉了，可能是用于调试打印信息
System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
if(columnIndex==0) {
return prod.getId2();
}else if(columnIndex==1) {
return prod.getName2();
}else if(columnIndex==2) {
return prod.getId();
}else if(columnIndex==3) {
return prod.getName();
}else {
return null;
if(columnIndex==0) { // 如果列索引为0，即第一列
return prod.getId2(); // 返回类别id
}else if(columnIndex==1) { // 如果列索引为1，即第二列
return prod.getName2(); // 返回类别名称
}else if(columnIndex==2) { // 如果列索引为2，即第三列
return prod.getId(); // 返回商品id
}else if(columnIndex==3) { // 如果列索引为3，即第四列
return prod.getName(); // 返回商品名称
}else { // 如果列索引不匹配以上任何列
return null; // 返回null
}
}
@Override
public String getColumnName(int column) {
return columnName[column];
@Override // 标记该方法重写了父类的方法
public String getColumnName(int column) { // 重写AbstractTableModel类的getColumnName方法，用于获取指定列的名称
return columnName[column]; // 返回columnName数组中指定索引的列名
}
}

125
Supermarket/src/com/lingnan/supermarket/table/StorageRecordTM.java
Unescape View File

@ -1,75 +1,90 @@
package com.lingnan.supermarket.table;
package com.lingnan.supermarket.table; // 定义包名，表示这个类属于com.lingnan.supermarket.table包
import java.util.Vector;
import java.util.Vector; // 导入Java的Vector类，用于存储表格数据
import javax.swing.table.AbstractTableModel; // 导入Swing库中的AbstractTableModel类，用于创建表格模型
import javax.swing.table.AbstractTableModel;
import com.lingnan.supermarket.dao.impl.storageRecordImpl; // 导入自定义的storageRecordImpl类，可能用于处理存储记录的数据访问对象
import com.lingnan.supermarket.dto.StorageRecord; // 导入自定义的StorageRecord类，可能用于表示存储记录的数据传输对象
import com.lingnan.supermarket.dao.impl.storageRecordImpl;
import com.lingnan.supermarket.dto.StorageRecord;
// 以下代码块是类的定义，继承自AbstractTableModel，用于创建表格模型
public class YourClassName extends AbstractTableModel {
// 类的成员变量和方法的定义将在这里开始
}
public class StorageRecordTM extends AbstractTableModel{ // 定义一个名为StorageRecordTM的类，该类继承自AbstractTableModel类，用于创建表格模型
private String [] columnName = {"订单号","操作时间","商品编号","进货+/出货-","数量"}; // 定义一个字符串数组，用于存储表格的列名
private storageRecordImpl srDao = new storageRecordImpl(); // 创建一个storageRecordImpl类的实例，用于操作存储记录的数据
private Vector<StorageRecord> storageRecords; // 声明一个Vector类型的变量，用于存储多个StorageRecord对象
private StorageRecord storageRecord ; // 声明一个StorageRecord类型的变量，用于表示单个存储记录
String oNumber ;/*订单号*/ // 声明一个String类型的变量，用于存储订单号，并添加注释说明
public class StorageRecordTM extends AbstractTableModel{
private String [] columnName = {"订单号","操作时间","商品编号","进货+/出货-","数量"};
private storageRecordImpl srDao = new storageRecordImpl();
private Vector<StorageRecord> storageRecords;
private StorageRecord storageRecord ;
String oNumber ;/*订单号*/
public void allStoragrRecord() {
public void allStoragrRecord() { // 定义一个公共方法，用于获取所有存储记录
//将添加的商品加入到静态变量Vector数组中
/*prod = InDialog.getProduction();*/
storageRecords = srDao.findAllStorageRecord();
/*prod = InDialog.getProduction();*/ // 这行代码被注释掉了，可能是用于从对话框获取商品信息
storageRecords = srDao.findAllStorageRecord(); // 调用srDao的findAllStorageRecord方法，获取所有存储记录并赋值给storageRecords变量
}
@Override
public int getRowCount() {
return storageRecords.size();
@Override // 标记该方法重写了父类的方法
public int getRowCount() { // 重写AbstractTableModel类的getRowCount方法，用于获取表格的行数
return storageRecords.size(); // 返回storageRecords的大小，即存储记录的数量
}
/* public Float getAllPrice() {
return BufferImpl.InBufferAllPrice();
}
*/
@Override
public int getColumnCount() {
return columnName.length;
@Override // 标记该方法重写了父类的方法
public int getColumnCount() { // 重写AbstractTableModel类的getColumnCount方法，用于获取表格的列数
return columnName.length; // 返回列名数组的长度，即表格的列数
}
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
storageRecord = storageRecords.get(rowIndex);
/* System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
oNumber=storageRecord.getTheNumber();
if(columnIndex==0) {
return storageRecord.getTheNumber();
}else if(columnIndex==1) {
return storageRecord.getcDate();
}else if(columnIndex==2) {
return storageRecord.getId();
}else if(columnIndex==3) {
return storageRecord.getExecute();
}else if(columnIndex==4) {
return storageRecord.getNum();
}else {
return null;
@Override // 标记该方法重写了父类的方法
public Object getValueAt(int rowIndex, int columnIndex) { // 重写AbstractTableModel类的getValueAt方法，用于获取表格中指定位置的值
storageRecord = storageRecords.get(rowIndex); // 从storageRecords中获取指定行的存储记录
/* 以下三行代码被注释掉了，可能是用于调试打印信息
System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
oNumber=storageRecord.getTheNumber(); // 从存储记录中获取订单号并赋值给oNumber变量
if(columnIndex==0) { // 如果列索引为0，即第一列
return storageRecord.getTheNumber(); // 返回订单号
}else if(columnIndex==1) { // 如果列索引为1，即第二列
return storageRecord.getcDate(); // 返回操作时间
}else if(columnIndex==2) { // 如果列索引为2，即第三列
return storageRecord.getId(); // 返回商品编号
}else if(columnIndex==3) { // 如果列索引为3，即第四列
return storageRecord.getExecute(); // 返回进货或出货标识
}else if(columnIndex==4) { // 如果列索引为4，即第五列
return storageRecord.getNum(); // 返回数量
}else { // 如果列索引不匹配以上任何列
return null; // 返回null
}
}
@Override
public String getColumnName(int column) {
return columnName[column];
@Override // 标记该方法重写了父类的方法
public String getColumnName(int column) { // 重写AbstractTableModel类的getColumnName方法，用于获取指定列的名称
return columnName[column]; // 返回columnName数组中指定索引的列名
}
}

61
Supermarket/src/com/lingnan/supermarket/table/StorageTableModel.java
Unescape View File

@ -10,45 +10,68 @@ import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
// 定义一个表格模型类，用于存储和生产相关的数据
public class StorageTableModel extends AbstractTableModel{
// 定义列名数组
private String [] columnName = {"id","名称","保质期","数量","类别","供应商编号"};
// 实例化生产数据访问对象
private productionImpl prodDao = new productionImpl();
// 声明一个向量，用于存储生产数据
private Vector<Production> prods;
// 查找所有生产数据的方法
public void all() {
//查找全部数据
// 查找全部数据并赋值给prods
prods = prodDao.findAllproduction();
}
// 根据名称查找生产数据的方法
public void Byname(Production p) {
//查找全部数据
// 查找指定名称的生产数据并赋值给prods
prods = prodDao.findproduction(p.getName());
}
// 重写获取行数的方法
@Override
public int getRowCount() {
// 返回生产数据的数量
return prods.size();
}
// 重写获取列数的方法
@Override
public int getColumnCount() {
public int getColumnCount() {
// 返回列名数组的长度
return columnName.length;
}
// 重写根据行索引和列索引获取单元格值的方法
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
// 获取指定行的生产数据对象
Production prod = prods.get(rowIndex);
/* System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
// 根据列索引返回相应的数据
if(columnIndex==0) {
return prod.getId();
}else if(columnIndex==1) {
return prod.getName();
return prod.getName();
}else if(columnIndex==2) {
return prod.getLife();
return prod.getLife();
}else if(columnIndex==3) {
return prod.getSum();
}else if(columnIndex==4) {
@ -57,13 +80,21 @@ public class StorageTableModel extends AbstractTableModel{
return prod.getSupplyId();
}else {
return null;
}
}
// 重写获取列名的方法
@Override
public String getColumnName(int column) {
// 返回指定列的列名
return columnName[column];
}
}

66
Supermarket/src/com/lingnan/supermarket/table/SupplierTableModel.java
Unescape View File

@ -13,50 +13,59 @@ import com.lingnan.supermarket.dao.impl.*;
public class SupplierTableModel extends AbstractTableModel{
// 定义表格列名数组
private String [] columnName = {"id","名称","地址","联系方式","邮箱"};
//private SupplierInfImpl supplierDao = new SupplierInfImpl();
// 使用供应商信息服务接口，实例化为具体实现类
private SupplierInfService supplierInfService = new SupplierInfImpl();
// 创建供应商信息对象
private SupplierInf supplierInf = new SupplierInf();
// 创建供应商信息向量，用于存储表格数据
private Vector<SupplierInf> suppliers;
// 定义一个ID变量
private int id=0;
// 查找全部供应商信息的方法
public void all() {
//查找全部数据
// 查找全部数据并存储到suppliers向量中
suppliers = supplierInfService.findAllSupplierInf();
}
// 根据名称查找供应商信息的方法
public void Byname(SupplierInf supplierInf) {
// 根据名称查找数据并存储到suppliers向量中
suppliers = supplierInfService.findByNameSupplierInf(supplierInf);
}
// 重写获取行数的方法
@Override
public int getRowCount() {
// 返回供应商信息的数量
return suppliers.size();
}
// 重写获取列数的方法
@Override
public int getColumnCount() {
public int getColumnCount() {
// 返回列名数组的长度
return columnName.length;
}
// 重写获取单元格值的方法
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
// 获取指定行的供应商信息对象
SupplierInf prod = suppliers.get(rowIndex);
//id = supplierInf.getId();
/* System.out.println( "id="+users.get(rowIndex).getId());
System.out.println("rowIndex"+rowIndex);
System.out.println("columnIndex"+columnIndex);*/
// 根据列索引返回相应的数据
if(columnIndex==0) {
return prod.getId();
}else if(columnIndex==1) {
return prod.getName();
return prod.getName();
}else if(columnIndex==2) {
return prod.getAddress();
}else if(columnIndex==3) {
@ -66,13 +75,32 @@ public class SupplierTableModel extends AbstractTableModel{
}
else {
return null;
}
}
@Override
public String getColumnName(int column) {
return columnName[column];
}
}
}
// 重写获取列名的方法
@Override
public String getColumnName(int column) {
// 返回指定列的列名
return columnName[column];
}
/*
public int getId() {

Write Preview
Loading…
Cancel
Save