Java 在jtable中计算，总计为%

我的项目快结束了，在解决它时遇到了一些问题。我是一名厨师，希望自己的应用程序与自己的业务相关

我的表单称为Recipes，使用了数量单价%

比如说，你有1公斤苹果，5欧元。在清洁结束时，你只有800克苹果。所以我多付了20%

例子

• 项目始终为100%
• 数量5
• 单价5
• 使用百分比100%总计=25

数量5，单价5，使用百分比70%，总计=32.5（必须增加30%）

最后，我必须计算食品成本

所以“总成本/售价*100”

我被这个密码困住了。请有人能帮助我进一步与我的项目。 我一周前才认识java。所以我没有时间好好学习。每天工作12小时

这在eclipse的标题中

public class Recipe extends javax.swing.JFrame {
    double Qty;
    double UnitPrice;
    double Used;
    double total;
    double subTotal;
    private static Connection connection = null;
    private JPanel contentPane;
    Connection conn=null;

如图所示，您可以在

getValueAt（）的实现中计算派生值。在下面的例子中


COLUMN\u PERCENT
是表中每行工资与
sum（）
工资的比率

百分比列还获取
PercentFormatter
的实例，以将派生值格式化为百分比



导入java.awt.BorderLayout；
导入java.awt.Component；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.text.NumberFormat；
导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.DefaultRowSorter；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JScrollPane；
导入javax.swing.JTable；
导入javax.swing.table.AbstractTableModel；
导入javax.swing.table.DefaultTableCellRenderer；
导入javax.swing.table.TableModel；
/**
*@见https://stackoverflow.com/posts/38192710/edit
*@见https://stackoverflow.com/a/37913520/230513
*@见https://stackoverflow.com/a/37892395/230513
*/
公共类JTablePercentTotalExample{
公共静态void main（字符串[]args）{
invokeLater（JTablePercentTotalExample:：display）；
}
公共静态无效显示（）{
JFrame f=新的JFrame（“JTable排序示例”）；
f、 setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
List listEmployees=createListEmployees（）；
TableModel model=新员工TableModel（列出员工）；
JTable表格=新JTable（型号）{
@凌驾
公共维度getPreferredScrollableViewportSize（）{
返回新维度（500，getRowCount（）*getRowHeight（））；
}
};
table.getColumnModel（）.getColumn（3）.setCellRenderer（新的CurrencyFormatter（））；
table.getColumnModel（）.getColumn（4）.setCellRenderer（新的PercentFormatter（））；
表.setAutoCreateRowSorter（真）；
DefaultRowSorter-sorter=（DefaultRowSorter）table.getRowSorter（）；
分拣机。可设置分拣（4，错误）；
f、 添加（新的JScrollPane（表），BorderLayout.CENTER）；
f、 包装（）；
f、 setLocationRelativeTo（空）；
f、 setVisible（真）；
}
私有静态列表createListEmployees（）{
List listEmployees=new ArrayList（）；
添加（新员工（“彼得”，“经理”，40000））；
添加（新员工（“保罗”，“程序员”，25000））；
添加（新员工（“玛丽”，“设计师”，25000））；
添加（新员工（“唐纳德”，“领导者”，30000））；
添加（新员工（“汤姆”，“设计师”，28000））；
添加（新员工（“Samantha”，“分析师”，50000））；
添加（新员工（“Jerome”，“程序员”，32000））；
添加（新员工（“乔纳森”，“开发者”，29000））；
添加（新员工（“凯文”，“程序员”，23000））；
添加（新员工（“安东尼”，“程序员”，23000））；
添加（新员工（“约翰”，“设计师”，33000））；
添加（新员工（“David”，“Developer”，28000））；
添加（新员工（“哈里”，“设计师”，31000））；
添加（新员工（“查尔斯”，“程序员”，26000））；
添加（新员工（“约瑟夫”，“经理”，40000））；
返回员工；
}
私有静态类EmployeeTableModel扩展了AbstractTableModel{
私有静态final int COLUMN_NUM=0；
私有静态final int COLUMN_NAME=1；
私有静态final int COLUMN_JOB=2；
私有静态最终整数列_工资=3；
私有静态最终整数列_百分比=4；
私有最终字符串[]columnNames={“否”、“名称”、“职务”、“工资”、“百分比”}；
私人最终员工名单；
公共雇员表格模型（列出雇员）{
this.listEmployees=listEmployees；
int indexCount=1；
适用于（员工：列表员工）{
setIndex（indexCount++）；
}
}
@凌驾
public int getColumnCount（）{
返回columnNames.length；
}
@凌驾
public int getRowCount（）{
return listEmployees.size（）；
}
@凌驾
公共字符串getColumnName（int columnIndex）{
返回columnNames[columnIndex]；
}
@凌驾
公共类getColumnClass（int columnIndex）{
返回getValueAt（0，columnIndex）.getClass（）；
}
@凌驾
公共对象getValueAt（int行索引、int列索引）{
Employee=listEmployees.get（rowIndex）；
开关（列索引）{
案例栏编号：
return employee.getIndex（）；
案例列名称：
返回employee.getName（）；
案例栏作业：
return employee.getJob（）；
案例栏(工资):
JButton btnNewButtonAdd = new JButton("Add");
// btnNewButtonAdd.setIcon(new // ??      
btnNewButtonAdd.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent evt) {
        int i=100;
        Qty=Double.parseDouble(textFieldQty.getText());
        UnitPrice=Double.parseDouble(txtUnitPrice.getText());
        Used=Double.parseDouble(textFieldUsed.getText());
        //Used=subTotal/100;
        subTotal=Qty*UnitPrice;
        //total=subTotal*Used;
        //Used=subTotal/100;
        total=subTotal*(Used/100);//(100+Used);

        String TotalRow= String.format("%.2f", total);
        txtTotal.setText(TotalRow);

        DefaultTableModel model=(DefaultTableModel) table.getModel();
        model.addRow(new Object[]{textFieldQty.getText(), BoxCategory.getSelectedItem(), 
            BoxDescription.getSelectedItem(), textFieldItemID.getText(), 
            txtUnitPrice.getText(), BoxUnit.getSelectedItem(), textFieldUsed.getText(), 
            txtTotal.getText()});
    }
}

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import javax.swing.DefaultRowSorter;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableModel;

/**
 * @see https://stackoverflow.com/posts/38192710/edit
 * @see https://stackoverflow.com/a/37913520/230513
 * @see https://stackoverflow.com/a/37892395/230513
 */
public class JTablePercentTotalExample {

    public static void main(String[] args) {
        EventQueue.invokeLater(JTablePercentTotalExample::display);
    }

    public static void display() {
        JFrame f = new JFrame("JTable Sorting Example");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        List<Employee> listEmployees = createListEmployees();
        TableModel model = new EmployeeTableModel(listEmployees);
        JTable table = new JTable(model) {
            @Override
            public Dimension getPreferredScrollableViewportSize() {
                return new Dimension(500, getRowCount() * getRowHeight());
            }
        };
        table.getColumnModel().getColumn(3).setCellRenderer(new CurrencyFormatter());
        table.getColumnModel().getColumn(4).setCellRenderer(new PercentFormatter());
        table.setAutoCreateRowSorter(true);
        DefaultRowSorter sorter = (DefaultRowSorter) table.getRowSorter();
        sorter.setSortable(4, false);
        f.add(new JScrollPane(table), BorderLayout.CENTER);
        f.pack();
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

    private static List<Employee> createListEmployees() {
        List<Employee> listEmployees = new ArrayList<>();
        listEmployees.add(new Employee("Peter", "Manager", 40000));
        listEmployees.add(new Employee("Paul", "Programmer", 25000));
        listEmployees.add(new Employee("Mary", "Designer", 25000));
        listEmployees.add(new Employee("Donald", "Leader", 30000));
        listEmployees.add(new Employee("Tom", "Designer", 28000));
        listEmployees.add(new Employee("Samantha", "Analyst", 50000));
        listEmployees.add(new Employee("Jerome", "Programmer", 32000));
        listEmployees.add(new Employee("Jonathon", "Developer", 29000));
        listEmployees.add(new Employee("Kevin", "Programmer", 23000));
        listEmployees.add(new Employee("Anthony", "Programmer", 23000));
        listEmployees.add(new Employee("John", "Designer", 33000));
        listEmployees.add(new Employee("David", "Developer", 28000));
        listEmployees.add(new Employee("Harry", "Designer", 31000));
        listEmployees.add(new Employee("Charles", "Programmer", 26000));
        listEmployees.add(new Employee("Joseph", "Manager", 40000));
        return listEmployees;
    }

    private static class EmployeeTableModel extends AbstractTableModel {

        private static final int COLUMN_NUM = 0;
        private static final int COLUMN_NAME = 1;
        private static final int COLUMN_JOB = 2;
        private static final int COLUMN_SALARY = 3;
        private static final int COLUMN_PERCENT = 4;
        private final String[] columnNames = {"No", "Name", "Job", "Salary", "Percent"};
        private final List<Employee> listEmployees;

        public EmployeeTableModel(List<Employee> listEmployees) {
            this.listEmployees = listEmployees;
            int indexCount = 1;
            for (Employee employee : listEmployees) {
                employee.setIndex(indexCount++);
            }
        }

        @Override
        public int getColumnCount() {
            return columnNames.length;
        }

        @Override
        public int getRowCount() {
            return listEmployees.size();
        }

        @Override
        public String getColumnName(int columnIndex) {
            return columnNames[columnIndex];
        }

        @Override
        public Class<?> getColumnClass(int columnIndex) {
            return getValueAt(0, columnIndex).getClass();
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            Employee employee = listEmployees.get(rowIndex);
            switch (columnIndex) {
                case COLUMN_NUM:
                    return employee.getIndex();
                case COLUMN_NAME:
                    return employee.getName();
                case COLUMN_JOB:
                    return employee.getJob();
                case COLUMN_SALARY:
                    return employee.getSalary();
                case COLUMN_PERCENT:
                    int salary = (int) getValueAt(rowIndex, COLUMN_SALARY);
                    return Double.valueOf(salary / (double) sum());
                default:
                    throw new IllegalArgumentException("Invalid column index");
            }
        }

        private int sum() {
            int sum = 0;
            for (int r = 0; r < getRowCount(); r++) {
                sum += (int) getValueAt(r, COLUMN_SALARY);
            }
            return sum;
        }
    }

    private static class Employee {

        private int index;
        private String name;
        private String job;
        private int salary;

        public Employee(String name, String job, int salary) {
            this.name = name;
            this.job = job;
            this.salary = salary;
        }

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getJob() {
            return job;
        }

        public void setJob(String job) {
            this.job = job;
        }

        public int getSalary() {
            return salary;
        }

        public void setSalary(int age) {
            this.salary = age;
        }
    }

    private static class CurrencyFormatter extends DefaultTableCellRenderer {

        private final NumberFormat nf = NumberFormat.getCurrencyInstance();

      @Override
        public Component getTableCellRendererComponent(JTable jTable, Object value,
            boolean isSelected, boolean hasFocus, int row, int column) {
            Component c = super.getTableCellRendererComponent(jTable, value,
                isSelected, hasFocus, row, column);
            if (c instanceof JLabel && value instanceof Number) {
                JLabel label = (JLabel) c;
                label.setHorizontalAlignment(JLabel.RIGHT);
                Number num = (Number) value;
                String text = nf.format(num);
                label.setText(text);
            }
            return c;
        }
    }

    private static class PercentFormatter extends DefaultTableCellRenderer {

        private NumberFormat nf = NumberFormat.getPercentInstance();

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value,
            boolean isSelected, boolean hasFocus, int row, int column) {
            Component c = super.getTableCellRendererComponent(table, value,
                isSelected, hasFocus, row, column);
            if (c instanceof JLabel && value instanceof Number) {
                JLabel label = (JLabel) c;
                label.setHorizontalAlignment(JLabel.RIGHT);
                Number num = (Number) value;
                String text = nf.format(num);
                label.setText(text);
            }
             return c;
        }
    }
}