java对象和内存的控制深入浅出

一、对象与内存控制的知识点

1.java变量的初始化过程，包括局部变量，成员变量（实例变量和类变量）。
2.继承关系中，当使用的对象引用变量编译时类型和运行时类型不同时，访问该对象的属性和方法是有区别的。
3.final修饰符特性。

二、java变量的划分与初始化过程

     java程序的变量大体可以分为成员变量和局部变量，成员变量可以分为实例变量（非静态变量）和类变量（静态变量），一般我们遇到的局部变量会在下列几种情况中出现：
     （1）形参：在方法签名中定义的局部变量，由调用方为其赋值，随着方法结束消亡。
     （2）方法内的局部变量：在方法内定义的局部变量必须在方法内显示的初始化（赋初始值），随着变量初始化完成开始，到方法结束而消亡。
     （3）代码块内的局部变量：在代码块内定义的局部变量必须在代码块内显示的初始化（赋初始值），随着初始化完成开始生效，随着代码块的结束而消亡。

package com.zlc.array;

public class TestField {
	{
		String b ;
		//如果不初始化，编译器就会报The local variable b may not have been initialized
		System.out.println(b);
	}
	public static void main(String[] args) {
		int a ;
		//如果不初始化，编译器就会报The local variable a may not have been initialized
		System.out.println(a);
	}
}

    使用static修饰的成员变量是类变量，属于类本身，没有用static修饰的成员变量是实例变量，属于该类的实例，在同一个JVM里面，每个类只能对应一个Class对象，但每个类可以创建多个java对象。（也就是说一个类变量只需一块内存空间，而该类每创建一次实例，就需要为实例变量分配一块空间）
   
     实例变量的初始化过程：从语法角度来说，程序可以在三个地方对实例变量执行初始化：
   （1）定义实例变量时指定初始值。
   （2）非静态块中对实例变量指定初始值。
   （3）构造器中对实例变量指定初始值。
    其中（1）和（2）这两种方式初始化时间都比（3）在构造器中要早，（1）和（2）两种初始化顺序是按照他们在源码中的排列顺序决定的。
   

package com.zlc.array;

public class TestField {
	public TestField(int age){
		System.out.println("构造函数中初始化 this.age = "+this.age);
		this.age = age;
	}
	{
		System.out.println("非静态块中初始化");
		age = 22;
	}
	//定义的时候初始化
	int age = 15;
	public static void main(String[] args) {
		TestField field = new TestField(24);
		System.out.println("最终 age = "+field.age);
	}
}

    运行结果为：非静态块中初始化
                     构造函数中初始化 this.age = 15
                     最终 age = 24
    如果会使用javap的话，可以通过javap -c XXXX（class文件）看下改java类是如何编译的。
    定义实例变量时指定初始值，初始化块中为实例变量指定初始值语句地位是平等的，当经过编译器编译处理之后，他们都被提到构造器中，上面所说的 int age = 15;会划分下面两个步骤执行：
    1）int age;创建java对象时系统根据该语句为该对象分配内存。
    2）age = 15;这条语句会被提取到java类的构造器中执行。
   
    类变量的初始化过程：从语法角度来说，程序可以从两个地方对类变量进行初始化赋值。
   （1）定义类变量时指定初始值。
   （2）静态块中对类变量指定初始值。
    两种执行顺序和他们在源码中的排列顺序相同，我们举个小变态的例子：

package com.zlc.array;

 class TestStatic {
	//类成员 DEMO TestStatic实例
	final static TestStatic DEMO = new TestStatic(15);
	//类成员 age
	static int age = 20;
	//实例变量 curAge
	int curAge;
	
	public TestStatic(int years) {
		// TODO Auto-generated constructor stub
		curAge = age - years;
	}
}
 public class Test{
	public static void main(String[] args) {
		System.out.println(TestStatic.DEMO.curAge);
		TestStatic staticDemo = new TestStatic(15);
		System.out.println(staticDemo.curAge);
	}
}

    输出结果有两行打印，一个是打印TestStatic类属性DEMO的实例变量，第二个通过java对象staticDemo输出TestStatic的实例属性，根据我们上面分析的实例变量和类变量的初始化流程可以进行推断：
    1）初始化第一阶段，加载类的时候为类变量DEMO、age分配内存空间，此时DEMO和age的默认值分别是null和0。

   2）初始化第二阶段，程序按顺序依次给DEMO、age赋初始值，TestStatic(15)需要调用TestStatic的构造器，此时age = 0 所以打印结果为 -15，而当staticDemo被初始化的时候，age已经被赋值等于20了，所以输出结果为5。

