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