05_面向对象编程（中）——1.面向对象特征之二：继承性（inheritance）
1. 为什么要有继承？
1) 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
2) 此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”
3) 类继承语法规则:
class Subclass extends SuperClass{ }
2. 继承的作用
1) 减少了代码冗余，提高了代码的复用性。
2) 更有利于功能的扩展。
3) 让类与类之间产生了关系，提供了多态的前提。
3. 继承性的注意事项
1） 不要仅仅为了获取其他类中【某个功能】而去继承。
2） 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
3） 子类继承了父类，就继承了父类的方法和属性。
4） 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
4. 关于继承的规则
1) 子类不能直接访问父类中私有的(private)的成员变量和方法。
2) Java只支持单继承和多层继承，不允许多重继承
一个子类只能有一个父类
一个父类可以派生出多个子类
class SubDemo extends Demo{ } //ok
class SubDemo extends Demo1,Demo2...//error
5. 单继承与多层继承举例
【1. 创建一个 Individual 类】
package com.atzwx.java.inheritance;
public class {
private int id;
private String name;
private int age;
public Individual() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Individual{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void walk() {
System.out.println("Individual.walk");
}
public void display() {
System.out.println("Individual.display");
}
}
【2. 创建一个 Employee 类，继承 Individual 类】
package com.atzwx.java.inheritance;
public class Employee extends Individual {
private int employeeId;
private char gender;
private String homeAddress;
public Employee() {
}
public int getEmployeeId() {
return employeeId;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getHomeAddress() {
return homeAddress;
}
public void setHomeAddress(String homeAddress) {
this.homeAddress = homeAddress;
}
@Override
public String toString() {
return "Employee{" +
"employeeId=" + employeeId +
", gender=" + gender +
", homeAddress='" + homeAddress + '\'' +
'}';
}
public void work() {
System.out.println("Employee.work");
}
public void report() {
System.out.println("Employee.report");
}
}
【3. 创建一个 Farmer 类，继承 Individual 类】
package com.atzwx.java.inheritance;
public class Farmer extends Individual{
private int farmerId;
private char gender;
private String homeAddress;
private int landCount;
public Farmer() {
}
public int getFarmerId() {
return farmerId;
}
public void setFarmerId(int farmerId) {
this.farmerId = farmerId;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getHomeAddress() {
return homeAddress;
}
public void setHomeAddress(String homeAddress) {
this.homeAddress = homeAddress;
}
public int getLandCount() {
return landCount;
}
public void setLandCount(int landCount) {
this.landCount = landCount;
}
@Override
public String toString() {
return "Farmer{" +
"farmerId=" + farmerId +
", gender=" + gender +
", homeAddress='" + homeAddress + '\'' +
", landCount=" + landCount +
'}';
}
public void plough() {
System.out.println("Farmer.plough");
}
public void harvest() {
System.out.println("Farmer.harvest");
}
}
【4. 调用 Employee 对象 和 Farmer 对象的方法】
package com.atzwx.test;
import com.atzwx.java.inheritance.Employee;
import com.atzwx.java.inheritance.Farmer;
import org.junit.Test;
// 单继承与多继承
public class InheritanceTest {
/**
* 单继承
*/
@Test
public void inheritanceTest1() {
Employee employee = new Employee();
System.out.println("=============Employee==============");
employee.walk();
employee.display();
System.out.println();
employee.work();
employee.report();
System.out.println("=============Employee==============");
Farmer farmer = new Farmer();
System.out.println("=============Farmer==============");
farmer.walk();
farmer.display();
System.out.println();
farmer.plough();
farmer.harvest();
System.out.println("=============Farmer==============");
}
}
【output】
=============Employee==============
Individual.walk
Individual.display
Employee.work
Employee.report
=============Employee==============
=============Farmer==============
Individual.walk
Individual.display
Farmer.plough
Farmer.harvest
=============Farmer==============
【5. 创建一个 Programer 类，继承 Employee 类】
package com.atzwx.java.inheritance;
public class Programer extends Employee {
private int programerId;
private int teskCount;
private String test;
public void programming() {
System.out.println("Programer.programming");
}
public void analyzing() {
System.out.println("Programer.analyzing");
}
public void distributing() {
System.out.println("Programer.distributing");
}
}
【6. 调用 Programer 对象的方法】
package com.atzwx.test;
import com.atzwx.java.inheritance.Programer;
import org.junit.Test;
// 单继承与多继承
public class InheritanceTest {
/**
* 多层继承
*/
@Test
public void inheritanceTest2() {
Programer programer = new Programer();
System.out.println("=============Programer==============");
programer.walk();
programer.display();
System.out.println();
programer.work();
programer.report();
System.out.println();
programer.analyzing();
programer.distributing();
programer.programming();
System.out.println("=============Programer==============");
}
}
【output】
=============Programer==============
Individual.walk
Individual.display
Employee.work
Employee.report
Programer.analyzing
Programer.distributing
Programer.programming
=============Programer==============
6. 继承性小结
1) 不要仅仅为了获取其他类中的某个功能就去进行继承
2) 子类不能直接访问父类中的私有的（private）成员变量和方法
3) 在Java中，只有单继承和多层继承；即 一个子类只能有一个父类，一个父类可以派生出多个子类。
eg： 父类 class Dome, 子类 class Dome01, class Dome02, class Dome03
单继承： class Dome01 extends class Dome 结构： 父类 Dome
class Dome02 extends class Dome | |
| |
子类 Dome01 子类 Dome02
多层继承： class Domeo3 extends Dome01 结构： 父类 Dome
|
|
子类 Dome01
|
|
子类 Dome03
4) 在Java中，子类是父类的 “拓展”，子类可以看作是一个 特殊的父类（继承性作为多态性的前提）
