降序奇数和升序偶数

输入2N个不间断无序自然数，例如，5,3,6,1,4,2，在一行输出降序奇书和升序偶数，例如，5,3,1,2,4,6。
要求:
1、使用接口机制或抽象类。
2、声明保存2N个自然数、N个奇数和N个偶数的整形数组以及N，作为接口实现类或抽象类的子类的成员变量。
3、系统地生成getters和setters以及构造函数。
4、必须有输入数组、输出数组、数组排序、数组逆序以及从2N个数中分离出奇数和偶数等成员方法或抽象方法。

import java.util.Scanner;

abstract class A {
	public abstract void sort(int a[]);
 	public abstract void re_sort(int a[]);
 	public abstract void divide(int a[], int odd1[], int even1[]);
}

public class Sort extends A {
 	int n;
 	int array[], odd[], even[];

	//系统地生成getters、setters和构造函数
 	public Sort(int n, int[] array, int[] odd, int[] even) {
  		super();
  		this.n = n;
  		this.array = array;
  		this.odd = odd;
  		this.even = even;
 	}
 	public int getN() {
  		return n;
 	}
 	public void setN(int n) {
  		this.n = n;
 	}
 	public int[] getArray() {
  		return array;
 	}
 	public void setArray(int[] array) {
  		this.array = array;
 	}
 	public int[] getOdd() {
  		return odd;
 	}
 	public void setOdd(int[] odd) {
  		this.odd = odd;
 	}
 	public int[] getEven() {
  		return even;
 	}
 	public void setEven(int[] even) {
  		this.even = even;
 	}
 	//正序，冒泡排序
	@Override
 	public void sort(int[] a) {
  		boolean flag = true;
  		for (int i = 0 ; i<a.length-1 ; i++)
  		{
   			for(int j = 0 ; j<a.length-1-i ; j++)
         		{
    				if (a[j]>a[j+1])
             			{
     					int t = a[j];
                 			a[j] = a[j+1];
                 			a[j+1] = t;
                 			flag = false;
             			}
         		}
         		if (flag)	break;
     		}  
 	}
	//逆序，冒泡排序
	@Override
 	public void re_sort(int[] a) {
 		boolean flag = true;
 		for (int i = 0 ; i<a.length-1 ; i++)
 	 	{
   			for(int j = 0 ; j<a.length-1-i ; j++)
         		{
    				if (a[j]<a[j+1])
            			{
     					int t = a[j];
                 			a[j] = a[j+1];
                		 	a[j+1] = t;
                 			flag = false;
             			}
         		}
         		if (flag)	break;
     		} 
 	}
	//将数组，分为奇数组和偶数组
	@Override
 	public void divide(int a[], int odd1[], int even1[]) {
  		int j = 0, k = 0;
  		for(int i = 0; i < a.length; i++) {
   			if(a[i]%2 == 1) {
    				odd1[j] = a[i];
    				j++;
   			}
  	 		else {
    				even1[k] = a[i];
    				k++;
   			}  
  		} 
 	} 
	//输出数组
	public void outputArray(int[] a) {
 	 	for (int i : a)
            	System.out.print(i+" ");
 	}
	//输入数组
	public void inputArray() {
  		Scanner scanner = new Scanner(System.in); 
  		boolean flag;
  
  		System.out.println("请输入N的值：");
  		n = scanner.nextInt();
  		//分配空间
 		array = new int[2*n];
  		odd = new int[n];
  		even = new int[n];
  
 	 	System.out.println("请输入"+2*n+"个不间断无序自然数：");
  		do {
   			flag = false;
   			for(int i = 0; i < array.length; i++) {   
    				array[i] = scanner.nextInt();
   	 			if(array[i] < 0) {
     					System.out.println("输入有误！需全部重新输入：");
     					flag = true;
    				}     
   			}
  		}while(flag);
  		System.out.println("输入完成！");
 	}
	//主函数
	public static void main(String[] args) { 
  		Sort array = new Sort(0, null, null, null);
  
  		System.out.println("输入2N个不间断无序自然数，在一行输出降序奇书和升序偶数。");  
  		array.inputArray();
  		//分离奇数和偶数
  		array.divide(array.getArray(), 	array.getOdd(), array.getEven());
  		//排序
  		array.re_sort(array.getOdd());
  		array.sort(array.getEven());
  		//输出
  		array.outputArray(array.getOdd());
  		array.outputArray(array.getEven());  
 	}
}