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

好的，这是一个非常具体的问题，我会尽力回答。首先，需要明确一下程序的需求，我们需要实现以下功能：

1. 从数据文件中读取药品编号、药名、药品单价、销售量、销售额信息记录，存储在顺序表中。
2. 对药品单价进行冒泡排序。
3. 对销售量进行快速排序。
4. 对销售额进行堆排序。
5. 对药品编号进行排序，可以采用多种排序算法。

接下来，我会给出一个简单的Java程序示例，用于实现以上功能：

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

public class DrugStore {
    private static final int MAX_SIZE = 100; // 顺序表的最大容量
    private static final String FILE_PATH = "data.txt"; // 数据文件路径

    private Drug[] drugs; // 药品信息记录的顺序表
    private int size; // 顺序表中元素的个数

    // 药品信息的数据结构
    private static class Drug {
        String id; // 药品编号
        String name; // 药名
        double price; // 单价
        int saleAmount; // 销售量
        double saleTotal; // 销售额

        public Drug(String id, String name, double price, int saleAmount, double saleTotal) {
            this.id = id;
            this.name = name;
            this.price = price;
            this.saleAmount = saleAmount;
            this.saleTotal = saleTotal;
        }
    }

    public DrugStore() {
        drugs = new Drug[MAX_SIZE];
        size = 0;
    }

    // 从文件中读取药品信息，并存储在顺序表中
    public void readDataFromFile() throws FileNotFoundException {
        Scanner scanner = new Scanner(new File(FILE_PATH));
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            String[] fields = line.split(" ");
            String id = fields[0];
            String name = fields[1];
            double price = Double.parseDouble(fields[2]);
            int saleAmount = Integer.parseInt(fields[3]);
            double saleTotal = Double.parseDouble(fields[4]);
            drugs[size++] = new Drug(id, name, price, saleAmount, saleTotal);
        }
        scanner.close();
    }

    // 冒泡排序，按照药品单价从小到大排序
    public void bubbleSortByPrice() {
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - i - 1; j++) {
                if (drugs[j].price > drugs[j + 1].price) {
                    Drug temp = drugs[j];
                    drugs[j] = drugs[j + 1];
                    drugs[j + 1] = temp;
                }
            }
        }
    }

    // 快速排序，按照销售量从大到小排序
    public void quickSortBySaleAmount() {
        quickSortBySaleAmount(0, size - 1);
    }

    private void quickSortBySaleAmount(int left, int right) {
        if (left >= right) {
            return;
        }
        int i = left;
        int j = right;
        int pivot = drugs[left].saleAmount;
        while (i < j) {
            while (i < j && drugs[j].saleAmount <= pivot) {
                j--;
            }
            if (i < j) {
                drugs[i] = drugs[j];
                i++;
            }
            while (i < j && drugs[i].saleAmount > pivot) {
                i++;
            }
            if (i < j) {
                drugs[j] = drugs[i];
                j--;
            }
        }
        drugs[i] = new Drug("", "", 0, pivot, 0);
        quickSortBySaleAmount(left, i - 1);
        quickSortBySaleAmount(i + 1, right);
    }

    // 堆排序，按照销售额从大到小排序
    public void heapSortBySaleTotal() {
        for (int i = size / 2 - 1; i >= 0; i--) {
            adjustHeap(i, size);
        }
        for (int i = size - 1; i >= 0; i--) {
            Drug temp = drugs[0];
            drugs[0] = drugs[i];
            drugs[i] = temp;
            adjustHeap(0, i);
        }
    }

    private void adjustHeap(int index, int length) {
        Drug temp = drugs[index];
        for (int k = index * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && drugs[k].saleTotal < drugs[k + 1].saleTotal) {
                k++;
            }
            if (drugs[k].saleTotal > temp.saleTotal) {
                drugs[index] = drugs[k];
                index = k;
            } else {
                break;
            }
        }
        drugs[index] = temp;
    }
    
    // 选择排序，按照药品编号从小到大排序
    public void selectionSortById() {
        for (int i = 0; i < size - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < size; j++) {
                if (drugs[j].id.compareTo(drugs[minIndex].id) < 0) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                Drug temp = drugs[i];
                drugs[i] = drugs[minIndex];
                drugs[minIndex] = temp;
            }
        }
    }

    // 输出顺序表中的药品信息
    public void printDrugs() {
        for (int i = 0; i < size; i++) {
            System.out.println(drugs[i].id + " " + drugs[i].name + " " + drugs[i].price + " " +
                    drugs[i].saleAmount + " " + drugs[i].saleTotal);
        }
    }

    public static void main(String[] args) {
        DrugStore store = new DrugStore();
        try {
            store.readDataFromFile();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        store.bubbleSortByPrice();
        store.quickSortBySaleAmount();
        store.heapSortBySaleTotal();
        store.selectionSortById();
        store.printDrugs();
    }
}

这个程序中，我们定义了一个 `DrugStore` 类，其中包含了一个 `Drug` 类作为内部类。`Drug` 类表示药品信息的数据结构，包含了药品编号、药名、药品单价、销售量、销售额等字段。`DrugStore` 类中有一个 `drugs` 数组用于存储药品信息，以及一个 `size` 字段表示顺序表中元素的个数。

在 `DrugStore` 类中，我们定义了 `readDataFromFile` 方法用于从文件中读取药品信息，并存储在顺序表中；`bubbleSortByPrice` 方法用于按照药品单价从小到大进行冒泡排序；`quickSortBySaleAmount` 方法用于按照销售量从大到小进行快速排序；`heapSortBySaleTotal` 方法用于按照销售额从大到小进行堆排序；`selectionSortById` 方法用于按照药品编号从小到大进行选择排序；`printDrugs` 方法用于输出顺序表中的药品信息。

在 `main` 方法中，我们创建了一个 `DrugStore` 对象，并调用了上述方法来实现程序的功能。

需要注意的是，这个程序中的排序算法只是示例，实际应用中可能需要选择更高效的排序算法来处理大规模数据。同时，程序中也没有对异常情况进行处理，如文件不存在等情况需要根据实际需求进行处理。