一、對象與內(nèi)存控制的知識點(diǎn)
1.java變量的初始化過程，包括局部變量，成員變量（實(shí)例變量和類變量）。
2.繼承關(guān)系中，當(dāng)使用的對象引用變量編譯時(shí)類型和運(yùn)行時(shí)類型不同時(shí)，訪問該對象的屬性和方法是有區(qū)別的。
3.final修飾符特性。
二、java變量的劃分與初始化過程
java程序的變量大體可以分為成員變量和局部變量，成員變量可以分為實(shí)例變量（非靜態(tài)變量）和類變量（靜態(tài)變量），一般我們遇到的局部變量會(huì)在下列幾種情況中出現(xiàn)：
（1）形參：在方法簽名中定義的局部變量，由調(diào)用方為其賦值，隨著方法結(jié)束消亡。
（2）方法內(nèi)的局部變量：在方法內(nèi)定義的局部變量必須在方法內(nèi)顯示的初始化（賦初始值），隨著變量初始化完成開始，到方法結(jié)束而消亡。
（3）代碼塊內(nèi)的局部變量：在代碼塊內(nèi)定義的局部變量必須在代碼塊內(nèi)顯示的初始化（賦初始值），隨著初始化完成開始生效，隨著代碼塊的結(jié)束而消亡。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package com.zlc.array; public class TestField { { String b ; //如果不初始化，編譯器就會(huì)報(bào)The local variable b may not have been initialized System.out.println(b); } public static void main(String[] args) { int a ; //如果不初始化，編譯器就會(huì)報(bào)The local variable a may not have been initialized System.out.println(a); }} |
使用static修飾的成員變量是類變量，屬于類本身，沒有用static修飾的成員變量是實(shí)例變量，屬于該類的實(shí)例，在同一個(gè)JVM里面，每個(gè)類只能對應(yīng)一個(gè)Class對象，但每個(gè)類可以創(chuàng)建多個(gè)java對象。（也就是說一個(gè)類變量只需一塊內(nèi)存空間，而該類每創(chuàng)建一次實(shí)例，就需要為實(shí)例變量分配一塊空間）
實(shí)例變量的初始化過程：從語法角度來說，程序可以在三個(gè)地方對實(shí)例變量執(zhí)行初始化：
（1）定義實(shí)例變量時(shí)指定初始值。
（2）非靜態(tài)塊中對實(shí)例變量指定初始值。
（3）構(gòu)造器中對實(shí)例變量指定初始值。
其中（1）和（2）這兩種方式初始化時(shí)間都比（3）在構(gòu)造器中要早，（1）和（2）兩種初始化順序是按照他們在源碼中的排列順序決定的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package com.zlc.array; public class TestField { public TestField(int age){ System.out.println("構(gòu)造函數(shù)中初始化 this.age = "+this.age); this.age = age; } { System.out.println("非靜態(tài)塊中初始化"); age = 22; } //定義的時(shí)候初始化 int age = 15; public static void main(String[] args) { TestField field = new TestField(24); System.out.println("最終 age = "+field.age); }} |
運(yùn)行結(jié)果為：非靜態(tài)塊中初始化
構(gòu)造函數(shù)中初始化 this.age = 15
最終 age = 24
如果會(huì)使用javap的話，可以通過javap -c XXXX（class文件）看下改java類是如何編譯的。
定義實(shí)例變量時(shí)指定初始值，初始化塊中為實(shí)例變量指定初始值語句地位是平等的，當(dāng)經(jīng)過編譯器編譯處理之后，他們都被提到構(gòu)造器中，上面所說的 int age = 15;會(huì)劃分下面兩個(gè)步驟執(zhí)行：
1）int age;創(chuàng)建java對象時(shí)系統(tǒng)根據(jù)該語句為該對象分配內(nèi)存。
2）age = 15;這條語句會(huì)被提取到j(luò)ava類的構(gòu)造器中執(zhí)行。
類變量的初始化過程：從語法角度來說，程序可以從兩個(gè)地方對類變量進(jìn)行初始化賦值。
（1）定義類變量時(shí)指定初始值。
（2）靜態(tài)塊中對類變量指定初始值。
兩種執(zhí)行順序和他們在源碼中的排列順序相同，我們舉個(gè)小變態(tài)的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.zlc.array; class TestStatic { //類成員 DEMO TestStatic實(shí)例 final static TestStatic DEMO = new TestStatic(15); //類成員 age static int age = 20; //實(shí)例變量 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); }} |
輸出結(jié)果有兩行打印，一個(gè)是打印TestStatic類屬性DEMO的實(shí)例變量，第二個(gè)通過java對象staticDemo輸出TestStatic的實(shí)例屬性，根據(jù)我們上面分析的實(shí)例變量和類變量的初始化流程可以進(jìn)行推斷：
1）初始化第一階段，加載類的時(shí)候?yàn)轭愖兞緿EMO、age分配內(nèi)存空間，此時(shí)DEMO和age的默認(rèn)值分別是null和0。
2）初始化第二階段，程序按順序依次給DEMO、age賦初始值，TestStatic(15)需要調(diào)用TestStatic的構(gòu)造器，此時(shí)age = 0 所以打印結(jié)果為 -15，而當(dāng)staticDemo被初始化的時(shí)候，age已經(jīng)被賦值等于20了，所以輸出結(jié)果為5。
三、在繼承關(guān)系中繼承成員變量和繼承成員方法的區(qū)別
當(dāng)創(chuàng)建任何java對象時(shí)，程序總會(huì)先調(diào)用父類的非靜態(tài)塊、父類構(gòu)造器，最后才調(diào)用本類的非靜態(tài)塊和構(gòu)造器。通過子類的構(gòu)造器調(diào)用父類的構(gòu)造器一般分為兩種情況，一個(gè)是隱式調(diào)用，一個(gè)通過super顯示調(diào)用父類的構(gòu)造器。
子類的方法可以調(diào)用父類的實(shí)例變量，這是因?yàn)樽宇惱^承了父類就會(huì)獲取父類的成員變量和方法，但父類的方法不能訪問子類的實(shí)例變量，因?yàn)楦割惒恢浪鼘⒈荒膫€(gè)類繼承，它的子類將會(huì)增加什么樣的成員變量，當(dāng)然在一些極端的例子里面還是可以實(shí)現(xiàn)父類調(diào)用子類變量的，比如：子類重寫了父類的方法，一般都會(huì)打印出默認(rèn)值，因?yàn)檫@個(gè)時(shí)候子類的實(shí)例變量還沒有初始化。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
package com.zlc.array;class Father{ int age = 50; public Father() { // TODO Auto-generated constructor stub System.out.println(this.getClass()); //this.sonMethod();無法調(diào)用 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"); }} |
按照我們正常推斷，通過子類隱式的調(diào)用父類的構(gòu)造器，而在父類的構(gòu)造器中調(diào)用了info()方法（注意：我這里沒有說調(diào)用父類的），按道理來說是輸出了父類的age實(shí)例變量，打印結(jié)果預(yù)計(jì)是50，但實(shí)際輸出的結(jié)果為0，分析原因：
1）java對象的內(nèi)存分配不是在構(gòu)造器中完成的，構(gòu)造器只是完成了初始化賦值的過程，也就是在調(diào)用父類的構(gòu)造器之前，jvm已經(jīng)給這個(gè)Son對象分類好了內(nèi)存空間，這個(gè)空間存放了兩個(gè)age屬性，一個(gè)是子類的age，一個(gè)是父類的age。
2）在調(diào)用new Son(28)的時(shí)候，當(dāng)前的this對象代表著是子類Son的對象，我們可以通過把對象.getClass()打印出來就會(huì)得到class com.zlc.array.Son的結(jié)果，但是當(dāng)前初始化過程又是在父類的構(gòu)造器中進(jìn)行的，通過this.sonMethod()又無法被調(diào)用，這是因?yàn)閠his的編譯類型是Father的緣故。
3）在變量的編譯時(shí)類型和運(yùn)行時(shí)類型不同時(shí)，通過該變量訪問它的引用對象的實(shí)例變量時(shí)，該實(shí)例變量的值由聲明該變量的類型決定，但通過該變量調(diào)用它引用的對象的實(shí)例方法時(shí)，該方法的行為由它實(shí)際引用的對象決定，所以這里調(diào)用的是子類的info方法，所以打印的是子類的age,由于age還沒來得急初始化所以打印默認(rèn)值0。
通俗的來說也就是，當(dāng)聲明的類型和真正new的類型不一致的時(shí)候，使用的屬性是父類的，調(diào)用的方法是子類的。
通過javap -c我們更能直接的體會(huì)為什么繼承屬性和方法會(huì)有很大的區(qū)別，如果我們把上面例子里面，子類Son的info重寫方法去掉，這個(gè)時(shí)候調(diào)用的會(huì)是父類的info方法，是因?yàn)樵谶M(jìn)行編譯的時(shí)候會(huì)把父類的info方法編譯轉(zhuǎn)移到子類里面去，而聲名的成員變量會(huì)留在父類中不進(jìn)行轉(zhuǎn)移，這樣子類和父類擁有了同名的實(shí)例變量，而如果子類重寫了父類的同名方法，則子類的方法會(huì)完全覆蓋掉父類的方法（至于為什么java要這么設(shè)計(jì)，個(gè)人也不太清楚）。同名變量能同時(shí)存在不覆蓋，同名方法子類會(huì)徹底覆蓋父類同名方法。
總的來說對于一個(gè)引用變量而言，當(dāng)通過該變量訪問它所引用的對象的實(shí)例變量時(shí)，該實(shí)例變量的值取決于聲明該變量時(shí)類型，當(dāng)通過該變量訪問它所引用的對象的方法時(shí)，該方法行為取決于它所實(shí)際引用的對象的類型。
最后拿個(gè)小case復(fù)習(xí)下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
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(); }} |
想要調(diào)用父類的方法：可以通過super來調(diào)用，但super關(guān)鍵字沒有引用任何對象，它不能當(dāng)做真正的引用變量來使用，有興趣的朋友可以自己研究下。
上面介紹的都是實(shí)例變量和方法，類變量和類方法要簡單多了，直接使用類名.方法就方便了很多，也不會(huì)遇到那么多麻煩。
四、final修飾符的使用（特別是宏替換）
（1）inal可以修飾變量，被final修飾的變量被賦初始值之后，不能對他重新賦值。
（2）inal可以修飾方法，被final修飾的方法不能被重寫。
（3）inal可以修飾類，被final修飾的類不能派生子類。
被final修飾的變量必須顯示的指定初始值：
對于是final修飾的是實(shí)例變量，則只能在下列三個(gè)指定位置賦初始值。
（1）定義final實(shí)例變量時(shí)指定初始值。
（2）在非靜態(tài)塊中為final實(shí)例變量指定初始值。
（3）在構(gòu)造器中為final實(shí)例變量指定初始值。
最終都會(huì)被提到構(gòu)造器中進(jìn)行初始化。
對于用final指定的類變量：只能在指定的兩個(gè)地方進(jìn)行賦初始值。
（1）定義final類變量的時(shí)候指定初始值。
（2）在靜態(tài)塊中為final類變量指定初始值。
同樣經(jīng)過編譯器處理，不同于實(shí)例變量的是，類變量都是提到靜態(tài)塊中進(jìn)行賦初始值，而實(shí)例變量是提到構(gòu)造器中完成。
被final修飾的類變量還有一種特性，就是“宏替換”，當(dāng)被修飾的類變量滿足在定義該變量的時(shí)候就指定初始值，而且這個(gè)初始值在編譯的時(shí)候就能確定下來（比如：18、"aaaa"、16.78等一些直接量），那么該final修飾的類變量不在是一個(gè)變量，系統(tǒng)就會(huì)當(dāng)成“宏變量”處理（就是我們常說的常量），如果在編譯的時(shí)候就能確定初始值，則就不會(huì)被提到靜態(tài)塊中進(jìn)行初始化了，直接在類定義中直接使該初始值代替掉final變量。我們還是舉那個(gè)年齡減去year的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.zlc.array; class TestStatic { //類成員 DEMO TestStatic實(shí)例 final static TestStatic DEMO = new TestStatic(15); //類成員 age final static int age = 20; //實(shí)例變量 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); }} |
這個(gè)時(shí)候的age 被final修飾了，所以在編譯的時(shí)候，父類中所有的age都變成了20，而不是一個(gè)變量，這樣輸出的結(jié)果就能達(dá)到我們的預(yù)期。
特別是在對字符串進(jìn)行比較的時(shí)候更能顯示出
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
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 或者不加都行 前面兩個(gè)能被宏替換就行了 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修飾方法和類沒有什么好說的，只是一個(gè)不能被子類重寫（和private一樣），一個(gè)不能派生子類。
用final修飾局部變量的時(shí)候，Java要求被內(nèi)部類訪問的局部變量都是用final修飾，這個(gè)是有原因的，對于普通局部變量而言，它的作用域就停留在該方法內(nèi)，當(dāng)方法結(jié)束時(shí)，該局部變量也就消失了，但內(nèi)部類可能產(chǎn)生隱式的“閉包”，閉包使得局部變量脫離他所在的方法繼續(xù)存在。
有時(shí)候在會(huì)在一個(gè)方法里面new 一個(gè)線程，然后調(diào)用該方法的局部變量，這個(gè)時(shí)候需要把改變量聲明為final修飾的。
五、對象占用內(nèi)存的計(jì)算方法
使用system.gc()和java.lang.Runtime類中的freeMemory(),totalMemory(),maxMemory()這幾個(gè)方法測量Java對象的大小。這種方法通常使用在需要對很多資源進(jìn)行精確確定對象的大小。這種方法幾乎無用等生產(chǎn)系統(tǒng)緩存的實(shí)現(xiàn)。這種方法的優(yōu)點(diǎn)是數(shù)據(jù)類型大小無關(guān)的，不同的操作系統(tǒng)，都可以得到占用的內(nèi)存。
它使用反射API用于遍歷對象的成員變量的層次結(jié)構(gòu)和計(jì)算所有原始變量的大小。這種方法不需要如此多的資源，可用于緩存的實(shí)現(xiàn)。缺點(diǎn)是原始類型大小是不同的不同的JVM實(shí)現(xiàn)對應(yīng)有不同的計(jì)算方法。
JDK5.0之后Instrumentation API提供了 getObjectSize方法來計(jì)算對象占用的內(nèi)存大小。
默認(rèn)情況下并沒有計(jì)算到引用對象的大小，為了計(jì)算引用對象，可以使用反射獲取。下面這個(gè)方法是上面文章里面提供的一個(gè)計(jì)算包含引用對象大小的實(shí)現(xiàn)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
public class SizeOfAgent { static Instrumentation inst; /** initializes agent */ public static void premain(String agentArgs, Instrumentation instP) { inst = instP; } /** * Returns object size without member sub-objects. * @param o object to get size of * @return object size */ public static long sizeOf(Object o) { if(inst == null) { throw new IllegalStateException("Can not access instrumentation environment.\n" + "Please check if jar file containing SizeOfAgent class is \n" + "specified in the java's \"-javaagent\" command line argument."); } return inst.getObjectSize(o); } /** * Calculates full size of object iterating over * its hierarchy graph. * @param obj object to calculate size of * @return object size */ public static long fullSizeOf(Object obj) { Map<Object, Object> visited = new IdentityHashMap<Object, Object>(); Stack<Object> stack = new Stack<Object>(); long result = internalSizeOf(obj, stack, visited); while (!stack.isEmpty()) { result += internalSizeOf(stack.pop(), stack, visited); } visited.clear(); return result; } private static boolean skipObject(Object obj, Map<Object, Object> visited) { if (obj instanceof String) { // skip interned string if (obj == ((String) obj).intern()) { return true; } } return (obj == null) // skip visited object || visited.containsKey(obj); } private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited) { if (skipObject(obj, visited)){ return 0; } visited.put(obj, null); long result = 0; // get size of object + primitive variables + member pointers result += SizeOfAgent.sizeOf(obj); // process all array elements Class clazz = obj.getClass(); if (clazz.isArray()) { if(clazz.getName().length() != 2) {// skip primitive type array int length = Array.getLength(obj); for (int i = 0; i < length; i++) { stack.add(Array.get(obj, i)); } } return result; } // process all fields of the object while (clazz != null) { Field[] fields = clazz.getDeclaredFields(); for (int i = 0; i < fields.length; i++) { if (!Modifier.isStatic(fields[i].getModifiers())) { if (fields[i].getType().isPrimitive()) { continue; // skip primitive fields } else { fields[i].setAccessible(true); try { // objects to be estimated are put to stack Object objectToAdd = fields[i].get(obj); if (objectToAdd != null) { stack.add(objectToAdd); } } catch (IllegalAccessException ex) { assert false; } } } } clazz = clazz.getSuperclass(); } return result; }} |
