李刚疯狂java讲义第3_【Java】-NO.16.EBook.4.Java.1.003-【疯狂Java讲义第3版 李刚】- oop...

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 修饰符范围总表