读《疯狂JAVA》笔记一（数组、对象与内存控制）

这是个读书笔记，仅供个人学习记录

这两天看《疯狂JAVA》，感觉好多JAVA的基础知识不熟练，为此特别使用笔记来加强学习效果。

数组与内存控制

Java语言是静态语言，因此数组是静态的。
数组变量是引用类型的变量，初始化后才可以被使用，且长度不可变。（ps:js中的可变）
初始化分为：

1. 静态初始化 ：显式指定每一个元素的初始值，由系统决定长度；
   String[] a = new String[]{“a”;“b”;“c”};
2. 动态初始化 ：只指定数组长度，由系统为数据元素分配初始值。
   String[] b = new String[5];
   a,b为数组变量，其值是数据对象，变量在main栈区，对象在堆内存。
   数组变量并不是数据本身，它只是指相堆内存中的数组对象。

元素初始值：

1. 整数类型（byte、short、int、long）： 0；
2. 浮点类型（float、double）： 0.0；
3. 字符类型（char）： ‘\u0000’；
4. 布尔类型（boolean）： false；
5. 引用类型（类、接口和数组）： null。

注：不要同时使用静态和动态初始化。

对象与内存控制

Java内存管理分为：
内存分配：创建对象时，JVM为此在堆内存中分配空间。
内存回收：对象失去引用，变成垃圾时JVM回收清理。

变量

成员变量和局部变量
局部变量：
作用时间短，存储在栈内存。

1. 形参：方法签名中定义
2. 方法内：必须显示初始化
3. 代码块内：必须显示初始化

成员变量（Field）：

1. static修饰：静态变量/类变量 （属于类本身）
2. 没有static修饰：非静态变量/实例变量 （属于该类的实例对象）

注意：非法前向引用异常

//以下两种会产生异常
int a = b+1;
int b = 1;
static int a1 = b1 +1;
static int b1 = 1;
//下面是正常的
int a2 = b2+1;
static b2 = 1;

由此可以得出：类变量实在实例变量前初始化。
在同一个JVM中，每一个类只对应一个Class对象，但没一个类可以创建多个Java对象。

继承父子实例

注：应避免在父类的构造其中调用被子类重写过的方法。如果父类构造器调用了被子类重写的方法，且通过子类构造器来创建子类对象，调用 (不管是显式还是隐式）了这个父类构造器，就会导致子类的重写方法在子类构造器的所有 代码之前被执行，从而导致子类的重写方法访问不到子类的实例变量值的情形.

如果子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法， 系统将不可能把父类里的方法转移到子类中。对于实例变量则不存在这样的现象，即使子类 中定义了与父类完全同名的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。
因为继承成员变量和继承方法之间存在这样的差别，所以对于一个引用类型的变麗而 言，当通过该变量访问它所引用的对象的实例变里时，该实例变量的值取决于声明该变量 时类型；当通过该变量来调用它所引用的对象的方法时，该方法行为取决于它所实际引用 的对象的类型。

//实例变量：由声明的对象类型决定
//方法：由对象的实际类型决定
Base b = new Derived();//Base声明类型，Derived实际类型

super关键字
super本身并没有引用任何对象，它甚至不能被当成一个 真正的引用变量使用。主要有如下两个原因.
■ 子类方法不能直接使用return super;，但使用return this;返回调用该方法的对象是允 许的；.
■ 程序不允许直接把super当成变量使用，例如，试图判断super和a变量是否引用同 一个Java对象------super == a;但这条语句将引起编译错误。
至此，对父、子对象在内存中存储有了准确的结论：当程序创建一个子类对象时，系统 不仅会为该类中定义的实例变量分配内存，也会为其父类中定义的所有实例变量分配内存， 即使子类定义了与父类中同名实例变量。也就是说，当系统创建一个Java对象时候，如果该 Java类有两个父类（一个直接父类A, —个间接父类B),假设A类中定义了 2个实例变量， B类中定义了 3个实例变量，当前类中定义了 2个实例变量,那这个Java对象将会保存2+3+2 个实例变量。
如果在子类里定义了与父类中已有变量同名的变量，那么子类中定义的变量会隐藏父类 中定义的变量。注意不是完全覆盖，因此系统为创建子类对象时，依然会为父类中定义的、 被隐藏的变量分配内存空间。
为了在子类方法中访问父类中定义的、被隐藏的实例变量，或者为了在子类方法中调用父类 中定义的、被覆盖（Override)的方法，可以通过super.作为限定来修饰这些实例变量和实例 方法。
因为子类中定义与父类中同名的实例变量并不会完全覆盖父类中定义的实例变量，它只 是简单地隐藏了父类中的实例变量，所以会出现如下特殊的情形。

