Java面向对象

封装、继承、多态

Person类

//在Java中，所有的类都默认直接或间接继承Object类
public class Person {
    // 一个类即使什么都不写，也会存在一个构造方法
    // 显式定义（public）构造器（构造方法）
    // 构造方法：1、和类名相同     2、没有返回值


    /*
        封装的好处：
        1、提高程序的安全性，保护数据
        2、隐藏代码的实现细节
        3、统一接口
        4、增加系统可维护性
     */
    //属性私有
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 实例化初始值
    // 1、使用new关键字，本质上是在调用构造器
    // 2、用来初始化值
    public Person() {
        System.out.println("Person无参执行了");
    }

    // 有参构造：一旦定义了有参构造，无参就必须显式定义
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    // Alt + Insert 生成构造方法
}

Student类

// 子类继承了父类，就会拥有父类的全部方法
// Java中只有单继承，没有多继承
// 私有的属性和方法无法被继承
// Ctrl + H打开继承树
public class Student extends Person{
    public Student() {
        // 隐藏代码：调用了父类的无参构造方法
        super(); // 只要继承了父类，此方法自动调用。如果父类没有定义无参构造，报错。
        // 解决方法：显式用super调用有参构造方法
        /*
        super注意点：
            1、super调用父类的构造方法，必须在构造方法的第一个
            2、super必须只能出现在子类的方法或构造方法中
            3、super和this不能同时调用构造方法
        vs this：
            代表的类不同：
                this：本类
                super：代表父类对象的引用
            前提：
                this：没有继承也可以使用
                super：只能在继承条件才可以使用
            构造方法：
                this()：本类的构造
                super()：父类的构造
         */
        System.out.println("Student无参执行了");
    }
}

Animal类

//重写都是方法的重写，和属性无关
public class Animal {
    public Animal() {
    }
    public void run(){
        System.out.println("动物在跑");
    }
    public void eat(){
        System.out.println("动物在吃");
    }
}

Dog类

public class Dog extends Animal {
    public Dog() {
        super();
    }

    // static：方法不能被子类重写

    /*
        Override 重写：需要有继承关系，子类重写父类的方法
        Java 重写(Override)与重载(Overload)的区别：https://www.runoob.com/java/java-override-overload.html
        1、方法名必须相同
        2、参数列表必须相同
        3、修饰符：范围可以扩大但不能缩小   public>protected>default>private
        https://blog.csdn.net/xiexingshishu/article/details/53690033
        4、抛出的异常：范围可以被缩小但不能扩大

        不能重写的修饰符：static final private
        为什么要重写：父类的功能子类不一定需要
     */
    /*
        多态存在条件：
            1、有继承关系
            2、子类重写父类方法
            3、父类引用指向子类对象
        注意事项：
            1、多态是方法的多态，属性没有多态
     */
    @Override // 注解：有功能的注释
    public void run() {
        System.out.println("狗在跑");
    }
    public void bark() {
        System.out.println("狗在叫");
    }
}

instanceof和类型转换

Application类

public class Application {
    public static void main(String[] args) {
        // 实例化了一个对象
        Person person = new Person();
        person.setAge(13);
        System.out.println(person.getName() + "\n" + person.getAge());

        // 静态方法：方法的调用只和左边定义的数据类型有关
        // 非静态方法：调用重写后的方法

        // Dog能调用的方法都是自己的或者继承父类的
        Dog dog = new Dog();

        //父类引用可以指向子类对象，但不能调用子类独有的方法
        Animal animal = new Dog();
        /*
            等价于
            Dog dog = new Dog();
            Animal animal = dog;
            低转高可能丢失除了Dog继承Animal以外的方法
         */
        Object object = new Animal();
        /*
            引用类型  变量名 = new 类名1();
            变量名 instanceof 类名2;
            Step1: 引用类型是否可以强制转换为类名2
                    可以：Step2;
                    不可以：编译报错,结束
            Step2:
                1、测试它左边的对象是否是它右边的类的实例
                2、左边是右边的直接或间接子类
                    是：true
                    不是：false

            Object -> Animal -> Dog
         */
        System.out.println(object instanceof Cat);// false

        // 对象能执行哪些方法，主要看对象左边的类型
        dog.run();
        animal.eat();

        /*关于强制转换的括号问题
        https://stackoverflow.com/questions/13581353/issue-about-casting-object-brackets
         */
        ((Dog)animal).bark();

        animal.run(); // 子类重写了父类的方法，执行子类的方法

        Student student = new Student();
        student.eat();
    }
}

static关键字

// 静态导包     可以导入方法和常量
import static java.lang.Math.random;
public class Static {
    // 1    只执行一次
    static {
        System.out.println("静态代码块");
    }

    // 2     作用：赋初值
    {
        System.out.println("匿名代码块");
    }

    // 3    构造方法
    public Static() {
        System.out.println("构造方法");
    }

    // 执行顺序：静态代码块 > 匿名代码块 > 构造方法

    public static void main(String[] args) {
        Static aStatic = new Static();
        /*
            输出内容：
                静态代码块
                匿名代码块
                构造方法
         */
        Static aStatic1 = new Static();
        /*
            输出内容：
                匿名代码块
                构造方法
         */
    }
}