父类的非私有化属性和方法可以默认继承到子类

继承：
父类（SuperClass）和 子类（SonClass）。
父类的非私有化属性和方法可以默认继承到子类。
Class Son extends Father{
}
而如果父类中的私有方法被子类调用的话，则编译报错。
父类的构造方法子类不可以继承，更不存在覆盖的问题。（非构造方法可以）
如果子类访问父类的构造方法，则在编译的时候提示访问不到该方法。
JAVA中不允许多继承，一个类有且只有一个父类（单继承）。
JAVA的数据结构为树型结构，而非网状。（JAVA通过接口和内部类实现多继承）

package TomText;
public class TomText_14 {

         public static void main(String[] args) {
          Date[] days = new Date[6];
          days[0] = new Date(2004, 4, 6);
          days[1] = new Date(2005, 4, 6);
          days[2] = new Date(2004, 6, 4);
          days[3] = new Date(2004, 4, 6);
          days[4] = new Date(2004, 5, 6);
          days[5] = new Date(2002, 8, 16);

          //sortForArray(days);
          bubbleSort(days);
          printArray(days);
          binarySearch2(days,days[3]);
         }
         /*
          * 选择排序
          */
         public static void sortForArray(Date[] d) {
          for(int i=0; i<d.length; i++) {
           int min = i;
           Date bigger;
           for(int j=i+1; j<d.length; j++) {
            if(d[min].compare(d[j]) > 0) {
             min = j;
            }
           }

           if(min != i) {
            bigger = d[i];
            d[i] = d[min];
            d[min] = bigger;
           }
          }
         }
         /*
          * 冒泡排序
          */
         public static void bubbleSort(Date[] d) {
          for(int i=d.length; i>1; i--) {
           Date temp;
           for(int j=0; j<i-1; j++) {
            if(d[j].compare(d[j+1])>0) {
             temp = d[j];
             d[j] = d[j+1];
             d[j+1] = temp;
            }
           }
          }
         }
         public static void printArray(Date[] d) {
          for(int i=0; i<d.length; i++) {
           System.out.println(d[i].year + "." +
                        d[i].month + "."+
                        d[i].day);
          }
         }
         /*
          * 二分法排序
          */
         public static void binarySearch(int[] i,int n) {
          int startNo = 0;
          int lastNo = i.length-1;
          int middle = (startNo + lastNo)/2;

          while(startNo <= lastNo) {
           if(middle == n) {
            System.out.println(middle);
            break;
           }else if(middle > n) {
            lastNo = middle -1;
           }else if(middle < n) {
            startNo = middle + 1;
           }
           middle = (startNo + lastNo)/2;
          }
         }
         /*
          * 形参是对象的二分法
          */
         public static void binarySearch2(Date[] d,Date day) {
          int startNo = 0;       //查找范围内的第一个数的下标
          int lastNo = d.length-1; //查找范围内的最后一个下标
          int middle = (startNo + lastNo)/2; //查找范围内的中间下标
          while(startNo <= lastNo) {
           if(d[middle].compare(day) == 0) {
            System.out.println(middle);
            break;   //必须有,否则有可能会无限循环
           }else if(d[middle].compare(day) == 1) {
            lastNo = middle -1;  //更新最后的下标
           }else if(d[middle].compare(day) == -1) {
            startNo = middle + 1;//更新第一个下标
           }
           //每次判断后需要更新中间下标
           middle = (startNo + lastNo)/2;
          }
         }

        }
        class Date {
         int year,month,day;

         Date(int y, int m, int d) {
          year = y;
          month = m;
          day = d;
         }

         public int compare(Date date) {
          return year > date.year ? 1
            : year < date.year ? -1
            : month > date.month ? 1
            : month < date.month ? -1
            : day > date.day ? 1
            : day < date.day ? -1
            : 0;
         }

}