目录
1. 为什么需要继承
Java 中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联。因此需要一些程序设计来解决这个问题。
下面通过代码来发现问题
//定义一个狗类
class Dog{
public String name;
public int age;
public String color;
public void eat() {
System.out.println(this.name + "在吃东西");
}
public void run() {
System.out.println(this.name + "在跑");
}
}
//定义一个鸟类
class Bird{
public String name;
public int age;
public String color;
public void eat() {
System.out.println( this.name + "在吃东西");
}
public void fly() {
System.out.println( this.name + "在飞");
}
}
public class blog {
public static void main(String[] args) {
Dog dog = new Dog(); //创建对象
//初始化
dog.name = "小灰";
dog.age = 10;
dog.color = "灰色";
//调用方法
dog.eat();
dog.run();
Bird bird = new Bird();
bird.name = "小花";
bird.age = 10;
bird.color = "花色";
bird.eat();
bird.fly();
}
}我们可以看到Dog类和Bird类中有以下相同的成员变量和成员方法
public String name;
public int age;
public String color;
public void eat() {
System.out.println(this.name + "在吃东西");
}因此 我们为了节省代码，提高代码的复用性，我们引入了继承这个概念。
2. 继承的概念
继承 (inheritance) 机制 ：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性
的基础上进行 扩展，增加新功能 ，这样产生新的类，称 派生类 。继承呈现了面向对象程序设计的层次结构， 体现了
由简单到复杂的认知过程。继承主要解决的问题是： 共性的抽取，实现代码复用 。
3. 继承的语法
修饰符 class 子类 extends 父类 {// ...}
关键字是 extends
因为 小狗和小鸟 都是属于动物，他们有自己的年龄、颜色等等属性。也会吃东西等等相同动作，并且作为宠物都会给他们给予名字 。
因此 我们创建一个新的类(Animals) 作为父类，并将 这些相同的属性和动作作为成员变量和成员方法 放入其中。
以下代码为使用继承之后。我们可以明显的看到 代码少了很多。
并且在现实生活中我们只需要关注子类特有的属性和方法即可
class Animals{
public String name;
public int age;
public String color;
public void eat() {
System.out.println(this.name + "在吃东西");
}
}
class Dog extends Animals{
public void run() {
System.out.println(this.name + "在跑");
}
}
class Bird extends Animals{
public void fly() {
System.out.println( this.name + "在飞");
}
}
public class blog {
public static void main(String[] args) {
Dog dog = new Dog();
dog.name = "小灰";
dog.age = 10;
dog.color = "灰色";
dog.eat();
dog.run();
Bird bird = new Bird();
bird.name = "小花";
bird.age = 10;
bird.color = "花色";
bird.eat();
bird.fly();
}
}4. 父类成员访问
4.1 子类中访问父类的成员变量
1.子类和父类不存在同名成员变量
class Father {
public int a = 10;
public int b = 20;
}
class Son extends Father {
public int c = 30;
public void Method(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.Method();
}
}程序正常运行，并且子类可以访问父类的成员变量，并打印值。
2. 子类和父类成员变量同名
使用关键字 super
我们先来看 如果 子类和父类成员变量同名 会输出什么?
class Father {
public int a = 10;
public int b = 20;
}
class Son extends Father {
public int a = 100; // 如果子类有 先访问子类的。 子类没有的 才会去看父类是否有
public int c = 30;
public void Method(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.Method();
}
}
由此我们可知，会输出子类的 同名成员变量。
那么如果我们非要访问 父类变量呢？
就是前面所提的 super
class Father {
public int a = 10;
public int b = 20;
}
class Son extends Father {
public int a = 100;
public int c = 30;
public void Method(){
System.out.println(super.a);// 输出父类的 a
System.out.println(this.a);// 谁调用 就输出谁的a
System.out.println(b);
System.out.println(c);
}
}
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.Method();
}
}
在子类方法中 或者 通过子类对象访问成员时 ：1.如果访问的成员变量子类中有，优先访问自己的成员变量。2.如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。3.如果访问的成员变量与父类中成员变量同名，则优先访问自己的。成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找 。
4.2 子类中访问父类的成员方法
1. 成员方法名字不同
class Father{
public void Func() {
System.out.println("Func");
}
}
class Son extends Father{
public void Func2() {
System.out.println("Func2");
}
public void Func3() {
Func();
Func2();
}
}
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.Func3();
}
}
2. 成员方法名字相同
我们在Son类中添加一个 和 Father类一模一样的Func成员方法，看结果如何？
class Father{
public void Func() {
System.out.println("Func");
}
}
class Son extends Father{
public void Func() {
System.out.println("Son::Func");
}
public void Func2() {
System.out.println("Func2");
}
public void Func3() {
Func();
Func2();
}
}
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.Func3();
}
}
结果是 子类有同名方法，先调用自己的方法。
如果想要在子类调用 父类中的同名成员方法，还是需要用到关键字super
//在此就不过多 赘写代码了
//基于上面的代码
//这里我将最核心的代码修改部分，单提了出来
public void Func3() {
this.Func();
super.Func();
this.Func2();
}
5. super关键字
作用：在子类方法中访问父类的成员。
如何使用，前面代码已经展示了其作用。
注意事项：1. 只能在非静态方法中使用2. 在子类方法中，访问父类的成员变量和方法。
6. 子类构造方法
父子，即先有父，后有子。所以在我们的代码中，当我们想创建子类对象时，要先调用和实现父类的构造方法，然后再实现子类构造方法
在之前的代码中，虽然父类和子类都没有显式的定义构造方法。但其实 子类中 有隐藏的代码
public class Father {
public Father(){
System.out.println("Father()");
}
}
public class Son extends Father{
public Son(){
// super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
// 并且只能出现一次
System.out.println("Son()");
}
}下面代码是父类已经有定义好的构造方法
class Animals{
public String name;
public int age;
public String color;
//父类的构造方法
public Animals(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
public void eat() {
System.out.println(this.name + "在吃东西");
}
}
class Dog extends Animals {
//子类的构造方法
public Dog() {
super("小罗",10,"白色");
}
public void run() {
System.out.println(this.name + "在跑");
}
}
class Bird extends Animals {
//子类的构造方法
public Bird(String name, int age, String color) {
super(name, age, color);
}
public void fly() {
System.out.println( this.name + "在飞");
}
}
public class Blog {
public static void main(String[] args) {
Dog dog = new Dog();// 根据构造方法
//第一种初始化方式
dog.name = "小灰";
dog.age = 10;
dog.color = "灰色";
dog.eat();
dog.run();
Bird bird = new Bird("小辣椒",10,"红色");// 根据构造方法 //第二种初始化方法
bird.eat();
bird.fly();
}
}
注意：
1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现
7. super和this
super 和 this 都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？
相同点
1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
不同点
1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造 方法中出现
4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有
8. 继承关系的执行顺序
在之前的学习中我们知道了
1.静态代码块先执行，并且只执行一次，在类加载阶段执行
2.当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行
class Persons{
String name;
int age;
public Persons(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person构造方法被调用");
}
{
System.out.println("Person实例代码块被调用");
}
static {
System.out.println("Person静态代码块被调用");
}
}
class Students extends Persons{
public Students(String name, int age) {
super(name, age);
System.out.println("Students构造方法被调用");
}
{
System.out.println("Students实例代码块被调用");
}
static {
System.out.println("Students静态代码块被调用");
}
}
public class job {
public static void main(String[] args) {
Students students = new Students("小罗",18);
Students students2 = new Students("小米",18);
}
}
无奖竞猜：大家猜一下输出结果是什么？
通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
9. 继承方式
单继承
多层继承
不同类继承同一个类 
最重要的是，不可以同一个类继承不同的类
10. final关键字
final关键可以用来修饰变量、成员方法以及类。
1.修饰变量或字段，表示常量(即不能修改)
2.修饰类：表示此类不能被继承
3.修饰方法：表示该方法不能被重写