JavaSE基础--（三）面向对象 部分

8/15/2015 1:30:58 AM

---

面向对象的三大特性：封装、继承、多态。
类里面的三大成员：Filed、构造器、方法（可能出现的第四种成员：初始化块）

---

封装（初步定义，以后单独分析）

隐藏对象的属性和实现细节，仅对外公开它的访问方法。
将抽象得到的数据和行为（或功能）相结合，形成“类”。
封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。
封装的基本要求是: 把所有的属性私有化，对每个属性提供getter和setter方法（不是必须）

继承（初步定义，以后单独分析）

通过继承实现代码复用。继承而得到的类称为子类，被继承的类称为父类。
### 继承特点 ###
    1 子类拥有父类非private的属性和方法。(构造器不可以继承，但是可以通过super调用)
    2 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
    3 子类可以用自己的方式实现父类的方法。
### 谨慎使用继承 ###
    1 父类变，子类就必须变。
    2 继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的。
    3 继承是一种强耦合关系。

    问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型，则继承是必要的否则不建议。（向上转型看我的另一篇博文）

多态

相同类型的变量、调用同一个方法时呈现出多种行为特征，这就是多态。（Field不发生多态）
    BaseClass（编译时类型） ploymophicBc = new SubClass();（运行时类型）
java引用变量有两个类型，一个编译时类型，一个运行时类型，如果编译时与运行时类型不一样，则发生多态，其方法总是表现出子类方法的行为特征。
注意：引用变量在编译时只能调用其编译类型多具有的方法，但运行时执行的它运行时所具有的方法。

### 实现多态有三个必要条件：继承（或实现接口）、重写、向上转型 ###
实现多态的case：

        class BaseClass
        {
            public void test()
            {
                System.out.println("父类的被覆盖的方法");
            }
        }
        //*继承*了BaseClass
        public class  SubClass extends BaseClass
        {
            //*重写*父类的test方法
            public void test()
            {
                System.out.println("子类的覆盖父类的方法");
            }
            public void sub()
            {
                System.out.println("子类的普通方法");
            }
            public static void main(String[] args)
            {

                //下面编译时类型和运行时类型不一样，多态发生（*向上转型*）
                BaseClass ploymophicBc = new SubClass();            
                //下面调用将执行从当前类的test方法（多态发生）
                ploymophicBc.test();

                //因为ploymophicBc的编译类型是BaseClass，
                //BaseClass类没有提供sub方法,所以下面代码编译时会出现错误。
                //ploymophicBc.sub();
            }
        }

    Output：
        子类的覆盖父类的方法
        error

分析：当超类对象引用变量引用子类对象时，运行时类型而不是编译时类型决定了调用谁的成员方法；
     这个被调用的方法必须是在超类中定义过的，也就是说被子类重写（覆盖）的方法。

---

构造器与初始化块

### 构造器（构造方法） ###
    构造器是一种特殊的方法，用于创建实例化时执行初始化，是创建对象的重要途径，因此java类中必须包含一个以上的构造器。
    主要用于被其他方法调用，用以返回该类的实例，因此通常把构造器设成public。
    建议通常为该类额外保留一个无参数的构造器。
  #### 构造器的重载 ####
    同一个类中具有多个构造器，多个构造器的形参列表不同，即被称为构造器的重载

    子类构造器中既没有super调用父类构造器，又没有this调用本类构造器，系统在执行子

### 例子 ###
    类构造器前，隐式调用父类（以及父类的父类，以此类推到Object类）无参数的构造器。(由父类及子类)

    public class Person {  
            protected String name;  
            protected int age;  
            protected String sex;  

            Person(){  
                System.out.println("Person Constrctor...");  
            }  
        }  

        public class Husband extends Person{  
            private Wife wife;  

            Husband(){  
                System.out.println("Husband Constructor...");  
            }  

            public static void main(String[] args) {  
                Husband husband  = new Husband();  
            }  
        }  

        Output:  
        Person Constrctor...  
        Husband Constructor... 

    分析：隐式调用父类的构造器是有前提的：父类有默认构造器。如果父类没有默认构造器，会运行报错，
    我们就要在子类构造器第一行显示的使用super()来调用父类构造器（具体看下面super）

### 初始化块 ###
    与构造器作用类似，是java里可能出现的第四种成员，在执行构造器之前执行。当创建java对象时，总是先调用该类里定义的初始化块。
    如有多个，前面定义的初始化先执行，后面的初始化后执行。虽说可定义多个初始化块，但没有意义，完全可放在一个初始化块中执行

    初始化块是构造器的补充，如果两个构造器有相同的初始化代码，且无需接收参数，就可把相同的代码提取出来放在初始化块中，
    提高初始化块的复用，提高整个应用的可维护性，与构造器类似，创建一个java对象，不仅会执行该类的普通初始化块和构造器，
    还会上溯到java.lang.Object(先执行，后面依次执行，最后执行所在类的初始化块）
  #### 静态初始化块 ####
    一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,
    两者的区别就是:静态代码块是在类加载时自动执行的;非静态代码块是在创建对象时自动执行的代码，只执行一次，
    构造方法是创建对象时自动执行的代码，每创建一个对象，执行一次。执行顺序为静态代码块——非静态代码块—-构造器——方法

  **提示：当JVM第一次主动使用某个类时，系统会在类准备阶段（才会）为该类的所有静态Field分配内存**

---