1. 继承的概述
继承就是子类继承父类的变量和方法，下面用代码解释一下：
class Student {// 定义学生类
String name;
int age;
void study() {
System.out.println(name + "studay good" + age);
}
}
class Work {// 定义工人类
String name;
int age;
void work() {
System.out.println(name + "work good" + age);
}
}
从上述例子中可以看到，学生类和工人类都有共同的特征，为了实现代码复用性，进行抽取，java中抽取用类表示将共有的的行为或特征进行抽取，然后原来的来类也要可以用，我们就需要用原来类继承我们抽取的类，用extends关键字进行调用，如：
class Student extends Person {// 定义学生类
void study() {
System.out.println(name + "studay good" + age);
}
}
class Work extends Person {// 定义工人类
void work() {
System.out.println(name + "work good" + age);
}
}
class Person {// 定义我们抽取的类
String name;
int age;
}
通常称Person（被继承的类）类为父类（也叫操类，基类），称Work和Student（继承类）称为子类。
2. 继承的优点
提高代码复用性
让类与类产生关系，给多态提供了前提
java支持单继承，不支持多继承，对C++多继承进行改良
单继承：一个子类只能有一个直接父类
class A {
}
class B {
}
class C extends A {
}
或者
class A {
}
class B {
}
class C extends B {
}
多继承：一个子类能有多个直接父类(为什么不能多继承)【不直接支持，会产生调用的不确定性】
class A {
void show() {
System.out.println(a);
}
}
class B {
void show() {
System.out.println(b);
}
}
class C extends A,B {
}
当我们new c();调用show方法，调用的是A的还是B的？为了区分java对此进行了改良，不用多继承，用接口
java支持多层（多重继承）=>传递性
class A {
}
class B extends A {
}
class C extends B {
}
3. 类的继承原则
单继承
继承具有传递性
继承不能循环
除Object类，所有类都有父类
4. 继承的使用
当要使用一个继承体系时，如何使用 ?
查看该体系中顶层类，了解该体系的基本功能。
创建该体系中最子类的对象，完成功能的使用。
什么时候写继承？
当类存在所属关系，就定义继承，A属于B,则A继承B
5. 继承中的成员变量
当本类局部和成员变量名相同时用this区分
当子父类中成员变量相同时用super区分
this和super的用法很相似
this：代表一个本类对象的引用
super：代表一个父类空间
class A {
int num = 5;
}
class B extends A {
int num = 10;
void show() {
System.out.println(this.num + "……" + super.num);//调用子类和父类的成员变量
}
}
注意：子类不能直接访问父类的私有成员
6. 继承中的成员方法
class A {
int num = 5;
void show1() {
System.out.println(num);
}
}
class B extends A {
int num = 10;
void show2() {
System.out.println(num);
}
}
public class Extendstext {
public static void main(String[] args) {
B b = new B();
b.show1();
b.show2();
}
}
当子父类中函数一样，将会运行子类的函数，称为覆盖操作
class A {
int num = 5;
void show() {
System.out.println(num);
}
}
class B extends A {
int num = 10;
void show() {
System.out.println(num);
}
}
public class Extendstext {
public static void main(String[] args) {
B b = new B();
b.show();
}
}
6.1 函数的两个特性
重载：同一个类
覆盖：子类中，覆盖也叫重写
6.2 注意事项
子类的方法覆盖父类方法时，子类的权限必须大于父类的权限
静态只能覆盖外汇返佣静态，或被静态覆盖
6.3 什么时候使用覆盖操作
当对一个类进行子类扩展时，子类需要保留父类的功能声明，但要定义子类中功能的特有内容时，就用覆盖操作完成。(修改方法，添加功能)如：
class Phone {// 定义一个手机类
void call() {// 通话功能
}
void show() {// 展示功能
System.out.println("number");
}
}
class newphone extends Phone {
void show() {// 展示功能重写
System.out.println("name");
System.out.println("jpg");
System.out.println("number");
}
}
或者
class newphone extends Phone {
void show() {// 展示功能重写
System.out.println("name");
System.out.println("jpg");
super.show();//调用父类show方法
}
}
7. 继承中的构造函数
在子类构造对象时，访问子类构造函数时，父类也运行，在子类的构造函数中，有一个默认的隐士语句，super();调用父类中空参数的构造函数，无覆盖，无继承
无参数
class fu {
fu() {
System.out.println("fu run");
}
}
class zi extends fu {
zi() {
super();//隐士自带的调用父类空参数构造函数
System.out.println("zi run");
}
}
有参数
class fu {
fu(int x) {
System.out.println("fu run");
}
}
class zi extends fu {
zi() {
super(4);//隐士自带的调用父类空参数构造函数
System.out.println("zi run");
}
}
子类的实例化过程，子类中的每个构造函数都会访问父类中空参数的构造函数
结果：AC AD
public class Extendstext {
public static void main(String[] args) {
new zi();
new zi(6);
}
}
class fu {
fu(){
System.out.println("A");
}
fu(int x) {
System.out.println("B");
}
}
class zi extends fu {
zi() {
System.out.println("C");
}
zi(int x){
System.out.println("D");
}
}
结果：BD
public class Extendstext {
public static void main(String[] args) {
new zi(6);
}
}
class fu {
fu(){
System.out.println("A");
}
fu(int x) {
System.out.println("B");
}
}
class zi extends fu {
zi() {
System.out.println("C");
}
zi(int x){
super(x);//覆盖隐式super();
System.out.println("D");
}
}
继承的优势 ：
提高代码的复用性，更简洁。
关于继承的内存结构 ：（代码如下）
//子类
package com.ss.cn;
/*
* 面向对象 --继承
* 要创建俩个老师的类 java php老师
* 老师有什么属性 :name age
* 老师的行为 ：teach sleep 休息
*
*/
public class JavaTeacher extends Teacher {
//利用封装的方式
/*private String name;
private int age;*/
//方法 ：
public void teach() {
/*
* 就是说的当前那么不是子类中的name，不是本类的东西那是绝对访问不了
* name现在在父类中，private String name 私有的受保护的，就是说其他类要是访问不了的，即使他有继承的关系
*
*/
System.out.println(getName()+"在教课");
}
//为什么要setget 方法
/*
* 利用封装时要想取得到值 也必须需要生成set/get方法
* 生成set/get方法快捷键 ： shift+alt+s
*/
}
//子类 ：
package com.ss.cn;
/*
* 面向对象 --继承
* 要创建俩个老师的类 java php老师
* 老师有什么属性 :name age
* 老师的行为 ：teach sleep 休息
* 创建老师的父类
* 继承的语法 ：关键字 extends
* class 子类 extends 父类{
* 子类的属性；
* 子类的方法；
* }
* 特点 ： 子类会把福父类的所有属性和方法继承下来（出来final）
*/
public class HtmlTeacher extends Teacher{
public void teach() {
System.out.println(getName()+"在教html课");
}
}
package com.ss.cn;
//父类
public class Teacher {
//公共类
private String name;
private int age;
public void sleep() {
System.out.println(name+"在睡觉");
}
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;
}
}
//测试类
package com.ss.cn;
public class ExtendsDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.对象中的属性就必须创建对象
JavaTeacher jTeacher=new JavaTeacher();
jTeacher.setName("Mrs");
jTeacher.setAge(25);
jTeacher.teach();
//同理 ：
HtmlTeacher hTeacher=new HtmlTeacher();
hTeacher.setName("ssy");
hTeacher.setAge(23);
hTeacher.sleep();
hTeacher.teach();
}
}
为什么自子类实例化的时候，会调用父类构造方法？
子类继承父类，所以子类有父类的属性，在使用父类内容前，要先看父类如何对自己的内容进行初始化，所以子类构造函数初始化的时候，必须调用父类构造函数，所以在子类的构造函数默认加了super();
如果父类中没有定义无参构造函数或者说是父类中定义了有参，没有定义无参，那么必须用super();来指定调用父类的构造函数
如果子类的构造函数中使用了this();调用本类的构造函数，那么super();就没有了，因为super和this只能定义在第一行，所以只能有一个，但是可以保证的是，子类中肯定会有其他构造方法来访问父类的构造函数。
注意：super();语句必须要定义在子类构造函数的第一行，因为父类的初始化要先完成