三、在继承关系中继承成员变量和继承成员方法的区别。

    当创建任何java对象时，程序总会先调用父类的非静态块、父类构造器，最后才调用本类的非静态块和构造器。通过子类的构造器调用父类的构造器一般分为两种情况，一个是隐式调用，一个通过super显示调用父类的构造器。
    子类的方法可以调用父类的实例变量，这是因为子类继承了父类就会获取父类的成员变量和方法，但父类的方法不能访问子类的实例变量，因为父类不知道它将被哪个类继承，它的子类将会增加什么样的成员变量，当然在一些极端的例子里面还是可以实现父类调用子类变量的，比如：子类重写了父类的方法，一般都会打印出默认值，因为这个时候子类的实例变量还没有初始化。

package com.zlc.array;
class Father{
	int age = 50;
	public Father() {
		// TODO Auto-generated constructor stub
                System.out.println(this.getClass());
                //this.sonMethod();无法调用
		info();
	}
	public void info(){
		System.out.println(age);
	}
}
public class Son extends Father{
	int age = 24;
	public Son(int age) {
		// TODO Auto-generated constructor stub
		this.age = age;
	}
	@Override
	public void info() {
		// TODO Auto-generated method stub
		System.err.println(age);
	}
	public static void main(String[] args) {
		new Son(28);
	}
        //子类特有的方法
        public void sonMethod(){
                 System.out.println("Son method");
        }
}

    按照我们正常推断，通过子类隐式的调用父类的构造器，而在父类的构造器中调用了info()方法（注意：我这里没有说调用父类的），按道理来说是输出了父类的age实例变量，打印结果预计是50，但实际输出的结果为0，分析原因：
   1）java对象的内存分配不是在构造器中完成的，构造器只是完成了初始化赋值的过程，也就是在调用父类的构造器之前，jvm已经给这个Son对象分类好了内存空间，这个空间存放了两个age属性，一个是子类的age，一个是父类的age。
   2）在调用new Son(28)的时候，当前的this对象代表着是子类Son的对象，我们可以通过把对象.getClass()打印出来就会得到class com.zlc.array.Son的结果，但是当前初始化过程又是在父类的构造器中进行的，通过this.sonMethod()又无法被调用，这是因为this的编译类型是Father的缘故。

   3）在变量的编译时类型和运行时类型不同时，通过该变量访问它的引用对象的实例变量时，该实例变量的值由声明该变量的类型决定，但通过该变量调用它引用的对象的实例方法时，该方法的行为由它实际引用的对象决定，所以这里调用的是子类的info方法，所以打印的是子类的age,由于age还没来得急初始化所以打印默认值0。
    通俗的来说也就是，当声明的类型和真正new的类型不一致的时候，使用的属性是父类的，调用的方法是子类的。
    通过javap -c我们更能直接的体会为什么继承属性和方法会有很大的区别，如果我们把上面例子里面，子类Son的info重写方法去掉，这个时候调用的会是父类的info方法，是因为在进行编译的时候会把父类的info方法编译转移到子类里面去，而声名的成员变量会留在父类中不进行转移，这样子类和父类拥有了同名的实例变量，而如果子类重写了父类的同名方法，则子类的方法会完全覆盖掉父类的方法（至于为什么java要这么设计，个人也不太清楚）。同名变量能同时存在不覆盖，同名方法子类会彻底覆盖父类同名方法。
    总的来说对于一个引用变量而言，当通过该变量访问它所引用的对象的实例变量时，该实例变量的值取决于声明该变量时类型，当通过该变量访问它所引用的对象的方法时，该方法行为取决于它所实际引用的对象的类型。
最后拿个小case复习下：

