夯实Java基础（三）----面向对象之继承

JAVA面向对象三大特性，封装继承多态

一、继承的定义

1、JAVA继承定义：

子类继承父类的特征和行为，使得子类对象具有父类相同的特征和行为，继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。

子类，也叫派生类；被继承的称为父类、超类（superclass）或者基类。

2、JAVA继承目的：

如果多个子类中存在相同的特征与行为，那么就可以继承父类，父类中的特征和行为可以被子类继承下来使用，则不需要在子类中重复定义。

3、继承的特点：

①、Java是单继承，不可以多继承，但可以多层继承。

②、子类只能继承父类非private的属性，方法。（其实子类继承父类后，仍然认为获取了父类的private结构，因为封装的影响，使得子类不能直接调用父类的private结构而已，setter或getter）。

③、子类可以对父类进行扩展，也可以用自己的方式继承父类的方法（重写）。

④、提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

4、继承的优点

减少代码的冗余，提高代码的复用性。

便于功能的扩展。

为后面多态提供前提。

5、继承的缺点

子类与父类存在严重的耦合关系

继承破坏了父类的封装性

子类继承父类的属性和方法，也就说明可以从子类中恶意修改父类的属性和方法。

6、类的继承格式

通过extends关键字实现继承关系

[修饰符] class 父类 {
    属性、方法
}
[修饰符] class 子类 extends 父类 {
    属性、方法
}

7、何时使用继承

①、子类需要额外增加属性，而不仅仅是属性值的改变。

②、子类需要增加自己独有的行为方式。（包括增加新的方法或重写父类的方法）

二、构造器

1、构造器定义：

构造器也叫构造方法或构造函数，作用是用于创建并初始化对象。

注意：构造器只为实例变量初始化，不为静态类变量初始化

2、无参构造与有参构造

当我们在使用new关键字创建对象时，A a = new A(); 此时使用了无参构造器创建了一个对象，创建完成后它的成员变量也会被初始化，默认是相对数据类型的默认值。如果我们需要为成员变量赋值，则再挨个为它们再赋值，太麻烦了。使用有参构造就可以在new对象时，直接为当前对象的某个或所有成员变量直接赋值。

3、构造器语法格式

[修饰符] 构造器名(){
    // 实例初始化代码
}
[修饰符] 构造器名(参数列表){
    // 实例初始化代码
}

构造器创建规则：

①、构造器名必须与类名一致。

②、构造器无返回值，不需要返回值类型，不需要void。

③、系统给出默认无参构造器，并该构造器的修饰符默认与类修饰符相同。

④、如果写了构造器，无论是有参无参，系统都不再提供无参构造。

⑤、构造器可以重载，既可以定义参数，也可以不定义参数。

public class Father {
    private String name;
    private int age;
    // 无参构造
    public Father() {}
    // 有参构造
    public Father(String name,int age) {
        this.name = name;
        this.age = age;
    }
    //getter,setter方法省略...
}

三、方法重载与重写

1、定义：

方法重载（overload）：指在同一个类中，允许存在一个以上的同名方法，只要参数列表不同即可。

注意：参数列表不同，指的是参数个数不同，数据类型不同，数据类型顺序不同。

方法重写（overrid）：子类中继承父类的某个方法方法，但并不能满足实际需求，那么则需要方法重写，覆盖父类的方法。方法体不同，用于改造并覆盖。

2、重写规则：

①、保证父子类间方法的名称相同，参数列表也相同

②、父子类间的返回值类型相同，或者为父类返回值类型的子类类型。

③、子类方法的访问修饰符不能小于父类。（public>protected>default>private）

④、子类方法抛出的异常不能大于父类被重写的异常。

静态方法不能被重写，方法重写指的是实例方法重写，静态方法属于类方法不能被重写，而是隐藏

在子类中不可见的方法（私有方法等）不能被重写。

final方法不能被重写。

四、this和super关键字

1、this关键字

①、含义：

表示当前对象的引用。可用于调用本类的属性、方法、构造器。

②、使用位置：

this在实例初始化相关代码块和构造器中，表示正在创建的实例对象，即正在new谁this就代表谁。

tnis在非静态实例方法中，表示调用该方法的对象，即谁在调用this就代表谁。

this不能出现在静态代码块和静态方法中。

③、this使用格式：

this.成员变量名：当方法的局部变量与当前对象重名时，就可以在成员变量前加this.。

this.成员方法：调用当前对象的成员方法时，都可以加this，也可以省略，实际开发都省略。

this.调用都是先从本类声的成员变量或方法中查找，如果未找到，会去从父类继承的子类中查找。

③、this()或this(实参列表)

只能调用本类的其他构造器

必须在构造器的首行

如果一个类中声明了n个构造器，则最多有n-1个构造器使用了this(实参列表)，否则会发生递归调用死循环。

/**
 * 通过this调用构造器测试
 */
public class Demo {
    public static void main(String[] args) {
        Father father = new Father("张三", 30);
        father.show();
    }
}

class Father {
    public String name;
    public int age;

    //1、无参构造器
    public Father() {
        System.out.println("调用了Father无参构造器");
    }

