1.继承
继承是一种代码复用的方式.
Student与Person有相同部分的代码。
Student可以从Person继承，这样Student获得了Person的所有功能，只需要编写新增的功能即可。通过继承，可以实现代码的复用。
继承使用关键字extends，一个类只能有一个父类。
如果没有写明继承类，编译器会自动指定该类继承于基类Object。
Person：超类super，父类，基类
Student：子类subclass，扩展类
Person.java
```#java
//默认继承Object
public class Person /*extends Object */{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(){
this.age = age;
}
public int getAge(){
return this.age;
}
public void run(){
System.out.println(name+" is running!");
};
}
```
Student.java
```#java
public class Student extends Person{
private int score;
public void setScore(int score){
this.score = score;
}
public int getScore(){
return this.score;
}
}
```
Hello.java
```#java
public class Hello {
public static void main(String[] args){
Person ming = new Person();
Student hong = new Student();
ming.setName("小明");
hong.setName("小红");
ming.run();
hong.run();
}
}
```
2.protected
上例中Person类定义的private字段无法被子类访问，用protected修饰的字段可以被子类访问。
protected把字段和方法的访问权限控制在继承树内部
Person.java
public class Person /*extends Object */{
protected String name; //将name的修饰符更改为protected
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(){
this.age = age;
}
public int getAge(){
return this.age;
}
public void run(){
System.out.println(name+" is running!");
};
}
Student.java
public class Student extends Person{
private int score;
public void setScore(int score){
this.score = score;
}
public int getScore(){
return this.score;
}
public String hello(){
return "Hello, " + this.name; //引用name
}
}
public class Hello {
public static void main(String[] args){
Person ming = new Person();
Student hong = new Student();
ming.setName("小明");
hong.setName("小红");
ming.run();
System.out.println(hong.hello());//引用hello方法
hong.run();
}
}
3.继承关系中的构造方法
编写Person类时，可以编写构造方法，或由编译器自动生成构造方法。由于子类包含有父类的所有功能，必须手动调用父类的构造方法。
Java语言规定，子类的构造方法第一行语句必须调用父类的构造方法。调用方式是super();
如果我们没有写super()，编译器会自动生成super()。如果父类没有默认的构造方法，此时编译器自动生成的构造方法会报错，因为父类的构造方法必须传入参数。此时我们需要显式的写上super，传入参数。
Person.java
public class Person /*extends Object */{
protected String name;
private int age;
public Person(){ //默认的构建方法
this.name = "王重阳";
}
public Person(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public void run(){
System.out.println(name+" is running!");
};
}
Student.java
public class Student extends Person{
public Student(){
//根据父类默认的构建方法，自动生成super();
}
public Student(String name){
super(name);
}
private int score;
public void setScore(int score){
this.score = score;
}
public int getScore(){
return this.score;
}
}
Hello.java
public class Hello {
public static void main(String[] args){
Student p = new Student("林朝英");
Student s = new Student();
p.run();
s.run();
}
}
# 4.向上转型
定义一个类时，实际是定义一个数据类型；定义继承时，是在数据类型之间加上了继承的关系。
定义一个实例对象时，需要把它赋值给一个引用类型的变量，让这个变量指向实例对象。
向上转型把一个子类型安全地变为更加抽象的类型(父类型)。
反过来，即向下转型是把一个父类型(抽象)变成一个自类型(具体)。如把一个Person类型变量强制转型为Student类型变量。
可以对实例变量进行向上转型(upcasting)和向下转型(downcasting)
```#java
//假如我们持有一个Student对象实例，name我们可以保证Student包含Person类型的全部功能，因此把它看成一个Person类型对象是没有问题的。
Student s = new Student("jack");
Person ps = s;
Student s2 = (Student) ps;
s2.run();
```
/*Person实例p可能指向Person实例，也可能指向Student实例。向下转型为Student很有可能报错。如果变量p指向的实际类型并不是Student实例，JVM运行时会抛出ClassCastException的错误。*/
Person p = new Person("tom");
Student s2 = (Student) p;
s2.run();
## 4.1instanceof操作符
```#java
public class Hello {
public static void main(String[] args){
Person p = new Person("tom");
System.out.println(p instanceof Person);
System.out.println((p instanceof Student ) + "\n");
Student s = new Student("jack");
System.out.println(s instanceof Person);
System.out.println((s instanceof Student) + "\n");
Student n = null;
System.out.println(n instanceof Object);
System.out.println(n instanceof Person);
System.out.println(n instanceof Student);
}
}
<img src="https://img2018.cnblogs.com/blog/1418970/201901/1418970-20190114213553125-21523129.png" width="500" />
使用instanceof修改向下转型代码
```#java
Person p = new Person("tom");
Student s = new Student("jack");
Person ps = s;
if(p instanceof Student) { //只在类型正确时转型，避免异常
Student s2 = (Student) p;
s2.run();
}
# 5.继承和组合
组合和子类使用不会，需要翻书
Student可以持有一个Book实例
继承是is关系，组合是has关系
```#java
public class Student extends Person{
private Book book;
public Student(String name){
super(name);
}
private int score;
public void setScore(int score){
this.score = score;
}
public int getScore(){
return this.score;
}
...
}
```
6.总结：
继承是面向对象编程的一种代码复用方式。
Java只允许单继承
protected允许子类访问父类的字段和方法
子类的构造方法可以通过super()调用父类的构造方法
可以安全地向上转型为更为抽象的类型
可以强制向下转型，最好借助instanceof判断
子类和父类的关系是is，has关系不能用继承