java类的三大特性——封装，继承，多态

在类内部，对于成员变量，如果在定义的时候没有进行显示的赋值初始化，则Java会保证类的每个成员变量都得到恰当的初始化：

1. 对于  char、short、byte、int、long、float、double等基本数据类型的变量来说会默认初始化为0（boolean变量默认会被初始化为false）；
2. 对于引用类型的变量，会默认初始化为null。

如果没有显示地定义构造器，则编译器会自动创建一个无参构造器，但是要记住一点，如果显示地定义了构造器，编译器就不会自动添加构造器。注意，所有的构造器默认为static的。

下面我们着重讲解一下 初始化 顺序：

　　当程序执行时，需要生成某个类的对象，Java执行引擎会先检查是否加载了这个类，如果没有加载，则先执行类的加载再生成对象，如果已经加载，则直接生成对象。

　　在类的加载过程中，类的static成员变量会被初始化，另外，如果类中有static语句块，则会执行static语句块。static成员变量和static语句块的执行顺序同代码中的顺序一致。记住，在Java中，类是按需加载，只有当需要用到这个类的时候，才会加载这个类，并且只会加载一次。

 

封装：

封装从字面上来理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。

      对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。

      使用封装有三大好处：

         1、良好的封装能够减少耦合。

         2、类内部的结构可以*修改。

         3、可以对成员进行更精确的控制。

         4、隐藏信息，实现细节。

 

继承：

在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。

1.子类继承父类的成员变量

　　当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：

　　1）能够继承父类的public和protected成员变量（通过this可以访问）；不能够继承父类的private成员变量；

　　2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

public class Father {

    protected String firstName;
    private String secondName;
    public Father(){
        this("first","second");
    }
    public Father(String firstName,String secondName){
        this.firstName = firstName;
        this.secondName = secondName;
        System.out.println("Father:"+this.firstName);
        System.out.println("Father:"+this.secondName);
    }
    public Father(String firstName){
        this.firstName = firstName;
        System.out.println("Father:"+this.firstName);
        System.out.println("Father:"+this.secondName);//没有赋值，初始化为null
    }
}

 

public class Child1 extends Father {
    private String secondName;
    public Child1(String firstName){
        super(firstName);
    }
    public Child1(String firstName,String secondName){
        super(firstName);//调用父类的一个参数的构造函数
        this.firstName = firstName;//继承父类的firstName
        this.secondName = secondName;//这个是子类的secondName，如果子类没有这个属性，会报错，因为不能继承父类私有的成员变量
        System.out.println("Child:"+this.firstName);
        System.out.println("Child:"+this.secondName);
    }

}

 

public class TestSome {
    public static void main(String[] args){
        Child1 child1 = new Child1("Huang","Chaohui");
    }
}

打印结果：

 

2.子类继承父类的方法

　　同样地，子类也并不是完全继承父类的所有方法。

　　1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；

　　2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

　　注意：隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。（后面会讲到）

3.构造器

　　子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

上诉例子，将 Child1中的super(firstName);注释掉，打印结果如下

 

多态：

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。

例如将上面的例子改一下：

Father类的添加代码

public void action(){
       System.out.println("Action: I am father");
       action2();
}
public void action2(){
      System.out.println("Action2:I am father");
}

 

Child1类的添加代码

 public void action(String s) {
        System.out.println("action: I am Child");
        action2();
 }

    @Override
 public void action2() {
        System.out.println("action2: I am Child");
 }

 

public class TestSome {
    public static void main(String[] args){
        Father child1 = new Child1("Huang","Chaohui");//child自动向上转为Father
        child1.action();
    }
}

结果分析：

先运行父类的action，然后再运行子类的action2

在这个程序中子类Child1重载了父类的方法action()，重写action2()，而且重载后的action(String s)与 action()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行Child1的Father类型引用是不能引用action(String s)方法。而子类Child1重写了action2() ，那么指向Child1的Father引用会调用Child1中action2()方法。

 

总结：指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

 

多态的实现：

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。