2020-09-08

标题 继承

语法:修饰符 Subject extends SuperClass{
//类定义部分
}
继承（inheritance）通过extends关键字来实现，其中的SubClass称为子类，SuperClass成为父类，基类或超类。

示例：
/*宠物类，狗狗和企鹅的父类/
public class Pet{
private String name=“无名氏”；//昵称
private int health=100；//健康值
private int love=0；//亲密度
//无参构造
public Pet(){
this.health=95；
System.out.println(“执行宠物的无参构造方法。”);
}
//有参构造
public Pet(String name){
this.name=name；
｝
public String getName(){
return name；
｝
public String getHealth(){
return health；
｝
public iint getLove(){
return love;
}
//输出宠物信息
public void print(){
System.out.println(“宠物的自白:\n我的名字叫”+this.name+"，我的健康值是"+this.health+"，我和主人的亲密度是"+this.love+"。")；
}
}

Dog继承宠物类
public class Dog extends Pet{
private String strain；//品种
public Dog(String name,String strain){
super(name)；//此处不能使用this.name=name
this.strain=strain;
}
public String getStrain(){
return strain;
}
}

企鹅类:
public class Penguin extends Pet{
private String sex；//性别
pubic Penguin(String name，String sex）｛
super(name);
this.sex=sex；
｝
public String getSex(){
return sex；
｝
｝

测试类:
public class Test{
public static void main(String[] args){
//创建宠物对象pet并输出信息
Pet pet=new Pet(“贝贝”)；
pet.print()；
//创建狗狗队象dog并输出信息
Dog dog=new Dog(“欧欧”，“雪纳瑞”)；
dog.print()；
//创建企鹅对象pgn并输出信息
Penguin pgn=new Penguin(“楠楠”，“Q妹”)；
pgn.print()；
｝
｝

继承是面相对象的三大特性之一，是Java实现代码重用的重要手段之一。java中只支持单继承，每个类只能有一个直接父类。继承表达的是is-a的关系。

在java中子类可以从父类中继承哪些财产呢?
继承public和protected修饰的属性和方法，无论子类和父类是否在同一个包里。
继承默认权限修饰的属性和方法，但子类和父类必须在同一个包里。
无法继承private修饰的属性和方法
无法继承父类的构造方法。

重载和重写的区别：
重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型，访问修饰符无关。
重写涉及的是子类和父类之间的同名方法，要求方法名相同，参数列表相同，返回值类型相同，访问修饰符不能严于父类。

super代表当前对象的直接父类对象的默认引用。
super必须出现在子类(子类的方法和构造方法)中，而不是其他位置。
可以访问父类的成员，如父类的属性，方法，构造方法中。
注意访问权限的限制，如无法通过super访问private成员。
super.name;//访问直接父类的name属性
super.print()；//访问直接父类的print()方法
super(name）；//访问直接父类对应的构造方法，只能出现在构造方法中

继承条件下构造方法的调用。
如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用弗雷德无参构造方法。在这种情况下，有没有"super()";语句，效果都是一样的。
如果子类的构造方法中通过super显示调用父类的有参构造方法，则执行父类相应的构造方法，而不是执行父类无参构造方法。
如果子类的构造方法中通过this显示调用自身的其他构造方法，则在相应构造方法中应用以上两条规则。
注：如果存在多级继承关系，则在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类应用，一直到执行顶级类Object类的无参构造方法为止。

class Person{
String name；//姓名
public Person(){
//super()；//有没有该语句，效果都一样
System.out.println(“execute Person()”)；
}
public Person(String name){
this.name=name；
System.out.println(“execute Person(name)”)；
}
}

class Student extends Person{
String school；//学校
public Student(){
//super()；//
System.out.println(“Execute Person(name)”)；
}
}

public Student(String name，String school){
super(name)；
this.school=school；
System.out.println(“execute Student(name,school)”)；
｝
｝
class PostGradute extends student{
String guid；//导师
public PostGraduate(){
super()；
System.out.println(“execute PostGraduate()”)；
}
public PostGraduate(String name，String school，String guide){
super(name，school)；
this.guide=guide；
System.out.println(“execute PostGraduate(name，school，
guide)”)；
｝
｝

class TestInherit{
public static void main(String[] args){
PostGraduate pgdt=null；
pgdt=new PostGraduate()；
System.out.println()；
pgdt=new PostGraduate(“刘志同”，“北京大学”，“王老师”)；
}
}

运行结果:
execute Person()
execute Student()
execute PostGraduate()

execute Person(name)
execute Student(name,school)
execute PostGraduate(name,school,guide)
当执行"Pgdt=new PostGraduate();"语句时,调用构造方法PostGraduate()。在PostGraduate()构造方法中,首选调用其父类的构造方法Student(),而在调用Student()方法时,又会调用其(Student类)父类的构造方法Person(),在执行Person()方法时会调用它的直接父类Object的无参构造方法，该方法内容为空。最终输出的结果依次是Object(),Person(),Student()和PostGraduate()方法中的内容。
执行"pgdt=new PostGraduate(“刘志同”,“北京大学”,“王老师”);"语句时,调用规则与执行"pgdt=new PostGraduate();"语句时相同，只是此次调用的构造方法不同，依次是public PostGraduate（String name，String school，String guide），public Student（String name，String school），public Person（String name）和Object()构造方法。

/抽象类，狗狗和企鹅的父类/
public abstract class Pet｛
private String name=“无名氏”;
private int health=100;
private int love=0;
｝
public Pet(String name){
this.name=name；
}
/*/
public abstarct void print()；

抽象类和抽象方法的特点如下：
抽象类和抽象方法都通过abstract关键字来修饰
抽象类不能实例化抽象类中可以没有，有一个或多个抽象方法，甚至全部方法都可以是抽象方法。
抽象方法只有方法声明，没有方法实现。有抽象方法的类必须声明为抽象类。子类必须重写所有的抽象方法才能实例化，否则子类还是一个抽象类。
public void print（）｛｝不是抽象方法，而是有实现但实现为空的普通方法
public abstract void print（）;"是抽象方法
abstract可以用来修饰类和方法，但不能用来修饰属性和构造方法

抽象类中可以有构造方法吗？
抽象类可以有构造方法，其构造方法可以被本类的其他构造方法调用，若此构造方法不是由private修饰，也可以被本类的子类中的构造方法调用。

用final修饰的类不能被继承
用final修饰的方法不能被子类重写
用final修饰的变量（包括成员变量和局部变量）将变成常量，只能赋值一次。
使用final修饰引用变量时，变量值是固定不变的，而变量所指向的对象的属性值是可变得。

注意：final和abstract是功能相反的两个关键字，可以对比记忆。
abstract可以用来修饰类和方法，不能用来修饰属性和构造方法。
final可以用来修饰类，方法和属性，不能修饰构造方法。
java提供的很多类都是final类，如String类，Math类，它们不能再用子类。Object类中一些方法，如getClass，notity()，wait()都是final方法，只能被子类继承而不能被重写，但是hashCode（），toString（），equals（Object obj）不是final方法，可以被重写。