//通过子类获取对应的父类对象
//父类中建方法
public 父类型 getThis(){
	return this;
}
//子类中建方法
public 父类型 getSuper(){
	return super.getThis();
}

final修饰符

■ final可以修饰变量，被final修饰的变量被赋初始值之后，不能对它重新赋值。
■ final可以修饰方法，被final修饰的方法不能被重写。
■ final可以修饰类，被final修饰的类不能派生子类。

被final修饰的实例变量必须显式指定初始值， 而且只能在如下3个位置指定初始值。
■ 定义final实例变量时指定初始值；
■ 在非静态初始化块中为final实例变量指定初始值；
■ 在构造器中为final实例变量指定初始值。 （本质上都在此处指定）
对于普通实例变量，Java程序可以对它执行默认的初始化，也就是将实例变量的值指定 为默认的初始值0或null;但对于final实例变量，则必须由程序员显式指定初始值。
下面程序示范了在3个地方对final实例变量进行初始化

public class FinalInstanceVaribaleTest { 
    //定义final实例变量时赋初始值 
    final int var1 = "疯狂 Java 讲义".length();
    final int var2; 
    final int var3; 
    //在初始化块中为var2赋初始值 
    { 
    	var2 = "轻置级Java EE企业应用实战".length(); 
    }
    //在构造器中为var3赋初始值 
    public FinalInstanceVaribaleTest () { 
    	this. var3 = "疯狂 XML 讲义".length();
    } 
    public static void main(String[] args) { 
    	FinallnstanceVaribaleTest fiv = new FinallnstanceVaribaleTest(); 
    	System.out.println(fiv.var1); 
    	System.out.println(fiv.var2); 
    	System.out.println(fiv.var3);
    }
}

被final修饰的类变量必须显式指定初始值， 而且只能在如下2个位置指定初始值。
■ 定义final类变量时指定初始值；
■ 在静态初始化块中为final类变量指定初始值。（本质上都在此处指定）
下面程序示范了在2个地方对final类变量进行初始化

public class FinalClassVaribaleTest { 
    //定义final类变量时赋初始值 
    final static int var1 = "疯狂 Java 讲义".length();
    final static int var2; 
    //在静态初始化块中为var2赋初始值 
    static{ 
    	var2 = "轻置级Java EE企业应用实战".length(); 
    }
    public static void main(String[] args) { 
    	System.out.println(FinalClassVaribaleTest .var1); 
    	System.out.println(FinalClassVaribaleTest .var2); 
    }
}

final修饰符的一个重要用途就是定义“宏变量”。当定义final变量时就为该变量指定了初始值，而且该初始值可以在编译时就确定下来，那这个final变量本质上就是一个“宏变量”。初始值在编译时就确定了。编译器会把程序中所有用到该变量的地方直接替换成该变量的值。
“宏变量”的范围：
final变量赋值时赋直接量；
final变量被赋的表达式只是基本算数运算表达式或字符串连接运算，没有访问普通变量，调用方法；
注：
对于实例变量而言，只有在定义该变量时指定初始值才会有“宏替换”的效果，在非静态初始化块、构造器中为final实例变量指定初始值则不会有这种效果。
对类变量而言，只有在定义final类变量时执行指定初始值，系统才会对该final类变量执行“宏替换”。

 public class FinalInitTest{
   //下面定义了4个final“宏变量”
   final int a = 5 + 2;
   final double b = 1.2 / 3;
   final String str = "疯狂" + "JAVA";
   final String book = "疯狂JAVA讲义：" + 99.0;
   //下面的book2变量的值因为调用了方法，所以无法在编译时确定下来
   final String book2 = "疯狂JAVA讲义：" + String.valueOf(99.0);
   System.out.println(book == "疯狂JAVA讲义：99.0");//true
   System.out.println(book2 == "疯狂JAVA讲义：99.0");//false
   //定义3个final实例变量
   final String str1;
   final String str2;
   final String str3 = "JAVA";
   //str1、str2分别放在非静态代码块、构造器中初始化
   {
   		str1 = "JAVA";
   }
   public FinalInitTest(){
   		str2 = "JAVA";
   }
   //判断str1、str2、str3是否执行“宏变量”
   public void dispaly(){
   		System.out.println(str1 + str1 == "JAVAJAVA");//false
   		System.out.println(str2 + str2 == "JAVAJAVA");//false
   		System.out.println(str3 + str3 == "JAVAJAVA");//true
   }
   //定一2个final类变量
   final static String str4;
   final static String str5 = "Java";
   //将str4放在静态初始化快中初始化
   static{
   		str4 = "Java";
   }
   public void displayStatic(){
   		System.out.println(str4 + str4 == "JavaJava");//false
   		System.out.println(str5 + str5 == "JavaJava");//true
   }

 }

