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

继承：

父类（SuperClass）和 子类（SonClass）。

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

Class Son extends Father{

}

而如果父类中的私有方法被子类调用的话，则编译报错。

 

父类的构造方法子类不可以继承，更不存在覆盖的问题。（非构造方法可以）

如果子类访问父类的构造方法，则在编译的时候提示访问不到该方法。

JAVA中不允许多继承，一个类有且只有一个父类（单继承）。

JAVA的数据结构为树型结构，而非网状。（JAVA通过接口和内部类实现多继承）

  1 package TomText;
  2 
  3 
  4 
  5 public class TomText_14 {
  6     
  7          public static void main(String[] args) {
  8           Date[] days = new Date[6];
  9           days[0] = new Date(2004, 4, 6);
 10           days[1] = new Date(2005, 4, 6);
 11           days[2] = new Date(2004, 6, 4);
 12           days[3] = new Date(2004, 4, 6);
 13           days[4] = new Date(2004, 5, 6);
 14           days[5] = new Date(2002, 8, 16);
 15           
 16           //sortForArray(days);
 17           bubbleSort(days);
 18           printArray(days);
 19           binarySearch2(days,days[3]);
 20          }
 21          /*
 22           * 选择排序
 23           */
 24          public static void sortForArray(Date[] d) {
 25           for(int i=0; i<d.length; i++) {
 26            int min = i;
 27            Date bigger;
 28            for(int j=i+1; j<d.length; j++) {
 29             if(d[min].compare(d[j]) > 0) {
 30              min = j;
 31             }
 32            }
 33            
 34            if(min != i) {
 35             bigger = d[i];
 36             d[i] = d[min];
 37             d[min] = bigger;
 38            }
 39           }
 40          }
 41          /*
 42           * 冒泡排序
 43           */
 44          public static void bubbleSort(Date[] d) {
 45           for(int i=d.length; i>1; i--) {
 46            Date temp;
 47            for(int j=0; j<i-1; j++) {
 48             if(d[j].compare(d[j+1])>0) {
 49              temp = d[j];
 50              d[j] = d[j+1];
 51              d[j+1] = temp;
 52             }
 53            }
 54           }
 55          }
 56          public static void printArray(Date[] d) {
 57           for(int i=0; i<d.length; i++) {
 58            System.out.println(d[i].year + "." + 
 59                         d[i].month + "."+
 60                         d[i].day);
 61           }
 62          }
 63          /*
 64           * 二分法排序
 65           */
 66          public static void binarySearch(int[] i,int n) {
 67           int startNo = 0;
 68           int lastNo = i.length-1;
 69           int middle = (startNo + lastNo)/2;
 70           
 71           while(startNo <= lastNo) {
 72            if(middle == n) {
 73             System.out.println(middle);
 74             break;
 75            }else if(middle > n) {
 76             lastNo = middle -1;
 77            }else if(middle < n) {
 78             startNo = middle + 1;
 79            }
 80            middle = (startNo + lastNo)/2;
 81           }
 82          }
 83          /*
 84           * 形参是对象的二分法
 85           */
 86          public static void binarySearch2(Date[] d,Date day) {
 87           int startNo = 0;       //查找范围内的第一个数的下标
 88           int lastNo = d.length-1; //查找范围内的最后一个下标
 89           int middle = (startNo + lastNo)/2; //查找范围内的中间下标
 90           while(startNo <= lastNo) {
 91            if(d[middle].compare(day) == 0) {
 92             System.out.println(middle);
 93             break;   //必须有,否则有可能会无限循环
 94            }else if(d[middle].compare(day) == 1) {
 95             lastNo = middle -1;  //更新最后的下标
 96            }else if(d[middle].compare(day) == -1) {
 97             startNo = middle + 1;//更新第一个下标
 98            }
 99            //每次判断后需要更新中间下标
100            middle = (startNo + lastNo)/2;
101           }
102          }
103          
104         }
105         class Date {
106          int year,month,day;
107          
108          Date(int y, int m, int d) {
109           year = y;
110           month = m;
111           day = d;
112          }
113          
114          public int compare(Date date) {
115           return year > date.year ? 1
116             : year < date.year ? -1
117             : month > date.month ? 1
118             : month < date.month ? -1
119             : day > date.day ? 1
120             : day < date.day ? -1
121             : 0;
122          }
123         
124 }