java 编程思想 笔记_java编程思想笔记

第一章：对象导论

1.1伴随多态的可互换对象

面向对象程序设计语言使用了后期绑定的概念。当向对象发送消息时，被调用的代码直到运行时才能确定。也叫作动态绑定。

编译器确保被调用的方法的存在，并对调用参数和返回值执行类型检查(java是强类型的语言，无法提供此类保证的语言称为弱类型的)，但是并不知道将被执行的确切代码。

在某些语言中，必须明确地生命希望某个方法预备后期绑定属性所带来的灵活性(C++使用virtual关键字实现的)。在这些语言中，方法默认不是动态绑定的。而java中，动态绑定是默认行为(java中除了使用static,final,private方法外，其他方法都是动态绑定的)，不需要添加额外的关键字来实现多态。

把导出来类看做是他的基类的过程称为向上转型(upcasting)

1.2单根继承结构

在java中(事实上还包括除C++以外的所有OOP语言)，所有的类最终都继承自单一的基类，这个终极基类的名字就是Object.

单根继承结构的好处：

在单根继承结构中所有对象都具有一个公用接口，所以他们归根到底都是相同的基本类型

单根继承结构保证所有对象都具备某些功能

单根继承结构使垃圾回收的实现变得容易，二垃圾回收正式相对C++的重要改进之一。由于所有对象都保证具有其类型信息，因此不会因无法确定对象的类型而陷入僵局。这对于系统级操作(如异常处理)显得尤其重要，并且给编程带来了更大的灵活性。

1.3对象的创建和生命周期

对象的数据位于何处(作用域)

将对象置于堆栈或静态存储区域来实现。这种方式将存储空间分配和释放置于优先考虑的位置，某些情况下这样控制非常有价值。但是，也牺牲了灵活性)

第二种方式被称为堆(heap)的内存池中动态地创建对象。这种方式中，知道运行时才知道需要多少独享，他们的生命周期，以及他们的具体是什么。

java完全采用动态内存分配方式(基本类型是一种特例)。每当想要创建对象时，就要使用new关键字来构建对象的动态实例。

对象生命周期

java的垃圾回收器被设计用来处理内存释放问题

第二章 一切都是对象

2.1特例：基本类型

基本类型是一个并非是引用的“自动”变量。这个变量直接存储“值”，并置于堆栈中，因此使用更高效，java的基本类型所占存储空间大小不随机器硬件架构的变化而变化。这种所占存储空间大小的不变性是java程序比其他大多数语言编写的程序更具有可移植性的原因之一。

基本类型

大小

包装器类型

boolean

-

Boolean

byte

8bits

Byte

char

16bits

Character

short

16 bits

Short

int

32 bits

Integer

float

32 bits

Float

long

64 bits

Long

double

64 bits

Double

void

-

Void

所有数值类型都有正负号

boolean类型所占存储空间的大小没有明确指定(要看具体虚拟机的实现)，仅定义为能够取字面值true或false.

2.2java中的数组

java确保数组会被初始化。而且不能在它的范围之外被访问。这种范围查找，是以每个数组上少量的内存开销以及运行时的下标检查为代价的。

《深入理解Java虚拟机》：

Java 语言中对数组的访问比C/C++相对安全是因为：如有一维数组，其元素类型为 mypackage.MyClass，则虚拟机会自动生成一个直接继承于java.lang.Object的子类[Lmypackage.MyClass，创建动作由字节码指令newarray触发。这个类代表了一个元素类型为mypackage.MyClass的一维数组，数组中应有的属性和方法(用户可直接使用的只有被修饰为public的length属性和clone()方法)都实现在这个类里。Java语言中对数组的访问比C/C++相对安全就是因为这个类封装了数组元素的访问方法(准确地说，越界检查不是封装在数组元素访问的类中，而是封装在数组访问的xaload、xastore字节码中)，而C/C++直接翻译为对数组指针的移动。

数组对象，实际就是一个引用数组，每个元素会被初始化为null.

基本数据类型的数组，编译器会将这种数组所占的内存全部置为零

在java中，检查到数组越界是会抛出java.lang.ArrayIndexOutOfBoundsException异常。

第8章 多态(Polymorphism)

8.2 域与静态方法

域是不具有多态性的，只有普通的方法调用是多态的。如果直接访问某个域，这个访问就将在编译期进行解析，即域是静态解析的。

如下，当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的。Super.field和Sub.field分配了不同的存储空间。这样，Sub实际上包含两个称为field的域：它自己的和它从Super处得到的。

class Super{

public int field = 0;

public int getField(){return field;}

}

class Sub extends Super{

public int field = 1;

public int getField(){return field;}

public int getSuperField(){return super.getField();}

}

public class FieldAccess{

public static void main(String[] args){

Super sup = new Sub(); // Upcast

System.out.println("sup.field = " + sup.field + ". sup.getField() = " + sup.getField());

Sub sub = new Sub();

System.out.println("sub.field = " + sub.field + ". sub.getFiled() = " + sub.getField() + ". sub.getSuperField() = " + 　　　　sub.getSuperField());

}

}

/** Output:

* sup.field = 0. sup.getField() = 1

* sub.field = 1. sub.getFiled() = 1. sub.getSuperField() = 0

*/

静态方法也是不具有多态性的，如前文所述，静态方法是与类，而非与单个的对象相关联的。

8.3 构造器内部的多态方法的行为

如果在构造器内部调用正在构造的对象的某个动态绑定方法，由于动态绑定是在运行时才决定的，而此时，该对象还正在构造中，所以它不知道自己属于哪个类(父类还是自己)，并且方法所操纵的成员可能还未进行初始化，这可能会产生一引起难于发现的隐藏错误。

public class PolyConstructors {

public static void main(String[] args){

new RoundGlyph(5);

}

}

class Glyph{

void draw(){

System.out.println("Glyph.draw()");

}

Glyph(){

System.out.println("Glyph() before draw()");

draw();

System.out.println("Glyph() after draw()");

}

}

class RoundGlyph extends Glyph{

RoundGlyph(int r){

draw();

radius = r;

System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);

}

private int radius = 1;

void draw(){

System.out.println("RoundGlyph.draw(), radius = " + radius);

}

}

Glyph() before draw()

RoundGlyph.draw(), radius = 0

Glyph() after draw()

RoundGlyph.draw(), radius = 1

RoundGlyph.RoundGlyph(), radius = 5