package com.zlc.array;
class Animal{
	int age ;
	public Animal(){
		
	}
	public Animal(int age) {
		// TODO Auto-generated constructor stub
		this.age = age;
	}
	void run(){
		System.out.println("animal run "+age);
	}
}
class Dog extends Animal{
	int age;
	String name;
	public Dog(int age,String name) {
		// TODO Auto-generated constructor stub
		this.age = age;
		this.name = name;
	}
	@Override
	void run(){
		System.out.println("dog run "+age);
	}
}
public class TestExtends {
	public static void main(String[] args) {
		Animal animal = new Animal(5);
		System.out.println(animal.age);
		animal.run();
		
		Dog dog = new Dog(1, "xiaobai");
		System.out.println(dog.age);
		dog.run();
		
		Animal animal2 = new Dog(11, "wangcai");
		System.out.println(animal2.age);
		animal2.run();
		
		Animal animal3;
		animal3 = dog;
		System.out.println(animal3.age);
		animal3.run();
	}
}

     想要调用父类的方法：可以通过super来调用，但super关键字没有引用任何对象，它不能当做真正的引用变量来使用，有兴趣的朋友可以自己研究下。
     上面介绍的都是实例变量和方法，类变量和类方法要简单多了，直接使用类名.方法就方便了很多，也不会遇到那么多麻烦。

四、final修饰符的使用（特别是宏替换）

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

被final修饰的变量必须显示的指定初始值：
对于是final修饰的是实例变量，则只能在下列三个指定位置赋初始值。
    （1）定义final实例变量时指定初始值。
    （2）在非静态块中为final实例变量指定初始值。
    （3）在构造器中为final实例变量指定初始值。
     最终都会被提到构造器中进行初始化。
对于用final指定的类变量：只能在指定的两个地方进行赋初始值。
    （1）定义final类变量的时候指定初始值。
    （2）在静态块中为final类变量指定初始值。
     同样经过编译器处理，不同于实例变量的是，类变量都是提到静态块中进行赋初始值，而实例变量是提到构造器中完成。
    被final修饰的类变量还有一种特性，就是“宏替换”，当被修饰的类变量满足在定义该变量的时候就指定初始值，而且这个初始值在编译的时候就能确定下来（比如：18、"aaaa"、16.78等一些直接量），那么该final修饰的类变量不在是一个变量，系统就会当成“宏变量”处理（就是我们常说的常量），如果在编译的时候就能确定初始值，则就不会被提到静态块中进行初始化了，直接在类定义中直接使该初始值代替掉final变量。我们还是举那个年龄减去year的例子：

package com.zlc.array;

 class TestStatic {
	//类成员 DEMO TestStatic实例
	final static TestStatic DEMO = new TestStatic(15);
	//类成员 age
	final static int age = 20;
	//实例变量 curAge
	int curAge;
	
	public TestStatic(int years) {
		// TODO Auto-generated constructor stub
		curAge = age - years;
	}
}
 public class Test{
	public static void main(String[] args) {
		System.out.println(TestStatic.DEMO.curAge);
		TestStatic static1 = new TestStatic(15);
		System.out.println(static1.curAge);
	}
}

    这个时候的age 被final修饰了，所以在编译的时候，父类中所有的age都变成了20，而不是一个变量，这样输出的结果就能达到我们的预期。
    特别是在对字符串进行比较的时候更能显示出

package com.zlc.array;

public class TestString {
	static String static_name1 = "java";
	static String static_name2 = "me";
	static String statci_name3 = static_name1+static_name2;
	
	final static String final_static_name1 = "java";
	final static String final_static_name2 = "me";
	//加final 或者不加都行 前面兩個能被宏替換就行了
	final static String final_statci_name3 = final_static_name1+final_static_name2;
	
	public static void main(String[] args) {
		String name1 = "java";
		String name2 = "me";
		String name3 = name1+name2;
		//(1)
		System.out.println(name3 == "javame");
		//(2)
		System.out.println(TestString.statci_name3 == "javame");
		//(3)
		System.out.println(TestString.final_statci_name3 == "javame");
	}
}

    用final修饰方法和类没有什么好说的，只是一个不能被子类重写（和private一样），一个不能派生子类。
    用final修饰局部变量的时候，Java要求被内部类访问的局部变量都是用final修饰，这个是有原因的，对于普通局部变量而言，它的作用域就停留在该方法内，当方法结束时，该局部变量也就消失了，但内部类可能产生隐式的“闭包”，闭包使得局部变量脱离他所在的方法继续存在。
     有时候在会在一个方法里面new 一个线程，然后调用该方法的局部变量，这个时候需要把改变量声明为final修饰的。