本文实例讲述了Java面向对象编程之类的继承。分享给大家供大家参考，具体如下：
继承：特殊类拥有一般类的全部属性与行为。
继承好处：
1.提高了代码的复用性
2.让类与类之前产生了关系，有了这个关系才有多态的特性。继承是类和类之前的关系。
注意事项：
1.java只支持单继承，不支持多继承。因为多继承有安全隐患：当多个父类定义相同的函数，但是功能不同时，子类不知道运行哪一个。
2.子类继承父类时，继承了父类的所有方法和属性，可直接使用。
3，java支持多层继承，即：孙-子-父的关系
语法：
|
1
2
3
|
[类修饰符] class 子类名 extends 父类名{ 语句;} |
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
class Pserson{ int age; String name; public void speak() { System.out.println("Hello World!"); }}//继承Person类，继承了父类所有方法和属性class Student extends Pserson{ public void study() { System.out.println("Good Study!"); }}//继承Person类，继承了父类所有方法和属性class Worker extends Pserson{ public void work() { System.out.println("Good work!"); }} |
如何使用一个继承体系中的功能（查阅api文档）：
查阅父类的功能，创建子类对象使用功能
在继承过程中经常遇到这三种场景：
1)同名变量
1.如果子类出现非私有的同名成员变量时，子类访问本类的变量，用this;子类访问父类中的同名变量，用super。
2.this代表本类对象的引用
3.super代表父类对象的引用（用法和this相同）
2)同名函数
1.如果子类出现和父类一模一样的函数时（函数名和参数都相同），当子类对象调用该函数，会运行子类函数内容。，父类的函数会被覆盖（也叫重写）。
2.重写定义：当子类继承父类，沿袭了父类的功能，到子类中。但子类虽具备该功能，但功能的内容和父类不一致，这时，没有必须要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。
3.重写（覆盖）注意事项：
<1>子类覆盖父类，必须保证子类的权限大于等于父类的权限，才能继承，否则编译失败。（public>不写修辞关键词>private）
<2>静态只能覆盖静态
<3>重载：只看同名函数的参数列表 重写：子父类方法要一模一样（函数名和参数列表）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class Fu{ //public void show() 当父类为show()时，会和子类函数一模一样，父类的show函数会被重写 public void show(String name) //父类的show函数和子类不一样（参数列表不一样），因此父类的show函数不会被重写 { System.out.println(name); }}class Zi extends Fu{ public void show() { System.out.println("zi"); }}class Jicheng{ public static void main(String[] args) { Zi z1=new Zi(); z1.show("nihao");//会调用父类的show函数 }} |
3)构造函数
1.在对子类对象进行初始化时，父类的构造函数也会运行，因为子类的构造函数的第一行默认有一条隐式语句super()
2.super()会访问父类中空参数的构造函数，而且子类中所有的构造函数第一行默认都是super()
3.子类一定要访问父类构造函数原因
<1>因为父类中的数据子类可以直接获取，所以子类在创建是，先看看父类如何对这些数据进行初始化的，所以子类在对象初始化时，默认先访问父类的构造函数。
<2>若要访问父类制定的构造函数或者父类没有空参数的构造函数时，可以通过手动定义super语句的方式来制定。
<3>当然子类的构造函数第一行也可以手动指定this语句来访问本类的构造函数，但子类中至少有一个构造函数会访问父类的构造函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
class Fu{ String name; int age; Fu(){System.out.println("Hello Fu");} Fu(String name) { System.out.println(name); } Fu(String name,int age) { this.name=name; this.age=age; System.out.println("name: "+name+",age: "+age); }}class Zi extends Fu{ //Zi(){System.out.println("Hello Zi");} 默认先会调用父类的无参构造函数 Zi() { super("zhangsan",20);//手动用super语句指定父类的构造函数，来获取父类非私有的信息 System.out.println(name+"::"+age); }}class Test{ public static void main(String[] args) { Zi z1=new Zi(); }} |
构造函数异常例子：
写出程序结果
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class Super{ int i=0; public Super(String s) { i=1; }}class Demo extends Super{ public Demo(String s) { i=2; } public static void main(String[] args) { Demo d=new Demo("yes"); System.out.println(d.i); }}//编译失败，因为父类中缺少空参数的构造函数。//或者子类应该通过super语句指定要调用的父类中的构造函数。 |
重写和重载例子：
|
1
2
3
4
|
class Demo{ int show(int a,int b){return 0;}} |
下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以，覆盖。
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。<br><br>因此子类允许重写和重载。
希望本文所述对大家java程序设计有所帮助。
原文链接：http://www.cnblogs.com/paulwinflo/p/7992942.html
