- 浏览: 167323 次
- 性别:
- 来自: 重庆
文章分类
最新评论
-
lilixu:
Netcdf (二) -
publicorprivate:
[b]atwr s [/b]
xml和实体对象相互转换 一步到位 -
mangolms:
讲得很好,顶一个
Java 线程入门 -
crawler:
lvwenwen 写道求问楼主自己学习的总结还是有什么相关的材 ...
第二章 面向对象的几个基本原则 -
lvwenwen:
求问楼主自己学习的总结还是有什么相关的材料
第二章 面向对象的几个基本原则
前言:
工作时间稍微长一些之后,总是对一些不能看到的东西会有一些好奇,想透过现象能观察到后台的本质情况,能用java语言编写业务逻辑了,但是并不一定能明白每个字符,每个常量在计算机中是怎么存储的,所以有时候在编程过程中可能由于基础知识不扎实而犯了一些很低级但又很严重的错误,也正是掌握了这些基础我想也才知道所以然,也才会有进步。
Java中的内存分配区域主要由:堆、栈、常量池、静态域、代码区
堆(Heap):堆主要存放Java在运行过程中new出来的对象,凡是通过new生成的对象都存放在堆中,对于堆中的对象生命周期的管理由Java虚拟机的垃圾回收机制GC进行回收和统一管理。
栈(Stack):栈主要存放在运行期间用到的一些局部变量(基本数据类型的变量)或者是指向其他对象的一些引用,当一段代码或者一个方法调用完毕后,栈中为这段代码所提供的基本数据类型或者对象的引用立即被释放;另外需注意的是栈中存放变量的值是可以共享的,优先在栈中寻找是否有相同变量的值,如果有直接指向这个值,如果没有则另外分配。
常量池(ConstantPool):常量池在编译期间就将一部分数据存放于该区域,包含基本数据类型如int、long等和对象类型String、数组等并以final声明的常量值。特别注意的是对于运行期位于栈中的String常量的值可以通过 String.intern()方法将该值置入到常量池中。
静态域(StaticSegment):存放类中以static声明的静态成员变量
代码区(CodeSegment):主要存放一些代码段以供类调用的时候所共用。
举例:
public static void main(String[] args) { String a = "a"; String tempa="a"; String b = "b"; String c = "c"; String abc = "abc"; String a_b_c = "a"+"b"+"c"; String a_b = a+b; String ab = "ab"; String newabc = new String("abc"); String abcintern = newabc.intern(); final String finalb = "b"; String a_b2 = "a"+finalb; System.out.println(tempa==a);//true,在栈中共享同一个值,也可以理解为他们共同指向字符串常量池中的a System.out.println(newabc==abc);//false,newabc是指向堆的一个引用,abc是在位于栈中的String对象的一个引用变量,然后去字符串常量池中找abc字符串,如果找到则将该应用指向abc,如果找不到则将abc放入字符串常量池然后指向它。 System.out.println(a_b==ab);//false,a_b是在运行期字符串的引用,而ab则是在编译期间就指定了 System.out.println(a_b_c==abc);//true,a_b_c在编译期间就将常量字符串连接到一起,所以他们指向同一个字符串常量,而且"a"+"b"+"c",首先a和b组装成一个常量ab放于常量池中,然后ab和c组装在一起放于常量池中,然后将abc的地址赋给了a_b_c,由于String是不可变的,所以产生了很多临时变量。 System.out.println(abcintern==abc);//true,调用intern()方法则将abc字符串放入了字符串常量池,返回值则是直接指向常量池中的字符串常量值所以相等 System.out.println(ab==a_b2);//true,finalb是因为声明为final修饰符它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中,相当于"a"+"b" }
在面试中我们经常被问到String和StringBuffer的区别,如果从内存上理解了他们的存储那么就不难理解了:以下是JDK中对String的类的说明:
public final class String
String
类代表字符串。Java 程序中的所有字符串字面值(如 "abc"
)都作为此类的实例实现。
字符串是常量;它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。
因为String 字符串是常量,所以他一旦初始化后值是不能变的,而且是可以共享的,存放于字符串常量池,需要在程序中做大量的字符串连接时采用StringBuffer来连接,如果直接采用String来连接由于他们的值是不能改变的,相当于还是采用了StringBuffer来连接了字符串,但是在连接过程中如果事先没声明Stringbuffer对象则中间工程中就会产生很多临时变量:
String str = null;
for(int i=0;i<100;i++){
str +=i;//每循环一次相当于产生了StringBuffer对象
}
评论
String a = "a"; String tempa="a";这种声明方式下,相同的字符串在堆内存中是一个对象。博主这句“栈中存放变量的值是可以共享的”我不太理解。从jvm内存模型看,所有的复杂对象(就是Object的子类)都是放在堆中的,而基本类型的变量都是放在栈中的。如果涉及到栈中数据的共享,应该是针对基本数据类型进行试验吧。
栈中存放了8种基本类型和Reference及ReturnAddress类型
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
natural is best.如果你写的代码是符合抽象模型的,是自然地,那编译器就应该在底层自己去优化它,而不是自己去挖底层,那不是你的活,大部分优化在那个抽象模型之上做就可以了。将程序与底层实现捆绑在一起,既不自然,维护性低,而且底层实现实际上是没有 “保证”的,随时都可能改,只要上层显示的抽象模型没有变化.也即是与底层实现相关的你的程序可能是“不稳定”的.
只有万不得已的时候,才以底层的思路看问题。但那样的代码应该标明做的理由,并且当底层的自身优化已经解决问题的时候。应立即将代码改为 自然的由抽象模型推出 的代码。
------
以上是在语言的抽象模型很理想的情况下说的...java吗..只能说尽量做到。方向要对.
呵呵,只能说你还没有接触到计较内存使用大小的情况。符合抽象模型难道你就能保证你的程序使用的内存是最小最优的么,说个简单的例子,大家都知道的例子,比如我们程序都是完美的设计,都是符合什么抽象,什么面向对象,什么aop,什么ioc,什么模式,等等,都是完美的设计,但是我只在一个方法里面写上一段代码,你就会觉得崩溃了
伪代码:
string a = "";
foreach(int i : list){//此处循环1万次
a += i + "_";
}
这只不过是个例子,如果我肯定不这么写,所以,细节决定成败,内存同样也是细节的范畴内。
其实我总结这些东西的目的是在工作实践的基础上去理解这些知识,去巩固自己的基础知识,对于细节来说个人觉得很重要,就像如果你被困在一个机关黑屋子里了,这个机关就是个细节,如果找不到打开黑屋子的机关那么你就永远被困在黑屋子里了;另外有的基础知识就像修炼内功一样,内功深厚你出招的杀伤力是不一样,效果是不一样的;每个人都有自己的见解和心得体会,我也觉得很正常,因为出于不同的工作阶段,认识阶段,成长阶段认识是不一样的。
编译器不是考试用的,它不是你的对手,更不是小黑屋,相反他是你的助手。你不信任它提供的抽象模型而什么都要自己做或者自己去看清楚底层实现,这既浪费时间又阻碍了编译器的自由优化。
然后,不要误解我,我并不是反对了解底层,我只是说 那不是“基础”知识,也不是内功,相反,那是“额外”的东西,并非 “必要”的基础。 了解额外的东西当然也是有好处的,因为总是有特殊情况让你不得不去 做底层相关的优化,不过那是 额外的,只有有必需的需要才做。
然后我来提出我认为的java的基础知识,1.语法语义,没有这个你什么也做不了。
2.api类库。没有这个你基本什么都做不了. 3.各种抽象模型,没这个,你不知道怎么做。
ps:算法并不算抽象模型,算法背后的数学抽象概念才算。用算法也就是用,just try it.了解背后的数学才能设计算法。
你说的有道理,所以我说不同的工作阶段,认识阶段,成长阶段每个人都有自己的见解和心得体会。
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
natural is best.如果你写的代码是符合抽象模型的,是自然地,那编译器就应该在底层自己去优化它,而不是自己去挖底层,那不是你的活,大部分优化在那个抽象模型之上做就可以了。将程序与底层实现捆绑在一起,既不自然,维护性低,而且底层实现实际上是没有 “保证”的,随时都可能改,只要上层显示的抽象模型没有变化.也即是与底层实现相关的你的程序可能是“不稳定”的.
只有万不得已的时候,才以底层的思路看问题。但那样的代码应该标明做的理由,并且当底层的自身优化已经解决问题的时候。应立即将代码改为 自然的由抽象模型推出 的代码。
------
以上是在语言的抽象模型很理想的情况下说的...java吗..只能说尽量做到。方向要对.
呵呵,只能说你还没有接触到计较内存使用大小的情况。符合抽象模型难道你就能保证你的程序使用的内存是最小最优的么,说个简单的例子,大家都知道的例子,比如我们程序都是完美的设计,都是符合什么抽象,什么面向对象,什么aop,什么ioc,什么模式,等等,都是完美的设计,但是我只在一个方法里面写上一段代码,你就会觉得崩溃了
伪代码:
string a = "";
foreach(int i : list){//此处循环1万次
a += i + "_";
}
这只不过是个例子,如果我肯定不这么写,所以,细节决定成败,内存同样也是细节的范畴内。
其实我总结这些东西的目的是在工作实践的基础上去理解这些知识,去巩固自己的基础知识,对于细节来说个人觉得很重要,就像如果你被困在一个机关黑屋子里了,这个机关就是个细节,如果找不到打开黑屋子的机关那么你就永远被困在黑屋子里了;另外有的基础知识就像修炼内功一样,内功深厚你出招的杀伤力是不一样,效果是不一样的;每个人都有自己的见解和心得体会,我也觉得很正常,因为出于不同的工作阶段,认识阶段,成长阶段认识是不一样的。
编译器不是考试用的,它不是你的对手,更不是小黑屋,相反他是你的助手。你不信任它提供的抽象模型而什么都要自己做或者自己去看清楚底层实现,这既浪费时间又阻碍了编译器的自由优化。
然后,不要误解我,我并不是反对了解底层,我只是说 那不是“基础”知识,也不是内功,相反,那是“额外”的东西,并非 “必要”的基础。 了解额外的东西当然也是有好处的,因为总是有特殊情况让你不得不去 做底层相关的优化,不过那是 额外的,只有有必需的需要才做。
然后我来提出我认为的java的基础知识,1.语法语义,没有这个你什么也做不了。
2.api类库。没有这个你基本什么都做不了. 3.各种抽象模型,没这个,你不知道怎么做。
ps:算法并不算抽象模型,算法背后的数学抽象概念才算。用算法也就是用,just try it.了解背后的数学才能设计算法。
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
natural is best.如果你写的代码是符合抽象模型的,是自然地,那编译器就应该在底层自己去优化它,而不是自己去挖底层,那不是你的活,大部分优化在那个抽象模型之上做就可以了。将程序与底层实现捆绑在一起,既不自然,维护性低,而且底层实现实际上是没有 “保证”的,随时都可能改,只要上层显示的抽象模型没有变化.也即是与底层实现相关的你的程序可能是“不稳定”的.
只有万不得已的时候,才以底层的思路看问题。但那样的代码应该标明做的理由,并且当底层的自身优化已经解决问题的时候。应立即将代码改为 自然的由抽象模型推出 的代码。
------
以上是在语言的抽象模型很理想的情况下说的...java吗..只能说尽量做到。方向要对.
呵呵,只能说你还没有接触到计较内存使用大小的情况。符合抽象模型难道你就能保证你的程序使用的内存是最小最优的么,说个简单的例子,大家都知道的例子,比如我们程序都是完美的设计,都是符合什么抽象,什么面向对象,什么aop,什么ioc,什么模式,等等,都是完美的设计,但是我只在一个方法里面写上一段代码,你就会觉得崩溃了
伪代码:
string a = "";
foreach(int i : list){//此处循环1万次
a += i + "_";
}
这只不过是个例子,如果我肯定不这么写,所以,细节决定成败,内存同样也是细节的范畴内。
如果是我的话,会这么写,mutable object和mutable variable尽量同时只存在一种,方便分析。这里首先看一下String和StringBuilder的抽像.
String : 不可变,每次操作建立一个新对象赋予给变量。
StringBuilder: 可变,用于最终建立一个String(主要目的).
很显然,不可变的String不适合用在for循环里不断变化.而用于中间变化生成 中间值 最终生成 String 结果的 StringBuilder更 natural.
final StringBuilder sb = new StringBuilder(); for (final Integer nj : l) { sb.append(nj).append(seperator); } final String result = sb.toString();
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
natural is best.如果你写的代码是符合抽象模型的,是自然地,那编译器就应该在底层自己去优化它,而不是自己去挖底层,那不是你的活,大部分优化在那个抽象模型之上做就可以了。将程序与底层实现捆绑在一起,既不自然,维护性低,而且底层实现实际上是没有 “保证”的,随时都可能改,只要上层显示的抽象模型没有变化.也即是与底层实现相关的你的程序可能是“不稳定”的.
只有万不得已的时候,才以底层的思路看问题。但那样的代码应该标明做的理由,并且当底层的自身优化已经解决问题的时候。应立即将代码改为 自然的由抽象模型推出 的代码。
------
以上是在语言的抽象模型很理想的情况下说的...java吗..只能说尽量做到。方向要对.
呵呵,只能说你还没有接触到计较内存使用大小的情况。符合抽象模型难道你就能保证你的程序使用的内存是最小最优的么,说个简单的例子,大家都知道的例子,比如我们程序都是完美的设计,都是符合什么抽象,什么面向对象,什么aop,什么ioc,什么模式,等等,都是完美的设计,但是我只在一个方法里面写上一段代码,你就会觉得崩溃了
伪代码:
string a = "";
foreach(int i : list){//此处循环1万次
a += i + "_";
}
这只不过是个例子,如果我肯定不这么写,所以,细节决定成败,内存同样也是细节的范畴内。
其实我总结这些东西的目的是在工作实践的基础上去理解这些知识,去巩固自己的基础知识,对于细节来说个人觉得很重要,就像如果你被困在一个机关黑屋子里了,这个机关就是个细节,如果找不到打开黑屋子的机关那么你就永远被困在黑屋子里了;另外有的基础知识就像修炼内功一样,内功深厚你出招的杀伤力是不一样,效果是不一样的;每个人都有自己的见解和心得体会,我也觉得很正常,因为出于不同的工作阶段,认识阶段,成长阶段认识是不一样的。
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
natural is best.如果你写的代码是符合抽象模型的,是自然地,那编译器就应该在底层自己去优化它,而不是自己去挖底层,那不是你的活,大部分优化在那个抽象模型之上做就可以了。将程序与底层实现捆绑在一起,既不自然,维护性低,而且底层实现实际上是没有 “保证”的,随时都可能改,只要上层显示的抽象模型没有变化.也即是与底层实现相关的你的程序可能是“不稳定”的.
只有万不得已的时候,才以底层的思路看问题。但那样的代码应该标明做的理由,并且当底层的自身优化已经解决问题的时候。应立即将代码改为 自然的由抽象模型推出 的代码。
------
以上是在语言的抽象模型很理想的情况下说的...java吗..只能说尽量做到。方向要对.
呵呵,只能说你还没有接触到计较内存使用大小的情况。符合抽象模型难道你就能保证你的程序使用的内存是最小最优的么,说个简单的例子,大家都知道的例子,比如我们程序都是完美的设计,都是符合什么抽象,什么面向对象,什么aop,什么ioc,什么模式,等等,都是完美的设计,但是我只在一个方法里面写上一段代码,你就会觉得崩溃了
伪代码:
string a = "";
foreach(int i : list){//此处循环1万次
a += i + "_";
}
这只不过是个例子,如果我肯定不这么写,所以,细节决定成败,内存同样也是细节的范畴内。
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
natural is best.如果你写的代码是符合抽象模型的,是自然地,那编译器就应该在底层自己去优化它,而不是自己去挖底层,那不是你的活,大部分优化在那个抽象模型之上做就可以了。将程序与底层实现捆绑在一起,既不自然,维护性低,而且底层实现实际上是没有 “保证”的,随时都可能改,只要上层显示的抽象模型没有变化.也即是与底层实现相关的你的程序可能是“不稳定”的.
只有万不得已的时候,才以底层的思路看问题。但那样的代码应该标明做的理由,并且当底层的自身优化已经解决问题的时候。应立即将代码改为 自然的由抽象模型推出 的代码。
------
以上是在语言的抽象模型很理想的情况下说的...java吗..只能说尽量做到。方向要对.
String a = "a"; String tempa="a";这种声明方式下,相同的字符串在堆内存中是一个对象。博主这句“栈中存放变量的值是可以共享的”我不太理解。从jvm内存模型看,所有的复杂对象(就是Object的子类)都是放在堆中的,而基本类型的变量都是放在栈中的。如果涉及到栈中数据的共享,应该是针对基本数据类型进行试验吧。
你说的“这种声明方式下,相同的字符串在堆内存中是一个对象”中的a和tempa并不在堆中,只有通过new出来的对象才为于堆中;
“栈中存放变量的值是可以共享的”你可以理解为对于基本数据类型和常量类型(包括字符常量、字符串常量)都是位于常量池中的,当String a = "a"; 执行这句时在栈中声明了一块内存变量a,然后到常量池中去找是否存在字符串常量"a",第一次没找到就将它置入常量池中,此时变量a的值为"a",你也可以理解它指向到常量池中的字符串常量"a";然后执行第二句String tempa="a"; 时,在栈中声明了一块内存变量tempa,然后到常量池中去找是否存在字符串常量"a",此时常量池中已经存在"a",则直接将该值赋给变量tempa,你也可以理解它指向到常量池中的字符串常量"a"(那么相当于他俩都指向常量池中的"a");所以为true。
另外你说的"从jvm内存模型看,所有的复杂对象(就是Object的子类)都是放在堆中的,而基本类型的变量都是放在栈中的"对应String的字符串常量是可以共享的,你可以看JDK中对String类的描述:Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared.(字符串是常量;它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。)
我明白你的意思了。之前是我记错了,字符串的确是放在常量池中的,只是针对你所说的“共享”不太理解你要表达的意思,呵呵
String a = "a"; String tempa="a";这种声明方式下,相同的字符串在堆内存中是一个对象。博主这句“栈中存放变量的值是可以共享的”我不太理解。从jvm内存模型看,所有的复杂对象(就是Object的子类)都是放在堆中的,而基本类型的变量都是放在栈中的。如果涉及到栈中数据的共享,应该是针对基本数据类型进行试验吧。
你说的“这种声明方式下,相同的字符串在堆内存中是一个对象”中的a和tempa并不在堆中,只有通过new出来的对象才为于堆中;
“栈中存放变量的值是可以共享的”你可以理解为对于基本数据类型和常量类型(包括字符常量、字符串常量)都是位于常量池中的,当String a = "a"; 执行这句时在栈中声明了一块内存变量a,然后到常量池中去找是否存在字符串常量"a",第一次没找到就将它置入常量池中,此时变量a的值为"a",你也可以理解它指向到常量池中的字符串常量"a";然后执行第二句String tempa="a"; 时,在栈中声明了一块内存变量tempa,然后到常量池中去找是否存在字符串常量"a",此时常量池中已经存在"a",则直接将该值赋给变量tempa,你也可以理解它指向到常量池中的字符串常量"a"(那么相当于他俩都指向常量池中的"a");所以为true。
另外你说的"从jvm内存模型看,所有的复杂对象(就是Object的子类)都是放在堆中的,而基本类型的变量都是放在栈中的"对应String的字符串常量是可以共享的,你可以看JDK中对String类的描述:Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared.(字符串是常量;它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。)
String a = "a"; String tempa="a";这种声明方式下,相同的字符串在堆内存中是一个对象。博主这句“栈中存放变量的值是可以共享的”我不太理解。从jvm内存模型看,所有的复杂对象(就是Object的子类)都是放在堆中的,而基本类型的变量都是放在栈中的。如果涉及到栈中数据的共享,应该是针对基本数据类型进行试验吧。
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
有道理,因为效率这个东西有你必须从细节入手
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
如果你搞java的时候很在乎内存的大小的时候,你就知道内存的了解是多么的重要了。
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
你的见解也不错,更在乎一些底层之上的东西,比如OO思想,算法,模式等。
只不过我觉得理解了内存分配,执行每一行代码都能知道这些东西分配在哪儿,而且有助于对一些概念的真实理解,以前感觉自己的基础是背出来的,现在想好好去理解下这些东西
就好像人一样,人的本质绝不是细胞,神经元之类的东西,而是更高层的东西。
掌握细节的确对掌握本质有帮助,不过那不是必须的。而是额外的。
感觉你这种方式适合去学C.
发表评论
-
第八章 装饰模式
2013-05-17 08:55 10821.装饰模式 动态地给对象添加一些额外的职责。就功能来说 ... -
Java基本类型与byte数组之间相互转换
2013-05-15 18:07 4343转:http://blog.sina.com.cn/s/bl ... -
Java 线程入门
2013-05-09 15:28 15161概念 线程,有时被称为轻量级进程(Lightweigh ... -
Java IO流 续
2013-05-08 09:39 13601.基于字节文件读写 FileInputStream和F ... -
Java IO流
2013-05-08 09:16 15411.流的概念 流是一个很形象的概念当程序需要读取数据的 ... -
第三章 单例模式
2013-05-05 14:52 8863.1单例(Singleton)模式 保证一个类仅有一个 ... -
第二章 面向对象的几个基本原则
2013-05-05 14:42 23482.1 抽象类和接口 抽象类是可以继承一个抽象类 ... -
理解JMS
2012-09-06 16:31 2238首先JMS存在的理由: RPC(Remote proced ... -
回望Java中的多线程并发(一)
2012-09-05 08:55 1764并发其实并不等于多线程,可以理解为多线程是实现并发的一种方式, ... -
回望Java中的final关键字
2012-09-03 15:25 2399final关键字可以理解为“这个东西不能改变”。之所以要禁止改 ... -
Java内存区域与内存溢出异常
2012-09-02 18:56 1446之前根据平时的积累总 ... -
回望Java中Static关键字
2012-09-01 09:41 3859编写代码过程中常常用 ...
相关推荐
### Java内存分配机制详解 #### 一、引言 Java作为一种广泛应用的编程语言,其内存管理机制对于确保程序高效稳定运行至关重要。本文旨在详细介绍Java内存分配机制中的几个关键概念:寄存器、栈、堆、静态域、常量...
Java内存分配主要涉及五个区域:寄存器、栈、堆、静态域和常量池。在Java编程中,理解这些内存区域的分配规则对于优化代码性能和避免内存泄漏至关重要。 1. **寄存器**:这是最快捷的存储区域,但不在Java程序员的...
Java内存分配是Java编程中非常重要的概念,它涉及到程序运行时的数据存储和管理。Java程序在JVM(Java Virtual Machine,Java虚拟机)上运行,JVM作为一个平台无关的执行环境,负责Java程序的内存管理和执行。理解...
### Java内存分配原理精讲 #### 一、引言 Java作为一门广泛应用于企业级开发的语言,其内存管理和分配机制是其核心技术之一。本文旨在深入探讨Java内存分配的基本原理及其在不同内存区域的具体表现,帮助读者更好...
50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java内存分配.zip50.java...
### JAVA内存分配详解 #### 一、JAVA内存结构概述 Java程序在运行过程中涉及的内存主要包括以下几个部分: 1. **方法区(Method Area)** 2. **栈内存(Stack Memory)** 3. **堆内存(Heap Memory)** 4. **本地...
"java内存分配演示程序"是一个用于理解Java内存模型和内存分配过程的项目。在这个课程设计中,你将深入学习Java如何在运行时为对象分配内存,以及垃圾收集器如何回收不再使用的内存。以下是关于Java内存分配的一些...
Java内存分配与管理是Java的核心技术之一,今天我们深入Java核心,详细介绍一下Java在内存分配方面的知识。一般Java在内存分配时会涉及到以下区域: ◆寄存器:我们在程序中无法控制 ◆栈:存放基本类型的...
Java内存分配原理是Java编程中的重要一环,它关乎到程序的性能、稳定性和资源管理。深入理解这一主题,能够帮助开发者编写出更高效、更稳定的代码。在Java中,内存分为堆内存、栈内存、方法区(在Java 8之后被元空间...
理解Java内存分配和JVM工作原理对于开发高效、健壮的Java应用至关重要。开发者应避免内存泄漏,合理使用内存,充分利用JVM的垃圾收集机制,同时理解JIT编译的优化策略,以提高程序的运行性能。在开发过程中,使用...
Java内存分配全面解析 Java程序在执行过程中,其内存分配主要涉及到JVM(Java Virtual Machine,Java虚拟机)的不同区域。这些区域包括寄存器、栈、堆、常量池、代码段和数据段。理解这些内存区域的工作原理对于...
### 深入Java内存分配 #### Java有几种存储区域? Java程序运行时涉及多种不同的存储区域,这些区域各自承担着不同的职责。 1. **寄存器**:这是CPU内部的一部分,开发人员无法直接控制寄存器的分配,通常由...
Java内存分配与管理是Java编程语言中非常核心的技术部分,因为Java虚拟机(JVM)为Java程序提供了自动内存管理的功能,包括垃圾回收机制,极大地降低了内存泄漏的风险,使得开发者可以专注于业务逻辑的实现而不是...
### Java内存分配详解 #### 一、Java内存区域划分 Java程序在运行过程中涉及的内存主要分为两大类:栈内存和堆内存。 1. **栈内存**:主要用于存储局部变量,如基本数据类型变量(int、long、char等)以及对象的...
Java内存分配是Java编程中非常关键的概念,它关乎程序的性能和稳定性。Java内存主要分为以下几个部分: 1. **寄存器**:这是最快的存储区域,由编译器根据需求进行分配,通常由硬件直接支持,程序员无法直接控制。 ...
本篇文章将深入探讨Java内存分配中的“最先适应法”、“最佳适应法”和“最坏适应法”,这些都是内存管理中的经典算法,适用于不同的场景和需求。 首先,我们来看“最先适应法”(First Fit)。这是一种简单的内存...
Java内存分配与垃圾回收是Java程序性能优化的关键领域。在Java平台上,程序的运行主要依赖于JVM(Java虚拟机),而JVM的核心组件之一就是内存管理。本篇将深入探讨Java内存分配策略以及垃圾回收机制,以帮助你更好地...
深入理解Java核心:Java内存分配原理精讲 Java内存分配是理解Java运行机制的关键部分,尤其对于初学者而言,掌握这一原理能显著提升编程效率和代码质量。Java内存分配涉及多个区域,包括栈、堆、常量池等,每个区域...
Java内存分配原理是Java编程中不可或缺的基础概念,它关乎程序的性能和稳定性。Java内存主要分为五个区域:寄存器、栈、堆、静态域和常量池。这些区域各有其特定的功能和生命周期。 首先,寄存器是硬件层面的概念,...