java基础-day10-面向对象4.0

面向对象4.0

1. 面向对象之继承

1.1 生活中的继承

王多鱼
    二爷的遗产
    
你长的像你爹
    遗传，继承！！！
    
开发中使用继承最多的地方:
    游戏开发！！！
    LOL
        血量，蓝量，攻击力，法术强度，攻击速度，护甲，魔抗，CD，移动速度，物理穿
        甲，法术穿甲，物理吸血，法术吸血....
        这里会考虑将所有的通用属性，封装成一个类，通过【继承】让每一个英雄类都可
        以使用到这些属性。这个类叫做【基类】.

1.2 Java中的继承

关键字
    extends 继承使用关键字
格式:
    class A extends B {
    
    }
    
    A类是B类的一个子类
    B类是A类的唯一父类
    Java语言是一门单继承语言。

继承效果
    1. 子类可以通过继承使用父类的非私有化成员变量和成员方法
    2. 子类无法通过继承使用父类的私有化成员变量和成员方法

1.3 子类对象创建，会调用父类的构造方法解释

1. 构造方法是用来做什么的???
    创建对象 new + 构造方法(); 
        new 申请内存【堆区】空间，并且擦除所有数据
        构造方法用于初始化当前类对象成员变量或者一些必要数据。
        构造方法没有创建对象的能力，只做【初始化操作】

2. 子类对象可以通过继承使用父类的非私有化成员变量和成员方法
    子类对象所占用的内存【堆区】空间中，是有对应父类成员变量和成员方法的内存空间。
    开发中:
        所有的数据，方法，数据类型都要占用一定的内存空间，程序运行是离不开内存
        的。

image.png

1.4 super关键字

1. super区分子类和父类同名内容。
2. 通过super关键字调用父类的构造方法[后面讲 Exception]

package com.qfedu.a_extends;

class Person {
    public String name;
    public int age = 10;
    
    public void work() {
        System.out.println("Person类work方法");
    }
}

/**
 * super关键字区分父类和子类同名内容
 * @author Anonymous
 *
 */
class SinglePerson extends Person {
    public int age = 20;
    
    public void work() {
        System.out.println("SinglePerson类work方法");
    }
    
    /*
     * super关键字可以解决父类和子类同名内容情况。
     */
    public void test() {
        // 子类和父类有同名内容情况下，默认为就近原则
        System.out.println(age);
        
        // 通过super明确告知编译器，这里使用的age是父类成员变量age
        System.out.println(super.age);
        
        // 调用方法也是采用就近原则
        work();
        
        // 通过super明确告知编译器这里调用的是父类的work方法。
        super.work();
    }
}

public class Demo3 {
    public static void main(String[] args) {
        
    }
}

1.5 继承带来的问题

Java中继承主要目的
    1. 制定规范
    2. 继承可以进行方法传递，子类可以使用父类的方法，简化开发流程

子类通过继承可以使用父类中的成员方法，但是父类成员方法     
无法满足子类的特殊情况。                    
                                
为了降低程序员的开发压力，面向对象语言中，引入了一个【重写】概念

1.6 重写 Override

重写:
    用于在不增加方法量的情况下，解决父类方法无法满足子类使用情况。

重写方法要求
    1. 子类和父类方法声明完全一致。
        权限修饰符 返回值类型 方法名(形式参数列表)
    2. 子类重写父类方法，可以修改方法体内容，来满足子类情况
    3. 通常情况下，会使用注解 @Override来开启严格格式检查。

package com.qfedu.b_override;

/**
 * LOLHero基类
 * @author Anonymous
 *
 */
class LOLHero {
    public void Q() {
        System.out.println("Q方法");
    }
    
    public void W() {
        System.out.println("W方法");
    }
    
    public void E() {
        System.out.println("E方法");
    }
    
    public void R() {
        System.out.println("R方法");
    }
}

/**
 * 锤石类
 * @author Anonymous
 *
 */
class Thresh extends LOLHero {
    /*
     * 重写之后，父类和子类方法声明完全一致，并没有增加方法的记忆压力
     * 只不过修改了子类方法体内容，从而更加合适子类的使用情况！！！
     */
    @Override
    public void Q() {
        // TODO todo是未完成代码标记，需要在todo注释之后完成代码
        System.out.println("死亡判决");
    }
    
    @Override
    public void W() {
        System.out.println("魂引之灯");
    }
    
    @Override
    public void E() {
        System.out.println("厄运钟摆");
    }
    
    @Override
    public void R() {
        System.out.println("幽冥监牢");
    }
}

/**
 * 维鲁斯类
 * @author Anonymous
 *
 */
class Varus 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 Demo1 {
    public static void main(String[] args) {
        /*
         * 子类通过继承可以使用父类中的成员方法，但是父类成员方法
         * 无法满足子类的特殊情况。
         * 
         * 为了降低程序员的开发压力，面向对象语言中，引入了一个【重写】概念
         */
        Thresh goulei = new Thresh();
        
        goulei.E();
        goulei.R();
        goulei.W();
        goulei.Q();
        
        System.out.println();
        
        Varus saolei = new Varus();
        
        saolei.E();
        saolei.W();
        saolei.R();
        saolei.Q();
    }
}

1.7 重写注意事项

1. 重写是建立在继承或者遵从[implements]关系之上的。通常是由子类或者实现类完成的。

2. @Override 
    注解 ==> 注释 + 解释
    开启重写严格格式检查。【编译时作用】

3. 重写可以简化代码结构，在不增加方法的情况下，满足子类的特殊使用情况。 

