Java

面向对象

面向过程和面向对象

面向过程注重过程，犹如烧水喝茶的过程，先煲水，再冲茶。面向对象则是将这个过程参与者看做对象，有人的动作倒水，有水壶的动作烧水，有人的动作冲茶。将这个过程归类 class 成为一个个对象 Object，对象有方法 Method 和属性 field。

过程固定，则灵活性不高；不同的对象，使用不同的方法，则可以排列组合出多种过程。面向对象编程更贴切生活中的例子。面对复杂的编程要求，面向对象有良好的扩展性。

面向对象三大特性：封装，继承和多态。

• private 修饰变量和方法等体现了封装的特性，但是并不是意味着封装就是私有（private）。
• Java 支持单继承类 class，多实现接口 interface。

类

类可以浓缩成这种形式，extends 和 implements 并存时不可以调换顺序，如果没有添加 [ ] 默认是继承 SUN 公司提供的根类 Object：

class A [extends B] [implements C] {
}

构造方法

默认构造方法的 super() 调用

父类 SuperClass 和 子类 SubClass，当子类的没有写构造方法的时候，编译会默认追加注释行代码，参看代码

class SuperClass {
    public SuperClass() {
        System.out.println("Super");
    }
}

class SubClass extends SuperClass {
    //public SubClass() {
    //    super();
    //}
}

注释行代码写与否都会输出下列的结果 output: Super

public class Test01 {
    public static void main(String[] args) {
        //测试证明，子类如果不重写，编译器也会默认写上 super() 这一行代码
        SubClass subClass = new SubClass();
    }
}

抽象类

抽象类能够继承非抽象类？

Object 类是 sun 公司提供的根类，所有类都默认是继承 Object 类，其中就有抽象类，所以答案是可以。举个例子：

无论是 java 自带的类库还是自己新建的抽象类，无一例外继承了 Object 类。

接口

接口的根类是 Object 类？

不是，这篇文章很详细说明了。举个直观例子说明：

权限修饰符

四种修饰符：private，(default)，protected，public。

修饰词	本类	同一个包的类	子类	任何地方
private	√	×	×	×
(default)	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

如果 ModifierTest01 和 ModifierTest02 不在同一个包，只能访问到 height 和 id 属性。

package javase.modifier;

public class ModifierTest01 {
    private int age = 1;
    int count = 2;
    protected int height = 3;
    public int id = 4;
}

package javase;

public class ModifierTest02 extends ModifierTest01 {
    public static void main(String[] args) {
        ModifierTest02 test02 = new ModifierTest02();
        System.out.println(test02.height);
        System.out.println(test02.id);
    }
}

子类继承父类的所有成员变量和方法，但是由于权限控制有些成员变量和方法不能直接使用。

构造方法和静态代码块加载顺序

/**
 * 1.实验结果表明，static 修饰的静态代码块在类加载的时候就运行，且只运行一次
 * 2.构造方法随 new 对象的时候执行，每新建一个对象执行一次
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("-------------- 实验 1 --------------");
        new Main();
        new Main();
    }

    static {
        System.out.println("before main");
    }

    public Main() {
        System.out.println("Main.Main");
    }
}

output:
before main
-------------- 实验 1 --------------
Main.Main
Main.Main

多态

package javase;

/**
 * 1.父类引用指向子类对象，只能使用父类本身的成员变量
 * 2.强制类型转换后，就可以使用子类的成员变量
 * 3.instanceof 测试结果表明，一个类的对象 instanceof 类 / 父类，返回 true；一个类的对象 instanceof 子类 / 其他类，false
 */
public class PlymorphismTest01 {
    class FatherClass {
        private String name = "Father";
    }

    class SonClass extends FatherClass {
        String name = "Son";
    }

    public void fun1() {
        FatherClass f = new SonClass();
        System.out.println(f.name); //Father
        System.out.println("-------------- 父类转为子类 --------------");
        System.out.println(((SonClass) f).name); //Son
    }

    public void fun2() {
        FatherClass f = new FatherClass();
        System.out.println(f instanceof FatherClass); //true
        System.out.println(f instanceof SonClass); //false
    }

    public void fun3() {
        SonClass f = new SonClass();
        System.out.println(f instanceof FatherClass); //true
        System.out.println(f instanceof SonClass); //true
    }

    public static void main(String[] args) {
        new PlymorphismTest01().fun1();
    }
}