1. package com.itcast.test1;
   
2. 
   
3. public class AbstractConstructorDemo {
   
4.         /**
   
5.          * 在父类中（这里就是你的抽象类）只写了有参数的构造函数，
   
6.          * 在子类继承是就必须写一个构造函数来调用父类的构造函数。
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 new Student1();
   
10.                 //new Person(); // 抽象类可以有构造函数，但是不能实例化。
    
11.         }
    
12. 
    
13. }
    
14. abstract class Person { //定义一个抽象类，必须被继承  
    
15.         Person() {
    
16.                 System.out.println("抽象类无参数构造函数已运行");
    
17.         }
    
18.     Person(int i) {
    
19.             System.out.println(i);
    
20.             System.out.println("抽象类有参数构造函数已运行");
    
21.     }
    
22. }
    
23. 
    
24. class Student1 extends Person {
    
25.         /*private int i = 0;
    
26.         Student1(int i) {
    
27.             super(i);//必须显示的调用父类构造方法
    
28.             System.out.println(this.i);
    
29.             System.out.println("学生类构造函数已运行");        
    
30.     }
    
31.     */
    
32.         public Student1() {               
    
33.                 //super(0); // 可不写
    
34.                 System.out.println("学生类构造函数已运行");
    
35.         }
    
36. }
    
37. 
    

复制代码

o(∩_∩)o 哈哈，满足你哦，全套的，从接口到抽象类，到实现抽象类，到使用实现后的类的方法，嘿嘿~

1. public class Exercise25_01 {
   
2.         public static void main(String[] args) {
   
3.                 MyArrayList<String> list1 = new MyArrayList<String>();
   
4.                 list1.add("Tom");
   
5.                 list1.add("George");
   
6.                 list1.add("Peter");
   
7.                 list1.add("Jean");
   
8.                 list1.add("Jane");
   
9. 
   
10.                 MyArrayList<String> list2 = new MyArrayList<String>();
    
11.                 list2.add("Tom");
    
12.                 list2.add("George");
    
13.                 list2.add("Michael");
    
14.                 list2.add("Michelle");
    
15.                 list2.add("Daniel");
    
16. 
    
17.                 list1.addAll(list2);
    
18.                 System.out.println(list1);
    
19. 
    
20.                 list1.removeAll(list2);
    
21.                 System.out.println(list1);
    
22. 
    
23.                 list1.retainAll(list2);
    
24.                 System.out.println(list1);
    
25.         }
    
26. 
    
27. }
    
28. 
    
29. interface MyList<E> {
    
30.         public void add(E e);
    
31. 
    
32.         public void add(int index, E e);
    
33. 
    
34.         public void clear();
    
35. 
    
36.         public boolean contains(E e);
    
37. 
    
38.         public E get(int index);
    
39. 
    
40.         public int indexOf(E e);
    
41. 
    
42.         public boolean isEmpty();
    
43. 
    
44.         public int lastIndexOf(E e);
    
45. 
    
46.         public boolean remove(E e);
    
47. 
    
48.         public E remove(int index);
    
49. 
    
50.         public Object set(int index, E e);
    
51. 
    
52.         public int size();
    
53. 
    
54.         public boolean addAll(MyList<E> otherList);
    
55. 
    
56.         public boolean removeAll(MyList<E> otherList);
    
57. 
    
58.         public boolean retainAll(MyList<E> otherList);
    
59. 
    
60. }
    
61. 
    
62. abstract class MyAbstrcatList<E> implements MyList<E> {
    
63.         protected int size = 0;
    
64. 
    
65.         protected MyAbstrcatList() {
    
66.         }
    
67. 
    
68.         protected MyAbstrcatList(E[] object) {
    
69.                 for (int i = 0; i < object.length; i++)
    
70.                         add(object[i]);
    
71.         }
    
72. 
    
73.         public void add(E e) {
    
74.                 add(size, e);
    
75.         }
    
76. 
    
77.         public boolean addAll(MyList<E> otherList) {
    
78.                 if (otherList != null) {
    
79.                         addAll(otherList);
    
80.                         return true;
    
81.                 } else
    
82.                         return false;
    
83.         }
    
84. 
    
85.         public boolean removeAll(MyList<E> otherList) {
    
86.                 if (otherList != null) {
    
87.                         removeAll(otherList);
    
88.                         return true;
    
89.                 } else
    
90.                         return false;
    
91.         }
    
92. 
    
93.         public boolean retainAll(MyList<E> otherList) {
    
94.                 if (otherList != null) {
    
95.                         retainAll(otherList);
    
96.                         return true;
    
97.                 } else
    
98.                         return false;
    
99.         }
    
100. 
     
101.         public boolean isEmpty() {
     
102.                 return size == 0;
     
103.         }
     
104. 
     
105.         public int size() {
     
106.                 return size;
     
107.         }
     
108. 
     
109.         public boolean remove(E e) {
     
110.                 if (indexOf(e) >= 0) {
     
111.                         remove(indexOf(e));
     
112.                         return true;
     
113.                 }
     
114.                 return false;
     
115.         }
     
116. 
     
117. }
     
118. 
     
