面向对象中的继承性

01、什么是继承

1、面向对象的三大特征：封装性，继承性，多态性

2、此前我们已经学习了封装性，方法是一种最常用的封装。在Java的类中，将属性私有化，提供公共的get和set方法也是一种常用的封装

3、那么什么是继承呢？

继承就是子类继承父类，就像现实生活中的“继承家产”一样

Java中的继承，能够让子类拥有父类的公共方法和属性

02、继承的使用场景是什么

1、提取不同的类公共的属性和方法，让其他类继承此类，节省代码

2、比如

讲师类

String name

int age

助教类

String name

int age

班主任类

String name

int age

员工类

String name

int age

但是讲师，助教，班主任都属于员工，所以，可以使讲师类，助教类，班主任类继承于员工类

3、定义一个类，定义类一些类的共性内容，将属于这个类的其他类的共性抽取出来，形成一个父类

4、其他属于此类的类，都继承这个父类，那么直接就拥有了这个父类的共性内容，那么子类就没有必要去反复的写这些共性内容了，这样节省了代码

03、被继承的类称作什么

1、父类

2、超类

3、基类

04、继承了其他类的类叫做什么

1、子类

2、派生类

05、子类继承了父类的所有成员吗

1、不是，子类只能继承父类公共的成员

2、对于私有的成员属性和成员方法等，子类是无法继承的

06、构造方法能够被继承吗

1、不能，构造方法不能被继承

2、构造方法是根据类名定，子类和父类的类名先让不可能一致

07、继承的使用场景是什么

1、如果我们定义了好几个类，类中都有着相同的成员属性或成员方法，这个时候，我们可以把这些类的共性内容抽取出来，形成一个父类，用以被继承，节约代码量

2、实际开发中，使用继承的场景是很少的

08、案例：继承的基本用法

1、员工类

