面向对象部分

一.三大特征

• 封装
• 继承
• 多态：程序中允许出现重名现象，多态体现：重载+重写。

重载与重写的区别：

1）重写：发生在父子类中，方法名相同，参数列表相同，返回值相同，权限修饰符不能小于被重写方法的修饰符。

遵循“运行期”绑定，根据引用指向对象的类型调用方法。

运行时确定如何调用称为动态绑定（晚绑定）多态体现（动态绑定）

2）重载：发生在一个类中，方法名相同，参数列表不同（参数个数，参数类型），方法体一般也不同，与返回值无关，与权限修饰符无关。

遵循“编译期”绑定，根据引用的类型调用方法。

编译时确定如何调用称为静态绑定（早绑定）

 

二.java7中抽象类和接口

 接口和抽象类都不能被实例化。

1. 抽象类中可以有构造方法，普通方法和普通成员变量。接口中不能有构造方法，接口中只能声明静态公共常量，默认都是抽象方法。
2. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然 eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。 
3. 抽象类中可以包含静态方法，接口中不能包含静态方法 。
4. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。 
5. 接口需要被实现，抽象类需要被继承。
6. 接口可以多继承，多实现，抽象类单继承。
7. 抽象类提供一种IS-A关系，接口是LIKE-A关系。

三.类的加载顺序

父类静态代码块，父类静态成员变量(按代码顺序)

子类静态代码块，子类静态成员变量(按代码顺序)

父类普通代码块，父类普通成员变量(按代码顺序)

父类构造方法

子类普通代码块，子类普通成员变量(按代码顺序)

子类构造方法

class FuTest {
    public static int i = 10;
    private int j = 15;
    static {
        System.out.println("父类静态代码块，无静态变量");
    }
    static {
        i = i + 100;
        System.out.println("父类静态代码块，有静态变量,i=" + i);
    }
    {
        System.out.println("父类代码块，无静态变量");
    }
    {
        j = j + 200;
        System.out.println("父类代码块，有静态变量，j=" + j);
    }
    public FuTest() {
        System.out.println("父类构造方法");
    }
}
public class ZiTest extends FuTest {
    public static int m = 20;
    private int n = 30;
    static {
        System.out.println("子类静态代码块，无静态变量");
    }
    static {
        m = m + 300;
        System.out.println("子类静态代码块，有静态变量,m=" + m);
    }
    {
        System.out.println("子类代码块，无静态变量");
    }
    {
        n = n + 400;
        System.out.println("子类代码块，有静态变量, n=" + n);
    }
    public ZiTest() {
        System.out.println("子类构造方法");
    }
    public static void main(String[] args) {
        ZiTest zi = new ZiTest();
    }
}

结果：

父类静态代码块，无静态变量
父类静态代码块，有静态变量,i=110
子类静态代码块，无静态变量
子类静态代码块，有静态变量,m=320
父类代码块，无静态变量
父类代码块，有静态变量，j=215
父类构造方法
子类代码块，无静态变量
子类代码块，有静态变量, n=430
子类构造方法

 

四.访问控制符

 

private只有在本类中才能访问；

public在任何地方都能访问；

protected在同包内的类及包外的子类能访问；

默认不写在同包内能访问。

 

五.成员内部类

成员内部类的访问规则

（1）成员内部类不是静态的：外部类名.内部类名 对象名=new 外部类名（）.new 内部类名（）；

（2）成员内部类是静态的：外部类名.内部类名  对象名=new 外部类名.内部类名();

/**
 * 创建内部类的对象
 */
public class InnerClass {
    public static void main(String[] args) {
        Onner.Inner inner = new Onner().new Inner();
        Onner.Sinner sinner = new Onner.Sinner();
    }
}
class Onner{
    class Inner{
    }
    static class Sinner{
    }
}