现在要求定义一个数组类（Array），里面定义了一个整型数组，但是此整型数组属于动态分配大小，即：所有的大小由程序指定，并在此基础上实现以下的两个子类：
                • 反转类：可以将数组的内容反转排列
                • 排序类：可以对数组进行排序的操作
        问：这样的类该如何实现？
        本程序肯定是通过继承实现，每一个都应该是一个具体的操作类。
         

本程序中包含了以下的知识点：
1、继承的基本概念：扩充了类的功能
2、方法的覆写的作用
3、引用传递
4、数组的排序、foreach输出

隐藏内容是什么意思？你自己的答案？？

{:soso_e126:}

1. import java.util.ArrayList;
   
2. import java.util.Arrays;
   
3. import java.util.Collections;
   
4. import java.util.Comparator;
   
5. import java.util.List;
   
6. 
   
7. public class MyDemo {
   
8. 
   
9.         public static void main(String []args){
   
10.        
    
11.                 ReverseArray al = new ReverseArray();
    
12.                 SortArray sa = new SortArray();
    
13. 
    
14.                 al.add(1);
    
15.                 al.add(15);
    
16.                 al.add(7);
    
17.                 al.add(19);
    
18.                 al.add(5);
    
19.                 al.add(29);
    
20.                 al.add(9);
    
21. /*
    
22.                                 al.add(7);
    
23.                 al.add(19);
    
24.                 al.add(5);
    
25.                 al.add(29);
    
26.                 al.add(9);
    
27.                 sa.add(7);
    
28.                 sa.add(19);
    
29.                 sa.add(5);
    
30.                 sa.add(29);
    
31.                 sa.add(9);   */
    
32.                
    
33.                 sa.add(1);
    
34.                 sa.add(15);
    
35.                 sa.add(7);
    
36.                 sa.add(19);
    
37.                 sa.add(5);
    
38.                 sa.add(29);
    
39.                 sa.add(9);
    
40. 
    
41. 
    
42.                 System.out.println(al.toString());
    
43.                 //System.out.println(al);
    
44.                 al.reverse();
    
45.                 System.out.println(al.toString());
    
46.                
    
47.                 System.out.println(sa.toString());
    
48.                 sa.sort();
    
49.                 System.out.println(sa.toString());
    
50. 
    
51.         }
    
52. }
    
53. 
    
54. 
    
55. class Array {
    
56.         private int [] array = new int[10];
    
57.         private int size =0;
    
58.        
    
59.         public int getSize() {
    
60.                 return size;
    
61.         }
    
62.         public void setSize(int size) {
    
63.                 this.size = size;
    
64.         }
    
65.          
    
66.         public int get(int index){
    
67.                 return array[index];
    
68.         }
    
69.        
    
70.         public int set(int index, int element){
    
71.                 array[index] = element;
    
72.                 return get(index);
    
73.         }
    
74.        
    
75.         public boolean add(int i){
    
76.                 size++;
    
77.                 System.out.println(size);
    
78.                 if(size>10)
    
79.                         array = copyArray(array);
    
80. 
    
81.                 array[size-1] = i;
    
82.                 return true;
    
83.         }
    
84.        
    
85.         private int[] copyArray(int[] array){
    
86.                        
    
87.                 int []array1 = new int[array.length+1];
    
88.                
    
89.                 for(int i = 0; i<array.length;i++){
    
90.                         array1[i] = array[i];
    
91.                 }
    
92.                 return array1;
    
93.         }
    
94.        
    
95.         public boolean remove(int index){
    
96.                 if(index>=size)
    
97.                         return false;
    
98.                 else{
    
99.                         int[] array1 = new int[size - 1];
    
100.                         for(int i = 0, count = 0; i<size;i++){
     
101.                                 if(i == index)
     
102.                                         continue;
     
103.                                 array1[count++] = array[i];                               
     
104.                         }
     
105.                         array = array1;
     
106.                         size--;
     
107.                         return true;
     
108.                 }
     
109.         }
     
110.        
     
111.         @Override
     
112.         public String toString() {
     
113.                 // TODO Auto-generated method stub
     
114.                 Integer [] intList = new Integer[size];
     
115.                
     
116.                 for(int i = 0;i<size;i++){//注意角标越界。
     
117.                         intList[i] = get(i);
     
118.                 }
     
119.                 List list = Arrays.asList(intList);
     
120.                 return list.toString();
     
121.         }       
     
122. }
     
123. 
     
124. class ReverseArray extends Array{
     
125.        
     
126.         public void reverse(){
     
127.                 int size = getSize();
     
128.                 int half = size>>1;
     
129.                
     
130.                 for(int i =0,x=0; i< half;i++){
     
131.                         x = get(i);
     
132.                         set(i, get(size-1-i));
     
133.                         set(size-1-i,x);
     
134.                 }
     
135.         }
     
136. 
     
137.        
     
138.         public void sort(){
     
139.                 int size = getSize();
     
140. 
     
141.                 for(int z=0,x=0;z<size-1;z++){
     
142.                         for(int y=z+1; y<size;y++){//y=z+1; 而不是1；
     
143.                                 if(get(z)>get(y)){
     
144.                                         x = get(z);
     
145.                                         set(z, get(y));
     
146.                                         set(y,x);
     
147.                                 }
     
148.                         }
     
149.                 }
     
150.         }
     
151.        
     
152. }
     
153. 
     
154. class SortArray extends Array{
     
155.         public void sort(){
     
156.                 int size = getSize();
     
157. 
     
158.                 for(int z=0,x=0;z<size-1;z++){
     
159.                         for(int y=z+1; y<size;y++){
     
160.                                 if(get(z)>get(y)){
     
161.                                         x = get(z);
     
162.                                         set(z, get(y));
     
163.                                         set(y,x);
     
164.                                 }
     
165.                         }
     
166.                 }
     
167.         }
     
168. }

复制代码

看看我的答案能否满足你的要求，请指教

{:soso_e103:}

我去，这个也能给分

如果问题已解决，请及时修改分类，否则继续提问，谢谢合作！