    //2、name属性的有参构造器
    public Father(String name) {
        this();
        this.name = name;
        System.out.println("调用了Father的name属性有参构造器");
    }

    //3、全参构造器
    public Father(String name, int age) {
        this(name); //调用2
        this.name = name; 
        this.age = age;
        System.out.println("调用了Father的全参构造器");
    }

    // 定义show方法
    public void show() {
        System.out.println("name：" + this.name + ",age：" + this.age);
    }
}

2、super关键字

①、含义：

super是用于当前类中访问父类的一个特殊关键字，可用于调用父类的属性、方法、构造器，它不是对象的引用。

②、使用格式：

（1）super.成员变量：在子类中访问父类的成员变量，如果子类的成员变量与父类的成员变量重名时，必定是调用父类的成员变量。

（2）super.成员方法：在子类中调用父类的成员方法，如果子类重写了父类的成员方法，必定是调用父类的成员方法。

（3）super()或super(实参列表)：在子类的构造器首行，用于表示调用父类的哪个实例初始化方法super()默认调用父类构造器。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

public class Demo {
    public static void main(String[] args) {
        Son son = new Son();
        son.show();
    }
}
class Father {
    String name = "Father";
    int age = 40;

    public Father() {
        System.out.println("调用了父类的无参构造器");
    }
    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println("父类的Show方法");
    }
}
class Son extends Father {
    String name = "Son";
    int age = 20;

    public Son() {
        //调用父类构造器,可以省略,系统会默认添加
        super();
    }
    public void show() {
        System.out.println("子类的Show方法");
        System.out.println("本类属性：" + this.name + "," + this.age);
        //调用父类方法
        super.show();
        System.out.println("父类属性：" + super.name + "," + super.age);
    }
}

3、this、super小结

使用this、super调用构造器时，必须放在构造方法的第一行，所以不能同时出现，否则编译报错。

子类会默认使用super调用父类默认构造器，如果父类没有默认构造器，则子类必须显式的使用super()来调用父类构造器。

只能使用super关键字来调用父类的构造方法，不能使用父类构造方法名来调用，因为父类的构造方法不能被子类继承。

如果子类中没显式调用，则编译器自动调用super()，也就是说一直调到Object类，因为Object是所有类的父类。

super和this都不能出现在静态方法和静态代码块中，因为super和this都是存在于对象中的。

4、this、super联系

①、父类，子类及子类方法中存在同名变量时

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.a);//20
        System.out.println(son.b);//11
        son.test();
        son.method(30);
        son.fun(13);
    }
}

class Father {
    int a = 10;
    int b = 11;
}
class Son extends Father {
    int a = 20;

    public void test() {
        //子类与父类的属性同名，子类对象中就有两个a
        System.out.println("父类的a：" + super.a);//10    直接从父类局部变量找
        System.out.println("子类的a：" + this.a);//20   先从本类成员变量找
        System.out.println("子类的a：" + a);//20  先找局部变量找，没有再从本类成员变量找

        //子类与父类的属性不同名，是同一个b
        System.out.println("b = " + b);//11  先找局部变量找，没有再从本类成员变量找，没有再从父类找
        System.out.println("b = " + this.b);//11   先从本类成员变量找，没有再从父类找
        System.out.println("b = " + super.b);//11  直接从父类局部变量找
    }
    public void method(int a) {
        //子类与父类的属性同名，子类对象中就有两个成员变量a，此时方法中还有一个局部变量a
        System.out.println("父类的a：" + super.a);//10  直接从父类局部变量找
        System.out.println("子类的a：" + this.a);//20  先从本类成员变量找
        System.out.println("局部变量的a：" + a);//30  先找局部变量
    }
    public void fun(int b) {
        System.out.println("b = " + b);//13  先找局部变量
        System.out.println("b = " + this.b);//11  先从本类成员变量找
        System.out.println("b = " + super.b);//11  直接从父类局部变量找
    }
}

②、父子类中找方法

public class Test {
    public static void main(String[] args) {
        Son s = new Son();
        System.out.println(s.getNum());//10   没重写，先找本类，没有，找父类

        Daughter d = new Daughter();
        System.out.println(d.getNum());//20  重写了，先找本类
    }
}
class Father {
    protected int num = 10;

    public int getNum() {
        return num;
    }
}
class Son extends Father {
    private int num = 20;
}

class Daughter extends Father {
    private int num = 20;

    public int getNum() {
        return num;
    }
}

③、父子类中找方法

public class Test {
    public static void main(String[] args) {
        Son s = new Son();
        s.test();

        Daughter d = new Daughter();
        d.test();
    }
}
class Father {
    protected int num = 10;

    public int getNum() {
        return num;
    }
}
class Son extends Father {
    private int num = 20;

    public void test() {
        System.out.println(getNum());//10  本类没有找父类
        System.out.println(this.getNum());//10  本类没有找父类
        System.out.println(super.getNum());//10  本类没有找父类
    }
}
class Daughter extends Father {
    private int num = 20;

    public int getNum() {
        return num;
    }
    public void test() {
        System.out.println(getNum());//20  本类有，先找本类
        System.out.println(this.getNum());//20  本类有，先找本类
        System.out.println(super.getNum());//10  重写了，直接找父类
    }
}