今日内容

零、复习昨日
一、final
二、static
三、多态
四、向上转型&向下转型
五、多态应用

零、复习昨日

封装
类的封装: 1 属性私有 2提供setget

继承
A extends B
子类可以使用父类非私有属性和方法
好处: 复用,多态准备

重写/覆写/覆盖/Override
子类重写父类的方法,以适应自己本身
多态准备

this super
发现: 在创建子类对象时先创建父类对象
为什么? 默认构造方法第一行有个super()调用父类构造方法
super代表父类对象 this 当前对象
super() super(实参) super.属性 super.方法
this() this(实参) this.属性 this.方法

访问修饰符
public > protected > package > private

子父类创建对象的过程
new 子类(),但是先super()调用父类构造
父类属性先初始化,后再执行父类构造方法内代码
在子类属性初始化,最后执行子类构造方法内代码
将对象地址赋值给引用

一、final

final 最终最后,修饰符,用来修饰类,属性,方法

final 修饰类,该类不能被继承,即该类不能有子类 (太监类)

final 修饰方法,该方法不能被重写

final 修饰属性/变量,变量变常量,不能被更改

    final int PEOPLE_AGE = 19;
    /**
     * 命名规范:
     *  变量命名驼峰原则: userName
     *  常量命名: 全部大写,多个单词之间使用下划线
     */

public static void main(String[] args) {
        // final 限制了father引用不能再改变
        final Father father = new Father( );
        // 但是不影响对象内部属性的变化
        father.age2 = 19;

        // 即不能像这样,再次引用别的对象
        // father = new Father();
    }

二、static

2.1 特点

static 静态修饰符,修饰属性 ,方法 ,类(静态内部类)

package com.qf.static_;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Huangniu {
    /**
     * static 修饰的属性在内存只有一份,被该类所有对象共享
     * 即这些静态属性叫做: 类属性,属于类
     * --------------------------------------
     * - static修饰属性和方法,随着类(字节码文件)加载而初始化
     * - static修饰的属性和方法,可以直接通过类名调用,不用对象
     * - static修饰的属性和方法,在内存只有一份,不属于某个对象,而是属于字节码文件
     */
    static int ticketNum = 100;// 许嵩演唱会票

    /**
     * 普通成员变量,即成员属性,每次创建对象,每个对象都有一份属于自己的属性
     * 即这些属性叫做: 对象属性,这些属性属于对象
     */
    String name;


    // 售票
    public void sell(){
        ticketNum--;
        System.out.println("售出一张" );
    }

    // 查余票
    public int getTicketNum(){
        return ticketNum;
    }

    public static void jiao(){
        System.out.println("黄牛叫卖" );
    }

    public static void main(String[] args) {
        Huangniu niu1 = new Huangniu( );// 黄牛
        System.out.println("1售票前"+niu1.getTicketNum( ));
        niu1.sell();// 售票
        System.out.println("1售票后"+niu1.getTicketNum( ));
        niu1.name = "牛1";

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

        Huangniu niu2 = new Huangniu( );// 黄牛
        System.out.println("2售票前"+niu2.getTicketNum( ));
        niu2.sell();// 售票
        System.out.println("2售票后"+niu2.getTicketNum( ));
        System.out.println(niu2.name );


        System.out.println(Huangniu.ticketNum );
        Huangniu huangniu = new Huangniu( );
    }
}

总结:

static修饰属性和方法,随着类(字节码文件)加载而初始化
static修饰的属性和方法,可以直接通过类名调用,不用对象
static修饰的属性和方法,在内存只有一份,不属于某个对象,而是属于字节码文件
静态方法只能调用静态
静态方法内部不能使用this

2.2 应用

1 当某些数据需要被所有对象共享时,给数据(属性或变量)设置static,例如票

2 当某些方法需要方便调用时,可以将方法设置静态,这样就是通过类名直接调用,而不用创建对象

 		int[] arr = {1,23,4,5,6};
        System.out.println(Arrays.toString( arr) );
        System.out.println(Math.abs(-1));

总结: 有静态修饰就直接使用,没有静态修饰,就创建对象用对象调用

三、多态

生活中的多态: 变形金刚,蝌蚪,铁甲小宝

程序中的多态: 同一个方法,出现不同的结果

多态的出现,要满足三个前提条件:

继承/实现
重写
父类引用指向子类对象(向上转型)

演示

package com.qf.poly;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class TestPoly {

    public static void main(String[] args) {
        // 创建对象
        // 类名 对象名 = new 类名();
        // 类名 引用 = new 构造方法();
        Dog dog = new Dog();

        // 父类引用,指向子类对象(向上转型)
        // Animal animal = new Dog();
        //
        // animal.eat();
        feed(new Dog( ));
        feed(new Cat( ));
        feed(new Pig( ));
        feed(new Tiger( ));

    }

    // 多态改造
    // Animal animal = new Dog( );
    // Animal animal = new Cat( );
    // Animal animal = new Pig( );
    // Animal animal = new Tiger( );
    public static void feed(Animal animal) {
        animal.eat();// 此方法体现出多态效果
        /**
         * 编译看父类
         * 运行看子类
         */
    }


    // 动物园饲养动物
    // public static void feed(Dog dog){// Dog dog = new Dog
    //     dog.eat();
    // }
    //
    // public static void feed(Cat cat) {
    //     cat.eat();
    // }
    // public static void feed(Pig pig) {
    //     pig.eat();
    // }
}