abstract class AbstractSortAlgorithm{
private String algorithmName; //排序算法的名字
private long nanoTime; //排序算法所用时间，单位纳秒
private int[] intNumbers; //排序的整数
private int[] sortNumber; //按照从小到大的排序后的整数
//构造方法，用于设置排序算法的名称及待排序的整数
public AbstractSortAlgorithm(String algorithmName,int[] intNumbers){
this.algorithmName=algorithmName;
this.intNumbers=intNumbers;
}
public void setAlgrithmName(String algorithmName){
this.algorithmName=algorithmName;
}
public String getAlgorithmName(){
return algorithmName;
}
public void setNanoTime(long nanoTime){
this.nanoTime=nanoTime;
}
public long getNanoTime(){
return nanoTime;
}
public void setIntNimbers(int[] intNumbers){
this.intNumbers=intNumbers;
}
public int[] getIntNumbers(){
return intNumbers;
}
public void setSortNumber(int[] sortNumber){
this.sortNumber=sortNumber;
}
public int[] getSortNumber(){
return sortNumber;
}
//输出数组中的数据
public void outNumber(int[] number){
for(int i=0;i
System.out.print(number[i]+" ");
}
System.out.println();
}
//sortAlgorithm（）为无返回值的抽象方法，在具体的排序算发子类中有不同的实现
public abstract void sortAlgorithm(); //定义起泡排序sortAlgorithm
}
//第一个子类，起泡排序类
class Bubble extends AbstractSortAlgorithm{
public Bubble(String name,int[] intNumber){
super(name,intNumber); //调用父类的构造的方法
}
//起泡排序的实现
public void sortAlgorithm(){
long t1=System.nanoTime(); //获取排序前系统的时间
int[] number=this.getIntNumbers(); //获取要排序的数据
//对10个整数采用起泡排序法进行从小到大的排序
for(int i=1;i
for(int j=0;j
if(number[j]>number[j+1]){
int temp;
temp=number[j];
number[j]=number[j+1];
number[j+1]=temp;
}
}
}
long t2=System.nanoTime();
this.setNanoTime(t2-t1);
this.setSortNumber(number);
}
}
//第二个子集，选择排序算法
class Select extends AbstractSortAlgorithm{
public Select(String name,int[] intNumber){
super(name,intNumber); //调用父类的构造函数
}
//选择排序算法方法的实现
public void sortAlgorithm(){
long t1=System.nanoTime();
int[] number=this.getIntNumbers();
//对10个整数进行从小到大排序
System.out.println(number[0]+"dsdds11111");
int min_index;
for(int i=0;i<10-1;i++){
min_index=i;
for(int j=i+1;j<10;j++){
if(number[j]<number[min_index]){
min_index=j;
}
}
if(min_index!=i){
int temp;
temp=number[i];
number[i]=number[min_index];
number[min_index]=temp;
}
}
long t2=System.nanoTime();
this.setNanoTime(t2-t1);
this.setSortNumber(number);
}
}
public class AbstractAlgothrimTest {
public static void main(String[] args) {
int[] numberBubble=new int[10];
int[] numberSelect=new int[10];
Bubble a=new Bubble("起泡排序法",numberBubble);
int randomNumber;
for(int i=0;i<10;i++){ //suzhufuzhi
randomNumber=(int) (Math.random()*1000);
numberBubble[i]=randomNumber;
System.out.println(numberBubble[0]+"libolin");
numberSelect[i]=randomNumber;
//System.out.println(numberSelect[i]+"libolin");
}
AbstractSortAlgorithm[ ] asa=new AbstractSortAlgorithm[2];
asa[0]= new Bubble("起泡排序法",numberBubble); //生成起泡算法对象
asa[1]=new Select("选择排序法",numberSelect); //生成排序算法对象
outputOrderedNumber(asa);
}
public static void outputOrderedNumber(AbstractSortAlgorithm[] asa){
for(int i=0;i<asa.length;i++){
System.out.println("排序名称："+asa[i].getAlgorithmName());
System.out.println("排序前10个整数为：");
System.out.println(asa[i].getIntNumbers()); //输出待排序的整数序列
System.out.println("执行排序算法中…………");
asa[i].sortAlgorithm(); //调用排序算法
System.out.println("排序后10个整数为：");
System.out.println(asa[i].getSortNumber()); //输出排好的数
System.out.println("算法所用时间为："+asa[i].getNanoTime()+"纳秒");
System.out.println();
}
}
}