119. class MyArrayList<E> extends MyAbstrcatList<E> {
     
120.         public static final int INITIAL_CAPACITY = 16;
     
121.         private E[] data = (E[]) new Object[INITIAL_CAPACITY];
     
122. 
     
123.         public MyArrayList() {
     
124. 
     
125.         }
     
126. 
     
127.         public MyArrayList(E[] objects) {
     
128.                 for (int i = 0; i < objects.length; i++)
     
129.                         add(objects[i]);
     
130.         }
     
131. 
     
132.         public void add(int index, E e) {
     
133.                 ensureCapacity();
     
134.                 for (int i = size - 1; i >= index; i--)
     
135.                         data[i] = data[i + 1];
     
136. 
     
137.                 data[index] = e;
     
138. 
     
139.                 size++;
     
140.         }
     
141. 
     
142.         private void ensureCapacity() {
     
143.                 if (size >= data.length) {
     
144.                         E[] newData = (E[]) new Object[2 * size + 1];
     
145.                         System.arraycopy(data, 0, newData, 0, size);
     
146.                         data = newData;
     
147.                 }
     
148.         }
     
149. 
     
150.         public void clear() {
     
151.                 data = (E[]) new Object[INITIAL_CAPACITY];
     
152.                 size = 0;
     
153.         }
     
154. 
     
155.         public boolean contains(E e) {
     
156.                 for (int i = 0; i < size; i++)
     
157.                         if (e.equals(data[i]))
     
158.                                 return true;
     
159.                 return false;
     
160.         }
     
161. 
     
162.         public E get(int index) {
     
163.                 return data[index];
     
164.         }
     
165. 
     
166.         public int indexOf(E e) {
     
167.                 for (int i = 0; i < size; i++)
     
168.                         if (e.equals(data[i]))
     
169.                                 return i;
     
170.                 return -1;
     
171.         }
     
172. 
     
173.         public int lastIndexOf(E e) {
     
174.                 for (int i = size - 1; i >= 0; i--)
     
175.                         if (e.equals(data[i]))
     
176.                                 return i;
     
177.                 return -1;
     
178.         }
     
179. 
     
180.         public E remove(int index) {
     
181.                 E e = data[index];
     
182. 
     
183.                 for (int i = index; i < size - 1; i++)
     
184.                         data[i] = data[i + 1];
     
185. 
     
186.                 data[size - 1] = null;
     
187. 
     
188.                 size--;
     
189. 
     
190.                 return e;
     
191.         }
     
192. 
     
193.         public E set(int index, E e) {
     
194.                 E old = data[index];
     
195.                 data[index] = e;
     
196.                 return old;
     
197.         }
     
198. 
     
199.         public String toString() {
     
200.                 StringBuilder result = new StringBuilder("[");
     
201. 
     
202.                 for (int i = 0; i < size; i++) {
     
203.                         result.append(data[i]);
     
204.                         if (i < size - 1)
     
205.                                 result.append(", ");
     
206.                 }
     
207. 
     
208.                 return result.toString() + "]";
     
209.         }
     
210. 
     
211.         public void trimToSize() {
     
212.                 if (size != data.length) {
     
213.                         E[] newData = (E[]) new Object[size];
     
214.                         System.arraycopy(data, 0, newData, 0, size);
     
215.                         data = newData;
     
216.                 }
     
217.         }
     
218. 
     
219.         public boolean removeAll(MyList<E> otherList) {
     
220.                 for (int i = 0; i < otherList.size(); i++) {
     
221.                         remove(otherList.get(i));
     
222.                 }
     
223. 
     
224.                 for (int i = 0; i < otherList.size(); i++) {
     
225.                         if (!data.equals(otherList.get(i)))
     
226.                                 return false;
     
227.                 }
     
228. 
     
229.                 return true;
     
230.         }
     
231. 
     
232.         public boolean retainAll(MyList<E> otherList) {
     
233.                 if (!removeAll(otherList))
     
234.                         return false;
     
235.                 if (!removeAll(otherList))
     
236.                         return false;
     
237.                 return true;
     
238.         }
     
239. 
     
240.         public boolean addAll(MyList<E> otherList) {
     
241.                 for (int i = 0; i < otherList.size(); i++)
     
242.                         add(otherList.get(i));
     
243.                 for (int i = 0; i < otherList.size(); i++) {
     
244.                         if (data.equals(otherList.get(i)))
     
245.                                 return false;
     
246.                 }
     
247. 
     
248.                 return true;
     
249. 
     
250.         }
     
251. }
     

复制代码

王渠 发表于 2012-7-26 19:19
o(∩_∩)o 哈哈，满足你哦，全套的，从接口到抽象类，到实现抽象类，到使用实现后的类的方法，嘿嘿~ ...

看起来像数据结构与算法课程里要写的顺序表。

黑马刘涛 发表于 2012-7-26 19:25
看起来像数据结构与算法课程里要写的顺序表。

是自己做的书籍的里面的题目哦，而且的确全是自己写的。
是先学习了泛型，再学习集合后，做的题目。也应该和数据结构有一定关系吧

{:soso_e135:}   完全看不懂。。。 先存起来  学到了 再拿出来瞧瞧。

王渠 发表于 2012-7-26 19:31
是自己做的书籍的里面的题目哦，而且的确全是自己写的。
是先学习了泛型，再学习集合后，做的题目。也应 ...

写的不错，看起来很清爽。我再好好看看:lol