面向对象的第二部分

多态性

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
原文地址:https://www.cnblogs.com/li33/p/12710957.html