java学习总结-高级语言特性-封装，继承，多态

1.1. 封装 (encapsulation)
1．事物的内部实现细节隐藏起来
2．对外提供一致的公共的接口――间接访问隐藏数据
3．可维护性

1.2. 继承 (inherit)
1.2.1. JAVA继承特点
 继承：父类的成员能否继承到子类？
 子类能否访问到父类的成员

private：本类内部可以访问 不能继承到子类
（default）：本类内部可以访问，同包其他类也可 以访问
 能否继承到子类？ 不一定

protected：本类内部可以访问，不同包的子类也可以访问， 同包其他类也可以访问
 能继承到子类  
public：任何地方都可以访问 能继承到子类

从严 到宽

（override）覆盖的构成条件：
1、方法名：相同
2、参数表：相同（个数，类型）
3、访问限制符：相同或者更宽
4、返回值类型：相同 或者 子类返回的类型是父类返回的类型的子类
5、不能抛出比subclass(父类)更多的异常

对象的构造过程：
1.递归的构造父类对象
2.分配空间
3.初始化属性
4.调用本类的某一个构造方法,并用在方法的第一句。

super：调用父类的某一个构造方法
 父类对象
不能出现在static方法内

多态：
1. 对象不变
2. 只能对对象调用编译时类型中定义的方法
3. 运行时，根据对象的运行时类型，找覆盖过的方法来调用（运行时动态类型判定）

强制类型转换 instanceof

屏蔽子类差异，利用父类共性做出通用编程

属性的遮盖（shadow）没有多态
方法的重载看参数的编译时类型

1.2.2. 父类（SuperClass）和 子类（SubClass）的关系
父类的非私有化属性(不同包的子类无法访问default修饰符)和方法可以默认继承到子类。
Class Son extends Father{
}
而如果父类中的私有方法被子类调用的话，则编译报错。
父类的构造方法子类不可以继承，更不存在覆盖的问题。
所以子类构造方法默认调用父类的无参构造方法。（所以养成写无参构造的习惯）
如果子类访问父类的有参构造方法，必须在子类构造方法第一行使用super(参数)
当构造一个对象的时候，系统先构造父类对象，再构造子类对象。
Public class BMWcar extends Car{
 Public BMWcar(){
 Super(int alength); //显式的调用父类的构造，默认调用无参构造
 //所以父类没有无参构造的话，子类如果不加显示调用其他构造就会报错。这里的super是一个对父类的引用
 }
}

1.2.3. 系统构造一个对象的顺序 
1先为最里层类成员属性赋初值；
2再构造该类对象；
3返回外层，重复1（上一层类）、2步骤直到完成最外层类的构造。

最外层类
 
最里层基类
 
<!--[if !vml]-->最外层类［里层类］

 
注意：super() this() 不会同时出现
A(){
super();
}
A(int a){
this();
}
1.3. 多态(polymorphism) 
多态：一个对象变量可以指向多种实际类型的现象。

1.3.1. 方法的覆盖（overridding）
当子类从父类继承一个无参方法，而又定义了一个同样的无参方法，则子类新写的方法覆盖父类的方法，称为覆盖。（注意返回值类型也必须相同，否则编译出错。）
如果方法参数表不同，则成重载。
特点：
1．对于方法的访问限制修饰词，子类方法要比父类的访问权限更高。
父类为public，那么子类为private则出现错误。
2．子类抛出的异常应该是父类抛出的异常或其子类。

1.3.2. 多态的分类
多态分两种：
1编译时多态：编译时动态重载；
2运行时多态：指一个对象可以具有多个类型，方法的覆盖
这样对于对象而言分为：
理解运行时多态：
Car c = new Bus();
Car编译时类型 编译时检查变量类型是否存在，是否有调用的方法
Bus运行时类型 实际运行是访问heep中的对象，调用实际的方法。
运行时多态是由运行时类型决定的
编译时多态是由编译时类型决定的
猫，小鸟，狗 都是动物，都可以安上动物的标签。
Interface Animal{}
Class Car implements Animal{}
Class Bird implements Animal{}
Class Dog implements Animal{}
方法中
Animal a = new Car();
Animal b = new Bird();
Animal c = new Dog();

*方法重载看的是参数的编译时类型

public class Animal{
 public static void main(String[] args){

 }
}


(1)   是覆盖吗？不能多态了
abstract class MyClass{
 priavate void m();
}
class Sub extends MyClass(){
 public void m();
}
(2)  错误的修饰符组合
abstract class MyClass{
 priavate abstract void m();
}
class Sub extends MyClass(){
 public void m();
}
(3) 5.0 新 非覆盖 
abstract class MyClass{
private final void m();
}
class Sub extends MyClass(){
 public void m();
}


1.3.3. 运行时多态的三原则
1.对象不变；（改变的是主观认识）
2.对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。
在上面的例子中：Animal a=new Dog()；对象a的编译时类型为Animal，运行时类型为dog。
注意：编译时类型一定要为运行时类型的父类或者同类型。
对于语句：Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。
3.动态类型判定实际调用的方法。即它调用覆盖后的方法。