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

巴特西

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

最新文章

热门文章

巴特西

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

最新文章

热门文章

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