面向对象的第二部分

多态性

public class Father {
    public void run(){
        System.out.println("爸爸再跑");
    }
    public void say(){
        System.out.println("说了一句话");
    }
}
public class Son extends Father {
    @Override
    public void run() {
        System.out.println("儿子再跑");
    }
    @Override
    public void say() {
        super.say();
    }
}
public static void main(String[] args) {
        Father son = new Son();//类指向不同的引用，父类和自身
        Son son1 = new Son();
        son.run();//子类重写了方法后，父类引用调用子类的方法
        son1.run();
        son.say();//子类没有重写，还是调用父类的
        son1.say();
    }
结果：
    儿子再跑
    儿子再跑
    说了一句话
    说了一句话

多态注意事项

• 必须有继承，没有继承就不存在多态
• 方法才能被重写，属性不可以
• 多态必须是指向父类的引用

instanceof类型转换

用来判断对象是什么类型

public static void main(String[] args) {
    Father son = new Son();
    Object object = new Object();
    System.out.println(son instanceof Son);
    System.out.println(son instanceof Father);
    System.out.println(son instanceof Object);
    System.out.println("+++++++++++++++++++++++++");
    System.out.println(object instanceof Son);
    System.out.println(object instanceof Father);
    System.out.println(object instanceof Object);
}
结果：
    true
    true
    true
    +++++++++++++++++++++++++
    false
    false
    true

总结：（可以把intanceof理解为，判断你是不是我的直系后代）

• x instanceof y 。 只要x是y的后代，（自己，儿子，孙子，等等），都是true
• 反过来则不可以

对象强制转换

强制转换的原则

• 父类引用指向子类
• 父类转向子类不会丢失方法，可以用子类的全部方法
• 子类转向父类，会丢失自己的方法。

作用：方便方法的调用，减少重复的代码

静态属性

静态属性

静态方法

静态代码块

public class StaticTest {
    static {//只执行一次，创建n个对象，也只执行一次
        System.out.println("静态代码块");
    }
    {//每次都会执行，可以用来给对象赋初值，因为他每次随着对象一起创建
        System.out.println("匿名代码块");
    }
    public StaticTest(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        StaticTest st = new StaticTest();
    }
}
结果：
    静态代码块
    匿名代码块
    构造方法

实例化一个对象，没想到加载顺序是 （静态代码块->匿名代码块->构造方法）

静态导入包

import static java.lang.Math.random;//静态导入包之后，可以用random()直接调用，不需要
System.out.println(Math.random());//没有静态导入，只能这么用
System.out.println(random());//可以这样

final 修饰了一个类，这个类不能被继承

抽象类（只能单继承，不如接口好）

不能new 抽象类，只能new子类

抽象方法需要子类去实现，抽象方法只能定义在抽象类

抽象类中也可以写普通方法

思考：抽象类的作用是什么？

为什么要用抽象类？提高开发效率

抽象类有构造器吗？

接口

只有规范

疑问：

• 接口的规范，方法是什么类型？
• 接口中的常量类型？
• 接口和实现类的命名规范

回答

1. 实现接口，就必须重写接口中的方法
2. 接口中的方法都是抽象方法，默认是 public abstract 修饰
3. 接口中的属性都是静态常量 ，默认为public static final
4. 接口中的实现类比如接口是User,其实现类是UserImpl