1.9 重写的问题

    LOLHero类内有QWER方法，这里其实是要求子类按照自己的需求来完成重写的，但是代码没有从【语法】角度进行强行约束。
    目前缺少让子类重写方法的【强制要求】
    这里需要使用abstract关键字

2. abstract关键字

2.1 abstract关键字语法要求

abstract修饰的方法
    要求子类必须强制完成/强制重写！！！

package com.qfedu.c;

/*
abstract关键字使用 Eclipse操作引导

第一个问题：
    Abstract methods do not specify a body
    abstract修饰的方法，不允许有方法体

快速修复:
    Ctrl + 1
    Remove method body;
    删除当前abstract修饰方法的方法体。

 第二个问题:
    The abstract method Q in type LOLHero can only be defined by an abstract class
        在LOLHero类内abstract修饰的方法q，有且只能定义在abstract修饰的类内
    The type LOLHero must be an abstract class to define abstract methods
        LOLHero类必须是一个abstract修饰的类，才可以定义abstract修饰的方法
 
 快速修复:
    Ctrl + 1 
    Make type 'LOLHero' abstract
    
 第三个问题:
    The type HappyWindBoy must implement the inherited abstract method LOLHero.Q()
        HappyWindBoy类因为继承LOLHero类，必须实现LOLHero类内的abstract修饰的方法 Q();
 快速修复:
     Ctrl + 1
     Add unimplemented method;
        添加未实现的方法
 */
/**
 * LOLHero基类
 * @author Anonymous
 *
 */
abstract class LOLHero {
    abstract public void Q();
    
    abstract public void W();
    
    abstract public void E();
    
    abstract public void R();
}

/**
 * 快乐风男
 * @author Anonymous
 *
 */
class HappyWindBoy 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("狂风绝息斩");
    }
    
}

/**
 * 提莫类
 * @author Anonymous
 *
 */
class Timor extends LOLHero {

    @Override
    public void Q() {
        System.out.println("你瞎吧");
    }

    @Override
    public void W() {
        System.out.println("溜~~~");
    }

    @Override
    public void E() {
        System.out.println("呵 tui~~~");
    }

    @Override
    public void R() {
        System.out.println("蹦沙卡拉卡");
    }

}

public class Demo1 {
    public static void main(String[] args) {
        HappyWindBoy happyWindBoy = new HappyWindBoy();
        
        happyWindBoy.Q();
        happyWindBoy.W();
        happyWindBoy.E();
        happyWindBoy.R();
        
        Timor timor = new Timor();
        timor.Q();
        timor.W();
        timor.E();
        timor.R();
    }
    
}

2.2 abstract使用总结

1. abstract关键字目前只要求了解语法规范。【实际使用和开发使用，后期项目中讲解】

2. abstract修饰的方法不能有方法体，有且只有方法的声明，这里只是在当前类内告知编译器，这里定义了一个方法的声明。

3. abstract修饰的方法，有且只能存在于abstract修饰的类内，或者interface接口内

4. 一个普通类如果继承abstract修饰的类需要完成abstract类内的所有abstract修饰方法，【语法强制要求】

5. abstract修饰的类请问有没有类对象???
    abstract修饰的类不能创建自己的类对象，因为abstrat修饰的类内可能存在abstract修饰的方法，而abstract修饰的方法没有方法体，无法通过类对象调用执行。

3. final关键字

3.1 基本语法

成员变量
    final修饰的成员变量，定义时必须初始化，并且无法被重新赋值。
成员方法
    final修饰的成员方法，不能被子类重写，为最终方法。
局部变量
    final修饰的局部变量一旦被赋值无法修改！！！
类
    final修饰的类不能被子类继承，没有子类
    断子绝孙
    代表之作:
        Java中的String字符串类就是一个final修饰的类

3.2 final面试题

package com.qfedu.d_final;

class Person {
    public String name = "彭于晏";
    public int age = 16;
}

public class Demo2 {
    public static void main(String[] args) {
        final Person person = new Person();
        
        System.out.println(person.name + " " + person.age);
        
        /*
         * 一下操作那些正确，那些错误?
         * 
         * 请问:
         *      这里是指向不可变，还是指向内容不可变???
         * 
         * 这里final Person person 实际上修饰的内容是person引用数据类型变量
         * 也就是说当前引用数据类型变量中保存的数据是不能修改的！！！
         * 引用数据类型变量保存的数据是地址，地址指向不得改变。
         * 
         * 指向空间中保存的数据内容是可以改变的！！！
         * 
         * 生活例子:
         *      你买的房子地址不会发生改变，但是房子内部的装修装饰是可以发生改变。
         */
         // person = new Person();
         
         person.name = "彭于晏";
         person.age = 6;
    }
}

4. static关键字【重点】

4.1 static修饰静态成员变量

4.1.1 为什么要使用静态成员变量

    开发中存在一些共享数据，这些数据存在于每一个类对象中，并且一致数据！！！如果每一个对象都存储当前数据，会导致大量的资源浪费！！！
    
    共享单车
        共享资源，共享经济
        1. 共享单车不占用用户空间。占用公共空间。
        2. 共享单车是否与你有关???
            所属权归共享单车的运营公司
            每一个用户拥有使用权。
        3. 共享单车被XXX卸了座，大家都无法使用。
        4. 你来到北京之前，共享单车已经存在，你走之后，共享单车依然存在。
    
    饮水机
        共享资源
        1. 占用共享空间，不占用用户空间
        2. 饮水机与你有关?
            只能使用
        3. 饮水机里面放了巴豆，蹦沙卡拉卡...
        4. 饮水机在这里，你走之后，它还在这里。