解析Java程序中對象內(nèi)存的分配和控制的基本方法
一、對象與內(nèi)存控制的知識點
1.java變量的初始化過程，包括局部變量，成員變量（實例變量和類變量）。
2.繼承關(guān)系中，當(dāng)使用的對象引用變量編譯時類型和運行時類型不同時，訪問該對象的屬性和方法是有區(qū)別的。
3.final修飾符特性。
二、java變量的劃分與初始化過程
java程序的變量大體可以分為成員變量和局部變量，成員變量可以分為實例變量（非靜態(tài)變量）和類變量（靜態(tài)變量），一般我們遇到的局部變量會在下列幾種情況中出現(xiàn)：
（1）形參：在方法簽名中定義的局部變量，由調(diào)用方為其賦值，隨著方法結(jié)束消亡。
（2）方法內(nèi)的局部變量：在方法內(nèi)定義的局部變量必須在方法內(nèi)顯示的初始化（賦初始值），隨著變量初始化完成開始，到方法結(jié)束而消亡。
（3）代碼塊內(nèi)的局部變量：在代碼塊內(nèi)定義的局部變量必須在代碼塊內(nèi)顯示的初始化（賦初始值），隨著初始化完成開始生效，隨著代碼塊的結(jié)束而消亡。
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里面，每個類只能對應(yīng)一個Class對象，但每個類可以創(chuàng)建多個java對象。（也就是說一個類變量只需一塊內(nèi)存空間，而該類每創(chuàng)建一次實例，就需要為實例變量分配一塊空間）
實例變量的初始化過程：從語法角度來說，程序可以在三個地方對實例變量執(zhí)行初始化：
（1）定義實例變量時指定初始值。
（2）非靜態(tài)塊中對實例變量指定初始值。
（3）構(gòu)造器中對實例變量指定初始值。
其中（1）和（2）這兩種方式初始化時間都比（3）在構(gòu)造器中要早，（1）和（2）兩種初始化順序是按照他們在源碼中的排列順序決定的。
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;
}
//定義的時候初始化
int age = 15;
public static void main(String[] args) {
TestField field = new TestField(24);
System.out.println("最終 age = "+field.age);
}
}
運行結(jié)果為：非靜態(tài)塊中初始化
構(gòu)造函數(shù)中初始化 this.age = 15
最終 age = 24
如果會使用javap的話，可以通過javap -c XXXX（class文件）看下改java類是如何編譯的。
定義實例變量時指定初始值，初始化塊中為實例變量指定初始值語句地位是平等的，當(dāng)經(jīng)過編譯器編譯處理之后，他們都被提到構(gòu)造器中，上面所說的 int age = 15;會劃分下面兩個步驟執(zhí)行：
1）int age;創(chuàng)建java對象時系統(tǒng)根據(jù)該語句為該對象分配內(nèi)存。
2）age = 15;這條語句會被提取到j(luò)ava類的構(gòu)造器中執(zhí)行。
類變量的初始化過程：從語法角度來說，程序可以從兩個地方對類變量進行初始化賦值。
（1）定義類變量時指定初始值。
（2）靜態(tài)塊中對類變量指定初始值。
兩種執(zhí)行順序和他們在源碼中的排列順序相同，我們舉個小變態(tài)的例子：
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);
}
}
輸出結(jié)果有兩行打印，一個是打印TestStatic類屬性DEMO的實例變量，第二個通過java對象staticDemo輸出TestStatic的實例屬性，根據(jù)我們上面分析的實例變量和類變量的初始化流程可以進行推斷：
1）初始化第一階段，加載類的時候為類變量DEMO、age分配內(nèi)存空間，此時DEMO和age的默認(rèn)值分別是null和0。
2）初始化第二階段，程序按順序依次給DEMO、age賦初始值，TestStatic(15)需要調(diào)用TestStatic的構(gòu)造器，此時age = 0 所以打印結(jié)果為 -15，而當(dāng)staticDemo被初始化的時候，age已經(jīng)被賦值等于20了，所以輸出結(jié)果為5。
三、在繼承關(guān)系中繼承成員變量和繼承成員方法的區(qū)別
當(dāng)創(chuàng)建任何java對象時，程序總會先調(diào)用父類的非靜態(tài)塊、父類構(gòu)造器，最后才調(diào)用本類的非靜態(tài)塊和構(gòu)造器。通過子類的構(gòu)造器調(diào)用父類的構(gòu)造器一般分為兩種情況，一個是隱式調(diào)用，一個通過super顯示調(diào)用父類的構(gòu)造器。
子類的方法可以調(diào)用父類的實例變量，這是因為子類繼承了父類就會獲取父類的成員變量和方法，但父類的方法不能訪問子類的實例變量，因為父類不知道它將被哪個類繼承，它的子類將會增加什么樣的成員變量，當(dāng)然在一些極端的例子里面還是可以實現(xiàn)父類調(diào)用子類變量的，比如：子類重寫了父類的方法，一般都會打印出默認(rèn)值，因為這個時候子類的實例變量還沒有初始化。
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實例變量，打印結(jié)果預(yù)計是50，但實際輸出的結(jié)果為0，分析原因：
1）java對象的內(nèi)存分配不是在構(gòu)造器中完成的，構(gòu)造器只是完成了初始化賦值的過程，也就是在調(diào)用父類的構(gòu)造器之前，jvm已經(jīng)給這個Son對象分類好了內(nèi)存空間，這個空間存放了兩個age屬性，一個是子類的age，一個是父類的age。
2）在調(diào)用new Son(28)的時候，當(dāng)前的this對象代表著是子類Son的對象，我們可以通過把對象.getClass()打印出來就會得到class com.zlc.array.Son的結(jié)果，但是當(dāng)前初始化過程又是在父類的構(gòu)造器中進行的，通過this.sonMethod()又無法被調(diào)用，這是因為this的編譯類型是Father的緣故。
3）在變量的編譯時類型和運行時類型不同時，通過該變量訪問它的引用對象的實例變量時，該實例變量的值由聲明該變量的類型決定，但通過該變量調(diào)用它引用的對象的實例方法時，該方法的行為由它實際引用的對象決定，所以這里調(diào)用的是子類的info方法，所以打印的是子類的age,由于age還沒來得急初始化所以打印默認(rèn)值0。
通俗的來說也就是，當(dāng)聲明的類型和真正new的類型不一致的時候，使用的屬性是父類的，調(diào)用的方法是子類的。
通過javap -c我們更能直接的體會為什么繼承屬性和方法會有很大的區(qū)別，如果我們把上面例子里面，子類Son的info重寫方法去掉，這個時候調(diào)用的會是父類的info方法，是因為在進行編譯的時候會把父類的info方法編譯轉(zhuǎn)移到子類里面去，而聲名的成員變量會留在父類中不進行轉(zhuǎn)移，這樣子類和父類擁有了同名的實例變量，而如果子類重寫了父類的同名方法，則子類的方法會完全覆蓋掉父類的方法（至于為什么java要這么設(shè)計，個人也不太清楚）。同名變量能同時存在不覆蓋，同名方法子類會徹底覆蓋父類同名方法。
總的來說對于一個引用變量而言，當(dāng)通過該變量訪問它所引用的對象的實例變量時，該實例變量的值取決于聲明該變量時類型，當(dāng)通過該變量訪問它所引用的對象的方法時，該方法行為取決于它所實際引用的對象的類型。
最后拿個小case復(fù)習(xí)下：
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)做真正的引用變量來使用，有興趣的朋友可以自己研究下。
上面介紹的都是實例變量和方法，類變量和類方法要簡單多了，直接使用類名.方法就方便了很多，也不會遇到那么多麻煩。
四、final修飾符的使用（特別是宏替換）
（1）inal可以修飾變量，被final修飾的變量被賦初始值之后，不能對他重新賦值。
（2）inal可以修飾方法，被final修飾的方法不能被重寫。
（3）inal可以修飾類，被final修飾的類不能派生子類。
被final修飾的變量必須顯示的指定初始值：
對于是final修飾的是實例變量，則只能在下列三個指定位置賦初始值。
（1）定義final實例變量時指定初始值。
（2）在非靜態(tài)塊中為final實例變量指定初始值。
（3）在構(gòu)造器中為final實例變量指定初始值。
最終都會被提到構(gòu)造器中進行初始化。
對于用final指定的類變量：只能在指定的兩個地方進行賦初始值。
（1）定義final類變量的時候指定初始值。
（2）在靜態(tài)塊中為final類變量指定初始值。
同樣經(jīng)過編譯器處理，不同于實例變量的是，類變量都是提到靜態(tài)塊中進行賦初始值，而實例變量是提到構(gòu)造器中完成。
被final修飾的類變量還有一種特性，就是“宏替換”，當(dāng)被修飾的類變量滿足在定義該變量的時候就指定初始值，而且這個初始值在編譯的時候就能確定下來（比如：18、"aaaa"、16.78等一些直接量），那么該final修飾的類變量不在是一個變量，系統(tǒng)就會當(dāng)成“宏變量”處理（就是我們常說的常量），如果在編譯的時候就能確定初始值，則就不會被提到靜態(tài)塊中進行初始化了，直接在類定義中直接使該初始值代替掉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，而不是一個變量，這樣輸出的結(jié)果就能達到我們的預(yù)期。
特別是在對字符串進行比較的時候更能顯示出
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要求被內(nèi)部類訪問的局部變量都是用final修飾，這個是有原因的，對于普通局部變量而言，它的作用域就停留在該方法內(nèi)，當(dāng)方法結(jié)束時，該局部變量也就消失了，但內(nèi)部類可能產(chǎn)生隱式的“閉包”，閉包使得局部變量脫離他所在的方法繼續(xù)存在。
有時候在會在一個方法里面new 一個線程，然后調(diào)用該方法的局部變量，這個時候需要把改變量聲明為final修飾的。
五、對象占用內(nèi)存的計算方法
使用system.gc()和java.lang.Runtime類中的freeMemory(),totalMemory(),maxMemory()這幾個方法測量Java對象的大小。這種方法通常使用在需要對很多資源進行精確確定對象的大小。這種方法幾乎無用等生產(chǎn)系統(tǒng)緩存的實現(xiàn)。這種方法的優(yōu)點是數(shù)據(jù)類型大小無關(guān)的，不同的操作系統(tǒng)，都可以得到占用的內(nèi)存。
它使用反射API用于遍歷對象的成員變量的層次結(jié)構(gòu)和計算所有原始變量的大小。這種方法不需要如此多的資源，可用于緩存的實現(xiàn)。缺點是原始類型大小是不同的不同的JVM實現(xiàn)對應(yīng)有不同的計算方法。
JDK5.0之后Instrumentation API提供了 getObjectSize方法來計算對象占用的內(nèi)存大小。
默認(rèn)情況下并沒有計算到引用對象的大小，為了計算引用對象，可以使用反射獲取。下面這個方法是上面文章里面提供的一個計算包含引用對象大小的實現(xiàn)：
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;
}
}
相關(guān)文章
這篇文章主要介紹了用Java實現(xiàn)一個簡單的布隆過濾器,布隆過濾器是1970年由布隆提出的,它實際上是一個很長的二進制向量和一系列隨機映射函數(shù),布隆過濾器可以用于檢索一個元素是否在一個集合中,需要的朋友可以參考下2023-12-12
SpringBoot開發(fā)案例之配置Druid數(shù)據(jù)庫連接池的示例
本篇文章主要介紹了SpringBoot開發(fā)案例之配置Druid數(shù)據(jù)庫連接池的示例，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-03-03
這篇文章主要介紹了Java數(shù)組的基本學(xué)習(xí)教程,是Java入門學(xué)習(xí)中的基礎(chǔ)知識,需要的朋友可以參考下2015-10-10
這篇文章主要介紹了JAVA得到數(shù)組中最大值和最小值的簡單實例，需要的朋友可以參考下2017-04-04
這篇文章主要給大家介紹了關(guān)于Java后端向前端返回文件流實現(xiàn)下載功能的相關(guān)資料,Java后端可以通過調(diào)用接口返回文件流來實現(xiàn)文件傳輸功能，文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下2023-10-10
執(zhí)行java請求時導(dǎo)致在腳本執(zhí)行結(jié)束時JVM無法退出
這篇文章主要介紹了執(zhí)行java請求，導(dǎo)致在腳本執(zhí)行結(jié)束時JVM無法退出問題，本文通過原因分析給出解決方案,需要的朋友可以參考下2020-02-02
這篇文章主要給大家介紹了關(guān)于java內(nèi)部類的定義與分類的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-04-04
了解java中的Clojure如何抽象并發(fā)性和共享狀態(tài)
Clojure是一種運行在Java平臺上的 Lisp 方言，Lisp是一種以表達性和功能強大著稱的編程語言，但人們通常認(rèn)為它不太適合應(yīng)用于一般情況，而Clojure的出現(xiàn)徹底改變了這一現(xiàn)狀。,需要的朋友可以參考下2019-06-06
這篇文章主要介紹了使用jdbcTemplate查詢返回自定義對象集合代碼示例，分享了相關(guān)代碼示例，小編覺得還是挺不錯的，具有一定借鑒價值，需要的朋友可以參考下2018-02-02
這篇文章主要為大家詳細(xì)介紹了四步、五分鐘Spring4快速集成Swagger的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-12-12