继承——java面向对象

extend

继承是一种代码复用的方式。
Java使用 extends 作为继承的关键字，extends 关键字在英文中的意思是扩展，而不是继承！ 这个关键字很好地体现了子类和父类的关系：子类是对父类的扩展，子类是一种特殊的父类。从这个意义上来看，使用继承来描述子类和父类的关系是错误的，用扩展更加恰当。
那么为什么国内把 extends 翻译为“继承”呢？ 除了与历史原因有关之外,把它翻译成继承也是有理由的：子类扩展了父类，将可以获得父类的全部成员变量和方法，这与韩语中的继承（子辈从父辈那里获得一笔财富称为继承）具有很好的类似性

public class Person {    private String name;    private int age;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public void run() {        System.out.println(name + " is running!");    }}

public class Student extends Person {    private int score;    public int getScore() {        return score;    }    public void setScore(int score) {        this.score = score;    }}

public class Main {    public static void main(String[] args) {        Person p = new Person();        Student s = new Student();        p.setName("xiao ming");        s.setName("xiao hong");        p.run();        s.run();    }}

xiao ming is running!
xiao hong is running!

用法如上

• Java只允许单继承，如果要多继承需要用到接口，以后我们会提到的。而且这个说法还有另外一个更有瑕疵的说法：Java只有一个父类，严格来说这种说法是错误的，可以换成下面的说法：Java类只能有一个直接父类，事实上java可以有无限多个间接父类。
• Object类是所有类的超类（可以这样理解：如果一个类的“爸爸”不是它，那么它一定是这个类的“祖宗”）

继承有关细节：

• 类名的设定，被继承的类称之为父类(基类)，继承的类称之为子类
• 子类并不能继承父类中所有的成员
  
  • 父类定义完整的成员 静态成员，非静态，构造方法。静态变量和静态方
    法都可以通过子类名.父类静态成员的形式调用成功。
  • 所有的私有成员不能继承,private修饰的成员。
  • 构造函数不能被继承

---

四个修饰关键字

简单记忆：

• 仅对本类——private
• 对所有类——public。
• 对本包和所有子类——protected。
• 对本包——默认，不需要修饰符。

具体描述：

• private(当前类访问权限)：如果类里的一个成员（包括成员变量、方法和构造器等）使用private访问控制符来修饰，则这个成员只能在当前类的内部被访问。很显然，这个访问控制符用于修饰成员变量最合适，使用它来修饰成员变量就可以把成员变量隐藏在在类的内部。
• default（包访问权限）：如果类里的一个成员（包括成员变量、方法和构造器等）或者一个外部类不使用任何访问控制符修饰，就称它是包访问权限的，default访问控制的成员或外部类可以被相同包下的其他类访问。
• protected（子类访问权限）：如果一个成员（包括成员变量、方法和构造器等）使用protected访问控制符修饰，那么这个成员即可以被同一个包中的其他类访问，也可以被不同包中的子类访问。在通常情况下，如果使用protected来修饰一个方法，通常是希望其子类来重写这个方法。
• public（公共访问权限）：这是一个最宽松的访问控制级别，如果一个成员（包括成员变量、方法和构造器）或者一个外部类使用public访问控制符修饰，那么这个成员或外部类就可以被所有类访问，不管访问类和被访问类是否处于同一个包中，是否具有父子继承关系。

private default protected public 同一个类中 √ √ √ √ 同一个包中 √ √ √ 子类中 √ √ 全局范围内 √

---

super

• super关键字表示父类（超类）
• 构造方法的第一行语句必须调用super（）
• 没有super（）时编译器会自动生成super（）
• 如果父类没有默认构造方法，子类就必须显示调用super（）

super关键字的作用

• 主要存在于子类方法中，用于指向子类对象中父类对象。
• 访问父类的属性
• 访问父类的函数
• 访问父类的构造函数

那么它和this关键字有什么不同呢：

this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。

在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数，编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行，只能调用一次。super() 和this()不能同时存在构造函数第一行。

向上转型

也就是父类引用指向子类对象
- 可以对实例变量进行向上转型（upcasting）
- 向上转型把一个子类型安全地变为更加抽象的类型（相对的向下转型是变得更加具体）

Person p = new Person();Studen s = new Student();Person ps = new Student();Object o1 = p;Object o2 = s;

向下转型

• 可以对实例变量进行向下转型（downcasting）
• 向下转型把抽象的类型编程一个具体的子类型
• 向下转型很可能报错：ClassCastException

Person p = new Person();Student s = (Student) p ; // ClassCastException

这里我们怎么保证向下转型的时候不报错呢 我们可以借助操作符——instanceof

instanceof

• instanceof操作符可以判断对象的类型

Person p = new Person();System.out.println(p instanceof Person);// trueSystem.out.println(p instanceof Student);// falseStudent s = new Student();System.out.println(p instanceof Person);//trueSystem.out.println(p instanceof Student);//trueStudent n = null;System.out.println(n instanceof Student);// false

• instanceof操作符可以判断对象的类型
• 向下转型前可以用instanceof判断

比如下面的例子 比较实用，希望以后可以记住

Person p = new Student();if (p instanceof Student){    Student s = (Student) p ; //OK}

这样一来 如果没有判断成功 那么if里面的语句就不会执行，也就不会报错了。