public class Employee {

private String name;

private int age;

public Employee() {

}

public Employee(String name, int age) {

this.name = name;

this.age = 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;

}

@Override

public String toString() {

return "Employee{" +

"name='" + name + '\'' +

", age=" + age +

'}';

2、讲师类

3、助教类

4、测试类

public class Demo01 {

public static void main(String[] args) {

//1、创建老师

Teacher teacher = new Teacher();

teacher.setName("孔夫子");

teacher.setAge(33);

teacher.job();

System.out.println(teacher);

//2、创建助教

Assistant assistant = new Assistant();

assistant.setName("张三");

assistant.setAge(33);

assistant.job();

System.out.println(assistant);

}

}

5、测试结果

09、继承中成员变量的访问特点

1、当子类和父类中的变量名字不重名的情况下，直接访问该成员变量即可

2、当子类和父类中的变量名字重名时，看等号左边是谁，优先调用的就是谁的变量。如果是匿名对象，则使用的是子类的变量。

3、如果子类没有该变量，父类有该变量，则使用的是父类的变量

10、继承中成员方法的访问特点

1、如果访问了同名的方法，调用的是子类的方法

2、如果访问了不同名的方法，子类有就用子类的，子类没有就用父类的

3、如果左边是父类，无法访问子类的方法

public class Demo {

public static void main(String[] args) {

F f = new Z();//左边是父类

Z z = new Z();//左边是子类

//1.如果访问了同名的方法，调用的是子类的方法

f.f();

z.f();

System.out.println("-------------------");

//2.如果访问了不同名的方法，子类有就用子类的，子类没有就用父类的

z.f2();

z.f1();

System.out.println("-----------------");

//3.如果左边是父类，无法访问子类的方法

// f.f2();//不行

}

}

class F {

public void f() {

System.out.println("父类中的f方法");

}

public void f1() {

System.out.println("父类中的f1方法");

}

}

class Z extends F {

public void f() {

System.out.println("子类中的f方法");

}

public void f2() {

System.out.println("子类中的f2方法");

11、继承中三种变量的访问特点

1、哪三种变量

父类的成员变量

子类的成员变量

子类的局部变量

2、如果三种变量都重名了，如何访问

1、优先访问的是局部变量

2、使用this访问子类的成员变量

3、使用super访问父类的成员变量

3、实例

12、所有类都继承Object类？

1、是。Object类是所有类的默认父类

2、所有类都拥有Object类的一些公共的方法

13、什么是方法的重写

1、如果父类中的方法和子类中的方法是一样的，那么就是方法的重写

2、重写是子类自己的方法覆盖父类的方法

3、重写可以使用@Override注解，用以检测是否满足重写规范

4、举例

public class Demo {

public static void main(String[] args) {

Child child = new Child();

child.show();

Father father = new Child();

father.show();

}

}

class Father {

void show() {

System.out.println("父类");

}

}

class Child extends Father {

//这里就是重写

@Override

//重写可以使用@Override注解

void show() {

System.out.println("子类");

}

14、方法重写的注意事项

1、前提：必须有继承关系，才能够重写

2、子类方法覆盖父类方法，必须要保证权限大于等于分类权限

3、返回值类型，函数名，参数列表都要相同，才能重写

4、私有方法不能被继承，也不能被重写

5、子类方法的返回值，可以是父类方法返回值的子类

15、有哪些权限修饰符

1、public：权限最大，公开的，外部可以访问

2、protected：保护

3、default：默认，什么都不写就是默认权限

4、private：私有，权限最小，外部不能访问

16、方法重写的使用场景

1、我们写标准类的时候，通常都会重写一个toString方法

2、随着项目的发展，如果要给之前的方法做增强，也可以使用重写

17、案例：手机功能增强

1、需求：新手机对老手机的功能做增强

2、代码

public class Demo {

public static void main(String[] args) {

NewPhone newPhone = new NewPhone();

newPhone.send();

}

}

class OldPhone {

void call() {

System.out.println("打电话");

}

void send() {

System.out.println("发短信");

}

}

class NewPhone extends OldPhone {

@Override

void send() {

super.send();//原本的功能不变

System.out.println("发彩信");//添加新的功能

}

18、继承中的构造方法

1、特点：调用子类构造方法之前，会先调用父类的构造方法

原因

构造方法中，第一行默认会有一个super()

super()代表的是父类的空参构造

即使没有手写上，默认也有，手写上也可以

2、特点：如果需要使用父类的有参构造，可以使用super方法

public class Demo {

public static void main(String[] args) {

Child child = new Child("aaa", 33, "男");

System.out.println(child);

}

}

class Father {

String name;

int age;

public Father() {

System.out.println("父类的空参构造");

}

public Father(String name, int age) {

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "Father{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

}

class Child extends Father {

String gender;

public Child() {

System.out.println("子类的空参构造");

}

//可以调用父类的有参构造

public Child(String name, int age, String gender) {

super(name, age);

this.gender = gender;

}

@Override

public String toString() {

return "Child{" +

"name='" + name + '\'' +

", age=" + age +

", gender='" + gender + '\'' +

'}';

19、super的使用场景

1、可以用掉调用父类的成员变量

2、可以用来调用父类的成员方法

3、可以用来调用的构造方法

实例

public class Demo {

public static void main(String[] args) {

Child child = new Child();

}

}

class Father {

int num = 333;

void method() {

System.out.println("ffff");

}

public Father() {

System.out.println("父类的无参构造方法");

}

}

class Child extends Father {

public Child() {

super();//调用父类的构造方法

System.out.println(super.num);//调用父类的成员变量

super.method();//调用父类的成员方法

20、this的使用

1、this代表的是当前对象

2、用来区分成员变量和局部变量，解决重名问题

3、可以访问本类的成员变量

4、可以访问本类的成员方法

5、还可以调用本类的构造方法,但是，必须写在第一行，且this和super不能同时出现

实例

public class Demo {

public static void main(String[] args) {

new Person();

}

}

class Person {

String name = "zhangsan";

int age = 333;

public Person() {

//3、访问构造方法

this("王舞", 55);

System.out.println(this);//上面已经初始化了

System.out.println("Person无参构造");

//1、访问成员变量

System.out.println(this.name);

//2、访问成员方法

this.show("李四");

}

public Person(String name, int age) {

this.name = name;

this.age = age;

}

void show(String name) {

System.out.println("show " + name);

}

void test() {

}

@Override

public String toString() {

return "Person{" +

"name='" + name + '\'' +

", age=" + age +

'}';

21、this和super总结

1、super用来表示父类

2、this用来表示当前类的一个具体对象

22、继承的特点

1、Java中只支持单继承，不支持多继承（Python支持多继承）

2、一个父类可以有多个子类

3、继承有传递性，比如A继承B，B继承C，那么A间接也继承了C