1.0.0 Summary
Tittle：【Java】-NO.16.EBook.4.Java.1.003-【疯狂Java讲义第3版 李刚】- oop
Style：EBook
Series：Java
Since：2017-09-04
End：....
Total Hours：...
Degree Of Diffculty：2
Degree Of Mastery：2
Practical Level：2
Desired Goal：2
Archieve Goal：....
Gerneral Evaluation：...
Writer:kingdelee
Related Links：
http://www.cnblogs.com/kingdelee/
值传递：
方法参数的传递方式，值传递的本质，即是传递副本，原值不受影响（不太准确）。
无论是基本数据类型，还是引用类型，都是采用值传递。
区别的是，引用是，副本保存的是引用地址，栈中的副本的变化即会改变堆中被引用的对象的变化。
而基本数据类型，并非引用，其改变的只有栈副本本身，而方法外的栈原值是不会被改变的。
高内聚：
尽可能把模块内部的功能在模块内部独立完成，不允许外部去干预
低耦合：
仅暴露少量的方法让外部使用
import：
系统默认导入java.lang包下的所有类。
继承时实例变量的内存分配：
创建子类对象时，系统不仅会给子类的实例变量分配内存，也会给父类的实例变量分配内存。如父类A有2个实例变量，子类B有3个，当创建子类B时，Java对象B的实力将保存5个实例变量。
构造方法：
创建子类对象时
1.若子类没有显式构造方法，则一定会调用父类的无参构造方法。
2.若子类有显式的构造方法，通过该构造方法创建对象时，构造方法第一行 一定是 显式/隐式的 this 或者 super，若有this调用本类的其他构造方法，若无this则为 显式/隐式的 super 直接调用父类对应的构造方法（显式调显式，隐式调无参构造方法）
向上转型：
子类实际上是一种特殊的父类，故父类可以直接赋值给子类，无需任何类型转换。
Object是所有类的父类，可以直接Object o = new AA();但是无法调用AA的方法
instanceof：
编译时：
前者和后者必须存在继承关系或者相同关系（无需考虑子父类顺序），否则会编译异常
运行时：
用于判断前者是否是后者的子类或者同类（子类在前，父类在后）
先用一个对象来判断是否可以强转，再去用(type)运算符进行强壮。
当把父类赋值给子类时，需要进行强制转换，而且还有可能在运行时产生类型转换异常，使用instanceof判断会更加安全
if( cat instatnceof Animal){
Animal a = (Animal) cat;
}
继承：
设计父类时：
不应在父类的构造器中调用可能被子类重写的方法。
class Animal
{
private void beat()
{
System.out.println("心脏跳动...");
}
public void breath()
{
beat();
System.out.println("吸一口气，吐一口气，呼吸中...");
}
}
// 继承Animal，直接复用父类的breath()方法
class Bird extends Animal
{
public void fly()
{
System.out.println("我在天空自在的飞翔...");
}
}
// 继承Animal，直接复用父类的breath()方法
class Wolf extends Animal
{
public void run()
{
System.out.println("我在陆地上的快速奔跑...");
}
}
public class InheritTest
{
public static void main(String[] args)
{
Bird b = new Bird();
b.breath();
b.fly();
Wolf w = new Wolf();
w.breath();
w.run();
}
}
组合：
类编写阶段：
1.用组合改写继承的方式，即子类不继承父类而是持有父类，并在构造方法将父类的引用对象传入并持有。
2.将需要继承父类的方法在子类中重写。
类使用阶段：分别创建父类、子类的实例，并让子类持有父类。这样子类就可以通过
class Animal
{
private void beat()
{
System.out.println("心脏跳动...");
}
public void breath()
{
beat();
System.out.println("吸一口气，吐一口气，呼吸中...");
}
}
class Bird
{
// 将原来的父类组合到原来的子类，作为子类的一个组合成分
private Animal a;
public Bird(Animal a)
{
this.a = a;
}
// 重新定义一个自己的breath()方法
public void breath()
{
// 直接复用Animal提供的breath()方法来实现Bird的breath()方法。
a.breath();
}
public void fly()
{
System.out.println("我在天空自在的飞翔...");
}
}
class Wolf
{
// 将原来的父类组合到原来的子类，作为子类的一个组合成分
private Animal a;
public Wolf(Animal a)
{
this.a = a;
}
// 重新定义一个自己的breath()方法
public void breath()
{
// 直接复用Animal提供的breath()方法来实现Wolf的breath()方法。
a.breath();
}
public void run()
{
System.out.println("我在陆地上的快速奔跑...");
}
}
public class CompositeTest
{
public static void main(String[] args)
{
// 此时需要显式创建被组合的对象
Animal a1 = new Animal();
Bird b = new Bird(a1);
b.breath();
b.fly();
// 此时需要显式创建被组合的对象
Animal a2 = new Animal();
Wolf w = new Wolf(a2);
w.breath();
w.run();
}
}
初始化：
静态代码块（静态初始化块）与静态成员的之间初始化顺序，以其在代码中的先后排列顺序而定。
public class StaticInitTest
{
// 先执行静态初始化块将a静态成员变量赋值为6
static
{
a = 6;
}
// 再将a静态成员变量赋值为9
static int a = 9;
public static void main(String[] args)
{
// 下面代码将输出9
System.out.println(StaticInitTest.a);
}
}
Java 修饰符范围总表