final方法不能被重写
子类是无法重写父类中的final方法的，但是有一种特殊情况，即是当父类中定义的final方法，子类中无法调用时，子类中可以存在与父类同名同参通返回的方法，但是此时不能算是“重写”。
父类中的final方法不被子类访问到的情况，举例说明：

1. private final void info(){} //private修饰，子类访问不到
2. final void info(){} //父类与子类没有处于同一个包下，父类中包含的某个方法不使用访问控制符（相当于包访问权限），子类也是无法重写的。

内部类中的局部变量
此处针对的情况是，内部类指的是局部内部类，因为只有局部内部类（包括匿名内部类）才可以访问局部变量，普通静态内部类、非静态内部类不可能访问方法体内的局部变量。

interface InArrayProductor{
	//接口里定义product方法用于封装“处理行为”
	int product();
}
public class CommandTest2{
	//定一一个方法生成指定长度的数组，但每一个数组元素由cmd负责产生
	public int[] process(InArrayProductor cmd,int length){
		int[] result = new int[length];
		for(int i = 0;i<length;i++){
			result[i] = cmd.product();
		}
		return result;
	}

	public static void main(String[] args){
		CommandTest2 ct = new CommandTest2();
		final int seed = 5;//这里必须添加final修饰
		//int[] result = ct.process(new IntArrayProductor(){
		//	public int product(){
		//		return (int)Math.round(Math.random() * seed);
		//	}
		//},6);
		class IntArrayProductorImpl implements IntArrayProductor{
			public int product(){
				return (int)Math.round(Math.random() * seed);
			}
		}
		//生成数组，具体生成方式取决于IntArrayProductor接口的匿名实现类
		int[] result = ct.process(new IntArrayProductorImpl(),6);
		System.out.println(Arrays.toString(result));
	}

}

注：Java要求所有被内部类访问的局部变量都使用final修饰也是有其原因的：对于普通局部变量而言，它的作用域就是停留在该方法内，当访法执行结束，该局部变量与随之消失；但内部类则可能产生隐式的“闭包（Closure）”，闭包将使得局部变量脱离他所在的方法继续存在。

public class ClosureTest{
	public ststic void main(String[] args){
		//定义一个局部变量
		final String str = "Java";
		//在内部类里访问局部变量str
		new Tread(new Runnable(){
			public void run(){
				for(int i = 0; i < 100; i++){
					//此处将一直可以访问到str局部变量
					System.out.println(str + " " +i);
					//暂停0.1秒
					try{
						Thread.sleep(100);
					}catch(Exception e){
						e.printStackTrace();
					}
				}
			}
		}).start();   // （1）
		//执行到此处，main方法结束
	}
}

正常情况下，当程序执行完（1）行代码之后，main方法的生命周期就结束了，局部变量str的作用与也随之结束。但实际上这个程序中只要新的线程里的run方法没有执行完，匿名内部类的实例的生命周期就没有结束，将一直可以访问str局部变量的值，这就是内部类会扩大局部变量作用域的实例。
由于内部类可能扩大局部变量的作用域，如果再加上这个被内部类访问的局部变量没有使用final修饰，也就是说该变量的值可以随意改变，那将引起极大的混乱，因此Java编译器要求所有被内部类访问的局部变量必须使用final修饰符修饰。