面相对象三大特性之继承

1.继承（Inheritance）：

Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类[基类]，继承的类叫做子类），Java中的继承使用extends关键字。

PS：

1、子类可以直接访问父类中的非私有的属性和行为。
 2、子类无法继承父类中私有的内容。
 3、父类怎么来的？共性不断向上抽取而来的。

示例：

[java] view plaincopy

1. class Person {  
2.   
3.     String name;  
4.     int age ;  
5. }  
6. class ExtendDemo {  
7.     public static void main(String[] args){  
8.           Student s = new Student();  
9.           s. name = "zhangsan" ;  
10.           s. age = 20;  
11.           s.study();  
12.       
13.           Worker w = new Worker();  
14.           w. name = "lisi" ;  
15.           w. age = 30;  
16.           w.work();  
17.           }  
18.       }           
19. class Worker extends Person{  
20.     void work(){  
21.         System.out.println("worker work..." + age);  
22.     }  
23. }   
24. class Student extends Person{  
25.     void study(){  
26.         System.out.println("student study..." + age);  
27.     }  
28. }  

最后运行结果如图：

由此可见，对象继承的几个好处：

1、继承的出现提高了代码的复用性。
 2、继承的出现让类与类之间产生了关系，提供了多态的前提。

二、对象的特点：

Java只支持单继承，不支持多继承。
 一个类只能有一个父类，不可以有多个父类。

原因：因为多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。

Java支持多层继承(继承体系)：
C继承B，B继承A，就会出现继承体系。多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。
 定义继承需要注意：
 不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属("is a")关系。

三、super关键字

表示父类对象的默认引用；
如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法；
使用super调用父类方法；
使用super调用父类的构造方法；
对super的调用必须是构造器中的第一个语句；
因为static修饰的方法属于类，即调用者是类；

在子父类中，成员的特点体现：

 1.成员变量
this和super的用法很相似。

this代表本类对象的引用。

this不能出现在static修饰的方法中，super也一样不能出现在static修饰的方法中
 super代表父类的内存空间的标识。
 当本类的成员和局部变量同名用this区分。
 当子父类中的成员变量同名用super区分父类。

　

示例：

[java] view plaincopy

1. class Fu{  
2.     private int num = 4;  
3.     public int getNum(){  
4.         return num ;  
5.     }  
6. }  
7. class Zi extends Fu{  
8.     private int num = 5;  
9.     void show(){  
10.         System.out.println(this.num + "..." + super.getNum());  
11.     }  
12. }  
13. class ExtendDemo{  
14.     public static void main(String[] args){  
15.         Zi z = new Zi();  
16.         z.show();  
17.     }  
18. }   

最后程序运行结果如图所示：。

四、成员函数：

当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作，这是函数在子父类中的特性。在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

函数两个特性：
 1.重载，同一个类中。
2.覆盖，子类中，覆盖也称为重写，覆写，override。

[java] view plaincopy

1. class Fu{  
2.   public void show(){  
3.   System.out.println("fu show run" );  
4.   }  
5. }  
6. class Zi extends Fu{  
7.       public void show(){  
8.       System.out.println("zi show run" );  
9.       }  
10.     }  
11. class ExtendDemo{  
12.     public static void main(String[] args){  
13.         Zi z = new Zi();  
14.         z.show();  
15.     }  
16. }   

最后程序运行结果如图所示：。