黑马程序员技术交流社区

标题: 写个关于抽象类构造函数的例子看看 [打印本页]
作者: 黑马刘涛    时间: 2012-7-26 17:36
标题: 写个关于抽象类构造函数的例子看看
  1. package com.itcast.test1;

  3. public class AbstractConstructorDemo {
  4.         /**
  5.          * 在父类中（这里就是你的抽象类）只写了有参数的构造函数，
  6.          * 在子类继承是就必须写一个构造函数来调用父类的构造函数。
  7.          */
  8.         public static void main(String[] args) {
  9.                 new Student1();
  10.                 //new Person(); // 抽象类可以有构造函数，但是不能实例化。
  11.         }

  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. }

  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. }

复制代码
作者: 王渠    时间: 2012-7-26 19:19
本帖最后由 王渠 于 2012-7-26 19:23 编辑

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");

  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");

  17.                 list1.addAll(list2);
  18.                 System.out.println(list1);

  20.                 list1.removeAll(list2);
  21.                 System.out.println(list1);

  23.                 list1.retainAll(list2);
  24.                 System.out.println(list1);
  25.         }

  27. }

  29. interface MyList<E> {
  30.         public void add(E e);

  32.         public void add(int index, E e);

  34.         public void clear();

  36.         public boolean contains(E e);

  38.         public E get(int index);

  40.         public int indexOf(E e);

  42.         public boolean isEmpty();

  44.         public int lastIndexOf(E e);

  46.         public boolean remove(E e);

  48.         public E remove(int index);

  50.         public Object set(int index, E e);

  52.         public int size();

  54.         public boolean addAll(MyList<E> otherList);

  56.         public boolean removeAll(MyList<E> otherList);

  58.         public boolean retainAll(MyList<E> otherList);

  60. }

  62. abstract class MyAbstrcatList<E> implements MyList<E> {
  63.         protected int size = 0;

  65.         protected MyAbstrcatList() {
  66.         }

  68.         protected MyAbstrcatList(E[] object) {
  69.                 for (int i = 0; i < object.length; i++)
  70.                         add(object[i]);
  71.         }

  73.         public void add(E e) {
  74.                 add(size, e);
  75.         }

  77.         public boolean addAll(MyList<E> otherList) {
  78.                 if (otherList != null) {
  79.                         addAll(otherList);
  80.                         return true;
  81.                 } else
  82.                         return false;
  83.         }

  85.         public boolean removeAll(MyList<E> otherList) {
  86.                 if (otherList != null) {
  87.                         removeAll(otherList);
  88.                         return true;
  89.                 } else
  90.                         return false;
  91.         }

  93.         public boolean retainAll(MyList<E> otherList) {
  94.                 if (otherList != null) {
  95.                         retainAll(otherList);
  96.                         return true;
  97.                 } else
  98.                         return false;
  99.         }

  101.         public boolean isEmpty() {
  102.                 return size == 0;
  103.         }

  105.         public int size() {
  106.                 return size;
  107.         }

  109.         public boolean remove(E e) {
  110.                 if (indexOf(e) >= 0) {
  111.                         remove(indexOf(e));
  112.                         return true;
  113.                 }
  114.                 return false;
  115.         }

  117. }

  119. class MyArrayList<E> extends MyAbstrcatList<E> {
  120.         public static final int INITIAL_CAPACITY = 16;
  121.         private E[] data = (E[]) new Object[INITIAL_CAPACITY];

  123.         public MyArrayList() {

  125.         }

  127.         public MyArrayList(E[] objects) {
  128.                 for (int i = 0; i < objects.length; i++)
  129.                         add(objects[i]);
  130.         }

  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];

  137.                 data[index] = e;

  139.                 size++;
  140.         }

  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.         }

  150.         public void clear() {
  151.                 data = (E[]) new Object[INITIAL_CAPACITY];
  152.                 size = 0;
  153.         }

  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.         }

  162.         public E get(int index) {
  163.                 return data[index];
  164.         }

  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.         }

  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.         }

  180.         public E remove(int index) {
  181.                 E e = data[index];

  183.                 for (int i = index; i < size - 1; i++)
  184.                         data[i] = data[i + 1];

  186.                 data[size - 1] = null;

  188.                 size--;

  190.                 return e;
  191.         }

  193.         public E set(int index, E e) {
  194.                 E old = data[index];
  195.                 data[index] = e;
  196.                 return old;
  197.         }

  199.         public String toString() {
  200.                 StringBuilder result = new StringBuilder("[");

  202.                 for (int i = 0; i < size; i++) {
  203.                         result.append(data[i]);
  204.                         if (i < size - 1)
  205.                                 result.append(", ");
  206.                 }

  208.                 return result.toString() + "]";
  209.         }

  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.         }

  219.         public boolean removeAll(MyList<E> otherList) {
  220.                 for (int i = 0; i < otherList.size(); i++) {
  221.                         remove(otherList.get(i));
  222.                 }

  224.                 for (int i = 0; i < otherList.size(); i++) {
  225.                         if (!data.equals(otherList.get(i)))
  226.                                 return false;
  227.                 }

  229.                 return true;
  230.         }

  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.         }

  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.                 }

  248.                 return true;

  250.         }
  251. }
复制代码
作者: 黑马刘涛    时间: 2012-7-26 19:25
王渠 发表于 2012-7-26 19:19
o(∩_∩)o 哈哈，满足你哦，全套的，从接口到抽象类，到实现抽象类，到使用实现后的类的方法，嘿嘿~ ...

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

是自己做的书籍的里面的题目哦，而且的确全是自己写的。
是先学习了泛型，再学习集合后，做的题目。也应该和数据结构有一定关系吧
作者: 307881191    时间: 2012-7-26 20:25
{:soso_e135:}   完全看不懂。。。 先存起来  学到了 再拿出来瞧瞧。
作者: 黑马刘涛    时间: 2012-7-26 21:16
王渠 发表于 2012-7-26 19:31
是自己做的书籍的里面的题目哦，而且的确全是自己写的。
是先学习了泛型，再学习集合后，做的题目。也应 ...

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2