java面向对象(二)：继承，方法重写，final关键字，抽象类，接口-优快云博客

本文链接：https://blog.youkuaiyun.com/lituxiu/article/details/120510061

1、继承

在java中，所有的类都直接或间接继承Object类，Object类称为所有Java类的祖先。java中的继承是通过extends关键字操作的。通常说被继承的类叫作父类，派生的类叫做子类，通过继承后，子类可以使用父类的成员变量和成员方法。由此特点，通常在生产中把父类设计为拥有所有子类的共同属性和行为的类，即多个类中相同的内容给提取出来定义到一个类。比如人会吃饭和睡觉，那么学生和老师也会吃饭和睡觉，如下

class Person {
   public void sleep() {
       System.out.println("人会睡觉的！");
   }
   public void eat() {
       System.out.println("人会吃饭的！");
   }
}

//继承格式：class 子类名 extends 父类名 {}

class Student extends Person{} //Student类继承了Person类

class Teacher extends Person{} //Teacher类继承了Person类

class test {
   public static void main(String[] args) {
   Student s1 = new Student();
   s1.sleep(); //Student类对象s1调用父类的sleep()成员方法
   s1.eat();
   System.out.println("---------");
   Teacher t1 = new Teacher();
   t1.sleep();  //Teacher类对象t1调用父类的sleep()成员方法
   t1.eat();
   }
}

//执行结果如下：

人会睡觉的！
人会吃饭的！
---------
人会睡觉的！
人会吃饭的！

1.1、 Java中继承的特点：

A:Java只支持单继承，不支持多继承。

//class Son extends ~~Father,Mother~~ {} // java这样的多继承是错误的
但有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)

class GrandFather(){}

class Father extends GrandFather(){}

class Son extends Father(){}

java多层继承的案例

class GrandFather {
   public void show() {
       System.out.println("我是爷爷");
   }
}

class Father extends GrandFather {
   public void method(){
       System.out.println("我是老子");
   }
}

class Son extends Father {}

class ExtendsDemo2 {
   public static void main(String[] args) {
       Son s = new Son();
       s.method(); //使用父亲的
       s.show(); //使用爷爷的
   }
}

1.2、继承注意事项

       A:子类只能继承父类所有非私有的成员(即成员方法和成员变量)
       B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。（子类通过super访问父类的成员方法）
       C:不要为了部分功能而去继承。只要A和B两者关系是"A is B"或"B is A"才去继承。

继承的案例2：

   继承其实体现的是一种关系："is a"。
           Person
               Student
               Teacher
           水果
               苹果
               香蕉
               橘子

       采用假设法。
           如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
*/
class Father {
   private int num = 10;
   public int num2 = 20;

   //私有方法，子类不能继承
   private void method() {
       System.out.println(num);
       System.out.println(num2);
   }

   public void show() {
       System.out.println(num);
       System.out.println(num2);
   }
}

class Son extends Father {
   public void function() {
       //num可以在Father中访问private
       //System.out.println(num); //子类不能继承父类的私有成员变量
       System.out.println(num2);
   }
}

class ExtendsDemo3 {
   public static void main(String[] args) {
       // 创建对象
       Son s = new Son();
       //s.method(); //子类不能继承父类的私有成员方法
       s.show();
       s.function();
   }
}

1.3、继承中成员变量和成员方法的调用

继承中成员变量的调用规则

   继承中成员变量的关系:
           在子类方法中访问一个变量的查找顺序：
               a:在子类方法的局部范围找，有就使用
               b:在子类的成员范围找，有就使用
               c:在父类的成员范围找，有就使用
               d:如果还找不到，就报错。
*/
class Father {
   public int num = 10;

   public void method() {
       int num = 50;
   }
}

class Son extends Father {
   public int num2 = 20;
   public int num = 30;

   public void show() {
       int num = 40;
       System.out.println(num);
       System.out.println(num2);
       // 找不到符号,报错
//System.out.println(num3);
   }
}

class ExtendsDemo4 {
   public static void main(String[] args) {
       //创建对象
       Son s = new Son();
       s.show();
   }
}

继承中成员方法的调用规则：

/*
   继承中成员方法的关系:
           通过子类对象调用方法：
               a:先找子类中，看有没有这个方法，有就使用
               b:再看父类中，有没有这个方法，有就使用
               c:如果没有就报错。
*/
class Father {
   public void show() {
       System.out.println("show Father");
   }
}

class Son extends Father {
   public void method() {
       System.out.println("method Son");
   }

   public void show() {
       System.out.println("show Son");
   }
}

class ExtendsDemo8 {
   public static void main(String[] args) {
       //创建对象
       Son s = new Son();
       s.show();
       s.method();
       //s.fucntion(); //找不到符号
   }
}

由以上两个案例可知，在继承中，无论是成员变量还是成员方法，调用顺序都遵守“就近原则”：

成员变量：子类方法局部变量-->子类成员变量-->父类成员变量

成员方法：子类成员方法-->父类成员方法

1.4、继承中this和super关键字的作用

this和super的区别?

this代表本类对应的引用。
super代表父类存储空间的标识(可以理解为父类的引用,可以操作父类的成员)

怎么用呢?
           A:调用成员变量
               this.成员变量调用本类的成员变量
               super.成员变量调用父类的成员变量
           B:调用构造方法
               this(...)   调用本类的构造方法
               super(...)   调用父类的构造方法
           C:调用成员方法
               this.成员方法调用本类的成员方法
               super.成员方法调用父类的成员方法

继承中用this和super区分父类(成员变量)、子类(成员变量)和子类方法中(局部变量)同名num的值

class Father {
public int num = 10;
}

class Son extends Father {
   public int num = 20;

   public void show() {
       int num = 30;
       System.out.println(num); //局部变量优先级最高，num=30
       System.out.println(this.num); //本类成员变量num=20
       System.out.println(super.num); //父类成员变量num=30
   }
}

class ExtendsDemo5 {
public static void main(String