java 007 面向对象 ——继承，重写

Java中的继承

/* 继承使用的关键字 */
extends

/* 基本格式 */
class A extends B {
    
}
/*
A类是B类的一个子类
B类是A类的唯一父类！！！

Java是一个单继承面向对象语言
*/

总结：
    1. 继承情况子类可以使用父类的非私有化成员
        成员 ==> 成员变量 + 成员方法
    2. 继承情况下子类不能使用父类的私有化成员
    3. 创建子类对象，会默认调用父类的无参数构造方法
        为什么会调用?
        没有你父母不可能有你
        没有父类就不可能有子类

 

 

 

继承带来的问题

父类的非私有成员方法可以继承给子类使用，但是子类使用的过程中发现父类的方法并不适合子类的实际情况。

【重写】
    重写要求子类中重写的方法，必须和父类的方法声明一致！！！

@Override：
    注解！！！
    这里是用于开启重写的严格检查！！！要求子类中重写父类的方法，方法声明必须完全一致。

继承又带来的问题

继承情况下，父类中的成员方法不符合子类的需求，子类可以利用重写来完成对于方法体的更改，从而满足子类的实际情况。但是该重写是非强制的！！！

实际开发中我们可以利用父类的方式来优化代码，但是同时也要考虑每一个类的独立性。
这里需要强制重写的需求！！！【语法要求】

abstract关键字

[特征]
    abstract修饰的方法是要求子类强制重写的！！

package com.qfedu.b_extends;


abstract class LOLHero {
    abstract public void q();

    abstract public void w();

    abstract public void e();

    abstract public void r();
}

class Yasou extends LOLHero {

    @Override
    public void q() {
        System.out.println("斩钢闪");
    }

    @Override
    public void w() {
        System.out.println("风之障壁");
    }

    @Override
    public void e() {
        System.out.println("踏前斩");
    }

    @Override
    public void r() {
        System.out.println("狂风XXXX");
    }
}

class VN extends LOLHero {

    @Override
    public void q() {
        System.out.println("暗影突袭");
    }

    @Override
    public void w() {
        System.out.println("圣银弩箭");
    }

    @Override
    public void e() {
        System.out.println("离我远一点");
    }

    @Override
    public void r() {
        System.out.println("你看我不到");
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Yasou yasou = new Yasou();
        VN vn = new VN();

        yasou.q();
        yasou.w();
        yasou.e();
        yasou.r();
        System.out.println();
        vn.q();
        vn.w();
        vn.e();
        vn.r();
    }
}

abstract关键字使用总结:

    1. abstract关键字修饰的方法没有方法体
    2. abstract关键字修饰的方法必须定义在abstract修饰的类内或者interface接口内
    3. abstract关键字修饰的类，如果是普通类继承，要求子类必须实现在abstract类内的所有abstract修饰方法
    4. abstract修饰的类没有自己的类对象。

final关键字

字面含义
    最终
可以修饰四类内容
    1. 成员变量
        使用final修饰的成员变量定义时必须初始化
    2. 成员方法
        final修饰的方法为最终方法，不能被子类重写
    3. 局部变量
        final修饰局部变量，赋值 之后不能修改
    4. 类
        final修饰的类不能被继承，没有子类 Java中的String类就是final修饰

package com.qfedu.d_final;

// final修饰的类不能被继承，没有子类 Java中的String类就是final修饰
final class Animal {
    // 使用final修饰的成员变量定义时必须初始化
    final String NAME_OF_ANIMAL = "动物";

    public Animal() {}

    // final修饰的方法为最终方法，不能被子类重写
    final public void eat() {
        System.out.println("吃东西！！！");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        System.out.println(animal.NAME_OF_ANIMAL);
        // final修饰的成员变量赋值之后无法修改内容
        //animal.name = "daaaa";

//        Dog dog = new Dog();
//        dog.eat();

        int num = 10;
        num = 20;

        // final修饰局部变量，赋值之后不能修改
        final int num1;
        num1 = 10;
        // num1 = 20;
    }
}

public class Demo2 {
    public static void main(String[] args) {
        final Person person = new Person();
        /*
        请问:
            1.成员变量的值是否可以修改???
                可以
            2.person对象是否可以保存其他Person类对象地址???
                不可以
            3.成员变量赋值之后是否可以修改???
                可以
        总结:
            final修饰引用数据类型的变量，引用数据类型变量中保存的地址
            不可以修改，但是指向的空间内容是可以修改的。*/
        person.name = "小明";
        person.age = 16;

        System.out.println(person.name);
        System.out.println(person.age);

        person.name = "老王";
        person.age = 3;

        System.out.println(person.name);
        System.out.println(person.age);
    }
}