Java-12继承

第12章继承

本章内容

• 继承

• 方法重写

• super关键词

• 万物皆对象的原理

• final关键字

第一节继承

1.概念

The idea of inheritance is simple but powerful: When you want to create a new
class and there is already a class that includes some of the code that you
want, you can derive your new class from the existing class. In doing this,
you can reuse the fields and methods of the existing class without having to
write (and debug!) them yourself.
继承的概念很简单但是很强大：当你要创建一个新类并且已经有一个包含所需代码的类时，可以从现有类
中派生新类。这样，你可以重用现有类的字段和方法，而不必自己编写（和调试！）它们。
A subclass inherits all the members (fields, methods, and nested classes)
from its superclass. Constructors are not members, so they are not inherited
by subclasses, but the constructor of the superclass can be invoked from the
subclass.
子类从其父类继承所有成员（字段，方法和嵌套类）。构造方法不是成员，因此它们不会被子类继承，但
是可以从子类中调用父类的构造方法

A class that is derived from another class is called a subclass (also a
derived class, extended class, or child class). The class from which the
subclass is derived is called a superclass (also a base class or a parent
class).
从一个类派生的类称为子类（也可以是派生类，扩展类或子类）。派生子类的类称为超类（也称为基类或
父类）。

构造方法不是变量成员，子类不会继承

2.如何使用继承

语法

public class 子类 extends 父类{
    public void show(){
        System.out.printfln(name);//可以直接使用，因为父类中的成员变量继承过来了
        //方法也可以
    }
}

子类不会继承private的私有成员，但是可以通过继承受到保护的成员方法调用使用私有成员。

继承的属性和方法

A subclass inherits all of the public and protected members of its parent, no
matter what package the subclass is in. If the subclass is in the same
package as its parent, it also inherits the package-private members of the
parent.
不论子类在什么包中，子类会继承父类中所有的公开的和受保护的成员（包括字段和方法）。如果子类和
父类在同一个包中，子类也会继承父类中
受包保护的成员。
A subclass does not inherit the private members of its parent class. However,
if the superclass has public or protected methods for accessing its private
fields, these can also be used by the subclass.
子类不会继承父类中定义的私有成员。尽管如此，如果父类有提供公开或者受保护的访问该字段的方法，
这些方法也能在子类中被使用。

受保护（protect）修饰的内容可以在不同包（package）的子类中继承，默认修饰符只能在本包中在能继承

3.应用场景

public class Programmer {
private String name;
private String sex;
private int age;
private String level;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public void programming(){
System.out.println("程序员编程");
}
public void eat(){
System.out.println("程序员吃饭");
}
}
public class Doctor {
private String name;
private String sex;
private int age;
private String professional;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("医生治病");
}
public void eat(){
System.out.println("医生吃饭");
}
}

直接看代码，初学者可能无法直观的看出问题所在，可以使用类图进行比对
有类图可以看出， Programmer 和 Doctor 两个类中存在大量重复的代码，可以使用继承来进行优化，
以减少重复的编码。

package com.cyx.inheritance.p2;
public class Person {
private String name;
private String sex;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("医生吃饭");
}
}
package com.cyx.inheritance.p2;
public class Doctor extends Person {
private String professional;
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("医生治病");
}
}
package com.cyx.inheritance.p2;
public class Programmer extends Person{
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public void programming(){
System.out.println("程序员编程");
}
}
package com.cyx.inheritance.p2;
public class PersonTest {
public static void main(String[] args) {
Doctor d = new Doctor();
d.setName("Miss Zhang");
d.setSex("女");
d.setAge(18);
d.setProfessional("临床医疗");
d.cure();
d.eat();
Person p1 = new Doctor();//医生是人
p1.setName("Miss Zhang");
p1.setSex("女");
p1.setAge(18);
p1.eat();
//强制类型转换 int number = (int)1.0;
((Doctor)p1).cure();
Person p2 = new Programmer();//程序员是人
p2.setName("马化腾");
p2.setSex("男");
p2.setAge(48);
p2.eat();
((Programmer)p2).programming();
}
}

子类与父类的关系是is - a关系。表示是一个,例如：程序员是人
如果一个对象赋值给其父类的引用，此时想要调用该对象的特有的方法，必须要进行强制类型转换//((Programmer)p2).programming();

2.方法重写

子类中的方法 方法名，参数列表 ,都与父类中的相同，就是方法重写（Override）

@Override 要写在子类要重写的方法的上方

子类的修饰标识符级别要 >= 父类，public>默认(default)>protect>private

协变返回类型子类返回值类型可以是父类方法返回值部分的子类

常见：Integer，Byte，Char，Long……都是Number的子类

父类：

protect Number test(){

}

子类

public Int test(){

}

3.super关键词

1.子类中引用父类的构造方法

2.子类中调用父类中被子类同名成员变量，

this.name //当前姓名

super.name //父节点的姓名

子类的静态方法与父类的静态方法重名算不算重写？

静态方法属于类，不属于对象

万物皆对象

所有的继承关系默认都是（object类）

创建子类就要先调用object的构造方法，object本来就是对象，所以创造出来的也是对象

4.final关键字

方法修饰符应该写在类，变量和方法上

如果一个类被final修饰，意思是这个类是最终的类，不能进行扩展，已经是final了

如果是方法或者成员变量，则不能被继承，因为子类不能够再访问

public static final 表示静态类常量

final修饰的成员变量必须

①在构造函数或者②创建变量时进行赋值，并且final已经是一个常量了，

不能再改变了，这里也可以得出初始必须进行赋值，否则就没有意义了

//构建Chj1d对象时，发现Child是Father的子类，而Father又是object的子类。因此JVM会首先加载object类
//然后再加载Father类，最后再加载child类。而静态代码块是在类第一次加载时执行，而且只会执行一次。因此
//Father类中的静态代码块先执行，然后再执行Child类中的静态代码块。然后才执行new child();代码。
//父类静态代码块执行
//子类静态代码块执行
//父类构造方法执行
//子类构造方法执行
}
}