继承——java面向对象

extend

四个修饰关键字
简单记忆

具体描述

super

向上转型

向下转型

instanceof

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);// true
System.out.println(p instanceof Student);// false

Student s = new Student();
System.out.println(p instanceof Person);//true
System.out.println(p instanceof Student);//true

Student 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里面的语句就不会执行，也就不会报错了。