用java编写一个程序，首先从数据文件中读出药品编号、药名、药品单价、销售量、销售额信息记录，存储在顺序表中,其中药品编号共4位，采用字母和数字混合编号，如：A125，前一位为大写字母，后三位为数字，在本系统中，对药品单价的排序采用冒泡排序法，对销售量的排序采用快速排序法，对销售额的排序采用堆排序法，对药品编号进行排序时，可采用多种排序法。

好的，这是一个比较复杂的问题，需要编写比较多的代码，我来解答并给出参考代码。

首先，我们需要定义一个药品类，包含药品编号、药名、药品单价、销售量、销售额这五个属性。代码如下：

public class Medicine {
    private String id; // 药品编号
    private String name; // 药名
    private double price; // 药品单价
    private int salesVolume; // 销售量
    private double salesAmount; // 销售额

    // 构造函数
    public Medicine(String id, String name, double price, int salesVolume, double salesAmount) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.salesVolume = salesVolume;
        this.salesAmount = salesAmount;
    }

    // getter和setter方法
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getSalesVolume() {
        return salesVolume;
    }

    public void setSalesVolume(int salesVolume) {
        this.salesVolume = salesVolume;
    }

    public double getSalesAmount() {
        return salesAmount;
    }

    public void setSalesAmount(double salesAmount) {
        this.salesAmount = salesAmount;
    }
}

接下来，我们需要定义一个顺序表类，用于存储药品信息记录。代码如下：

public class MedicineList {
    private Medicine[] medicines; // 存储药品信息的数组
    private int size; // 数组中元素的个数

    // 构造函数
    public MedicineList(int capacity) {
        medicines = new Medicine[capacity];
        size = 0;
    }

    // 在顺序表的末尾添加一个元素
    public void add(Medicine medicine) {
        if (size == medicines.length) {
            // 如果数组已满，需要扩容
            Medicine[] newMedicines = new Medicine[medicines.length * 2];
            System.arraycopy(medicines, 0, newMedicines, 0, medicines.length);
            medicines = newMedicines;
        }
        medicines[size] = medicine;
        size++;
    }

    // 冒泡排序法，根据药品单价对顺序表中的药品信息记录进行排序
    public void sortByPrice() {
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - 1 - i; j++) {
                if (medicines[j].getPrice() > medicines[j + 1].getPrice()) {
                    Medicine temp = medicines[j];
                    medicines[j] = medicines[j + 1];
                    medicines[j + 1] = temp;
                }
            }
        }
    }

    // 快速排序法，根据销售量对顺序表中的药品信息记录进行排序
    public void sortBySalesVolume() {
        sortBySalesVolume(0, size - 1);
    }

    // 快速排序的递归函数
    private void sortBySalesVolume(int left, int right) {
        if (left >= right) {
            return;
        }
        int i = left;
        int j = right;
        Medicine pivot = medicines[left];
        while (i < j) {
            while (i < j && medicines[j].getSalesVolume() <= pivot.getSalesVolume()) {
                j--;
            }
            medicines[i] = medicines[j];
            while (i < j && medicines[i].getSalesVolume() >= pivot.getSalesVolume()) {
                i++;
            }
            medicines[j] = medicines[i];
        }
        medicines[i] = pivot;
        sortBySalesVolume(left, i - 1);
        sortBySalesVolume(i + 1, right);
    }

    // 堆排序法，根据销售额对顺序表中的药品信息记录进行排序
    public void sortBySalesAmount() {
        for (int i = size / 2 - 1; i >= 0; i--) {
            adjustHeap(i, size);
        }
        for (int i = size - 1; i >= 0; i--) {
            Medicine temp = medicines[0];
            medicines[0] = medicines[i];
            medicines[i] = temp;
            adjustHeap(0, i);
        }
    }

    // 调整堆
    private void adjustHeap(int i, int length) {
        Medicine temp = medicines[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && medicines[k].getSalesAmount() < medicines[k + 1].getSalesAmount()) {
                k++;
            }
            if (medicines[k].getSalesAmount() > temp.getSalesAmount()) {
                medicines[i] = medicines[k];
                i = k;
            } else {
                break;
            }
        }
        medicines[i] = temp;
    }

    // 插入排序法，根据药品编号对顺序表中的药品信息记录进行排序
    public void sortById() {
        for (int i = 1; i < size; i++) {
            Medicine temp = medicines[i];
            int j = i - 1;
            while (j >= 0 && medicines[j].getId().compareTo(temp.getId()) > 0) {
                medicines[j + 1] = medicines[j];
                j--;
            }
            medicines[j + 1] = temp;
        }
    }

    // 输出顺序表中的药品信息记录
    public void display() {
        for (int i = 0; i < size; i++) {
            Medicine medicine = medicines[i];
            System.out.println(medicine.getId() + "\t" + medicine.getName() + "\t" + medicine.getPrice() + "\t"
                    + medicine.getSalesVolume() + "\t" + medicine.getSalesAmount());
        }
    }
}

最后，我们需要编写一个主函数，用于读取数据文件，创建顺序表，并对其进行各种排序操作。代码如下：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 从数据文件中读取药品信息记录
        MedicineList medicineList = new MedicineList(10);
        try {
            Scanner scanner = new Scanner(new File("data.txt"));
            while (scanner.hasNext()) {
                String line = scanner.nextLine();
                String[] parts = line.split("\t");
                String id = parts[0];
                String name = parts[1];
                double price = Double.parseDouble(parts[2]);
                int salesVolume = Integer.parseInt(parts[3]);
                double salesAmount = Double.parseDouble(parts[4]);
                Medicine medicine = new Medicine(id, name, price, salesVolume, salesAmount);
                medicineList.add(medicine);
            }
            scanner.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        // 根据药品单价进行排序
        medicineList.sortByPrice();
        System.out.println("按药品单价排序：");
        medicineList.display();

        // 根据销售量进行排序
        medicineList.sortBySalesVolume();
        System.out.println("按销售量排序：");
        medicineList.display();

        // 根据销售额进行排序
        medicineList.sortBySalesAmount();
        System.out.println("按销售额排序：");
        medicineList.display();

        // 根据药品编号进行排序
        medicineList.sortById();
        System.out.println("按药品编号排序：");
        medicineList.display();
    }
}

以上就是这个程序的全部代码，它实现了从数据文件中读取药品信息记录，存储在顺序表中，并对其进行各种排序操作。需要注意的是，这里只是提供了一种可能的实现方式，实际上还有很多其他的方法可以完成类似的任务。