1. 子父类中的变量

2. 子父类中函数的特点----覆盖
    当子父类中有相同的函数时，子类成员调用函数时的情况属于覆盖，如代码：

  1. /*  子父类中，函数的特点*/ 
  2.       
  3. class Fu  
  4. {  
  5.     void show()  
  6.     {  
  7.         System.out.println("fu show");  
  8.     }  
  9. }  
  10.  
  11. class Zi extends Fu  
  12. {  
  13.     void show()  
  14.     {  
  15.         System.out.println("zi show");  
  16.     }  
  17. }  
  18.  
  19. class ExgtendsDemo3  
  20. {  
  21.     public static void main(String[] args)  
  22.     {  
  23.         Zi z = new Zi();  
  24.         z.show(); //结果为: zi show  
  25.     }  
  26. } 
 
    当子类出现和父类相同的函数时，当子类对象调用该函数，会运行子类函数的内容。这如同父类的函数被覆盖一样，这就是函数的另一个特性：重写（覆盖）。
     覆盖的特点：保留父类的功能定义，并重写功能内容，如添加新内容。
 注意：
     （1）子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
     （2）静态只能覆盖静态
     （3）重载：只看同名函数的参数列表； 重写：子父类方法要一模一样
 
3. 子父类中的构造函数
     （1）对子类对象进行初始化时，父类的构造函数也会运行。 
     因为子类构造函数默认第一行有一条隐式语句super()；
 super()会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();
     （2）子类必须要访问父类中的构造函数
     为什么子类一定要访问父类中的构造函数?
     因为子类可以直接获取父类中的数据，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
     所以子类在对象初始化时，要先访问一下父类中的构造函数。
 如果要访问父类中指定的构造函数，可以通过手动定义super语句方式来指定。
     （3）子类的实例化过程
     this()和super()必须只能存在一个，不能同时存在。 
     子类的所有构造函数默认都会访问父类中空参数的构造函数。
     因为子类每个构造函数内的第一行都有一句隐式super();
     当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的构造函数。
     当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
 子类中至少会有一个构造函数会访问父类中的构造函数。
     通过上面的分析，可知下面这种情况是错误的，因为子类必须要访问父类中的构造函数。
 
  1. class Fu  
  2. {  
  3.     int num=2;  
  4.     /*Fu()  
  5.     {  
  6.         num=60;  
  7.         System.out.println("fu run");  
  8.     }*/ 
  9.     Fu(int x)  
  10.     {  
  11.         System.out.println("fu run"+x);  
  12.     }//*/  
  13. }  
  14.  
  15. class Zi extends Fu  
  16. {  
  17.     Zi()  
  18.     {  
  19.         //super();       //super表示父类构造函数，而this()表示子类构造函数  
  20.         System.out.println("zi run");  
  21.     }  
  22.     Zi(int x)  
  23.     {  
  24.         System.out.println("zi run"+x);  
  25.     }  
  26. }  
  27.  
  28. class ExgtendsDemo4  
  29. {  
  30.     public static void main(String[] args)  
  31.     {  
  32.         Zi z = new Zi(9);                  
  33.         System.out.println(z.num);  //结果出错，因为子类没有使用父类中的构造函数Fu(int x)  
  34.     }  
  35. } 
 
 下面的两个程序是对的，因为子类构造函数默认第一行有一条隐式语句super()。
 
  1. class Fu  
  2. {  
  3.     int num=2;  
  4.     Fu()  
  5.     {  
  6.         num=60;  
  7.         System.out.println("fu run");  
  8.     }  
  9.     Fu(int x)  
  10.     {  
  11.         System.out.println("fu run"+x);  
  12.     }//*/  
  13. }  
  14.  
  15. class Zi extends Fu  
  16. {  
  17.     Zi()  
  18.     {  
  19.         //super();       //super表示父类构造函数，而this()表示子类构造函数  
  20.         System.out.println("zi run");  
  21.     }  
  22.     Zi(int x)  
  23.     {  
  24.         System.out.println("zi run"+x);  
  25.     }  
  26. }  
  27.  
  28. class ExgtendsDemo4  
  29. {  
  30.     public static void main(String[] args)  
  31.     {  
  32.         Zi z = new Zi(9);                  
  33.         System.out.println(z.num);  //结果为：fu run / zi run9 /60  
  34.     }  
  35. } 
 
  1. class Fu  
  2. {  
  3.     int num=2;  
  4. }  
  5.  
  6. class Zi extends Fu  
  7. {  
  8.     Zi()  
  9.     {  
  10.         //super();       //super表示父类构造函数，而this()表示子类构造函数  
  11.         System.out.println("zi run");  
  12.     }  
  13.     Zi(int x)  
  14.     {  
  15.         System.out.println("zi run"+x);  
  16.     }  
  17. }  
  18.  
  19. class ExgtendsDemo4  
  20. {  
  21.     public static void main(String[] args)  
  22.     {  
  23.         Zi z = new Zi(9);                  
  24.         System.out.println(z.num);  //结果为:zi run9 /2  
  25.     }  
  26. } 
 
 举例：
 
  1. class Person  
  2. {  
  3.     private String name;  
  4.     Person(String name)  
  5.     {  
  6.         this.name=name;  
  7.     }  
  8. }  
  9. class Student extends Person  
  10. {  
  11.     Student(String name)  
  12.     {  
  13.         super(name); //父类中已经定义好内容，在子类中没必要再定义。通过super即可  
  14.     }  
  15.     void method()  
  16.     {  
  17.         super.show();  
  18.     }  
  19. } 
 
 4. final关键字
 
  1. /* final:最终，作为一个修饰符   
  2. 1. 可以修饰类，函数，变量。  
  3. 2. 被final修饰的类不可以被继承（因为继承有缺点，即打破了封装性）,所以为了避免被继承，被子类复写。  
  4. 3. 被final修饰的方法不可被复写。  
  5. 4. 被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量，通过用于修饰不  
  6.     需要再改变值的变量。常量的书写要求所有字母都大写；多个单词间用_连接。  
  7. 5. 内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。  
  8. */ 
  9.       
  10. final class Demo  
  11. {  
  12.     final int x = 3; //x终身为4  
  13.     public static final double PI = 3.14 //全局常量  
  14.     final void show1()  
  15.     {}  
  16.     void show2()  
  17. }  
  18. class SubDemo extends Demo  
  19. {  
  20.     void show1()  //不可复写  
  21. } 
 
 5. 抽象类
 
  1. /*  
  2.     当多个类有相同（名称）的功能，但是功能内容不同，  
  3. 这时可以进行向上抽取，只抽取功能定义(只搭一个框架)。  
  4.       
  5.     抽象：即看不懂  
  6. 抽象类的特点：  
  7.     1. 抽象方法必须存放在抽象类中，必须被abstract关键字修饰  
  8.     2. 抽象类不可以用new创建对象，因为调用抽象方法没意义  
  9.     3. 抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。  
  10. 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。  
  11.     4. 抽象类中既可以有抽象方法，也可以非抽象方法。  
  12. 抽象方法表示无法定义主体，其功能是不确定的，所以可延续到子类中去做。  
  13.     5. 抽象类可以不定义抽象方法。比一般类多了几个抽象函数，抽象类不可以实例化，即不可建立对象。  
  14. */ 
  15.  
  16. class Student  
  17. {  
  18.     abstract void study();  
  19.     abstract void study1(); //若加此句，由3知，BaseStudent还是抽象类。  
  20.     void sleep()  
  21.     {  
  22.         System.out.println("sleep");  
  23.     }  
  24. }  
  25. class BaseStudent extends Student    
  26. {  
  27.     void study()  
  28.     {  
  29.         System.out.println("base study");  
  30.     }  
  31. }  
  32. class AdvStudent extends Student  
  33. {  
  34.     void study()  
  35.     {  
  36.         System.out.println("adv study");  
  37.     }  
  38. }     
  39. class AbstractDemo  
  40. {  
  41.     public statc  
  42. }