java debug是什么意思 java调试中debug怎么用
大家好，今天给各位分享java debug是什么意思的一些知识，其中也会对java调试中debug怎么用进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！
JAVA中提到的IDE是什么意思
IDE(Integrated Development,集成开发环境)
集成开发环境（简称IDE）软件是用于程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面工具。就是集成了代码编写功能、分析功能、编译功能、debug功能等一体化的开发软件套。所有具备这一特性的软件或者软件套（组）都可以叫做IDE。如微软的Visual Studio系列，Borland的C++ Builder,Delphi系列等。该程序可以独立运行，也可以和其它程序并用。例如，BASIC语言在微软办公软件中可以使用，可以在微软Word文档中编写WordBasic程序。IDE为用户使用Visual Basic、Java和PowerBuilder等现代编程语言提供了方便。不同的技术体系有不同的IDE。比如visual studio.Net可以称为C++、VB、C#等语言的集成开发环境，所以visual studio.Net可以叫做IDE。同样，Borland的JBuilder也是一个IDE，它是Java的IDE。zend studio、editplus、ultra edit这些，每一个都具备基本的编码、调试功能，所以每一个都可以称作IDE。
IDE多被用于开发HTML应用软件。例如，许多人在设计网站时使用IDE（如HomeSite、DreamWeaver、FrontPage，等等），因为很多项任务会自动生成。IDE集成代码编辑，代码生成，界面设计，调试，编译等功能，目前还融合了建模功能。
java中setBorder和setFocusable是什么意思
这两个方法是swing组件的方法，setBorder设置组件的边框，如大小、是否透明、其他特殊效果。setFocusable设置组件是否可被选中，如文本框不允许复制内容，则setFocusable(false)，不能被选中，就不可以复制。
setBorder(Border border)设置组件的边框，Border对象负责定义组件的 insets（直接对组件重写所有 insets设置），并且可选地呈现这些 insets
范围内的边框装饰。要为 swing组件创建有装饰的和无装饰的区域（例如边距和填充），应该使用边框（而不是
insets）。在单个组件中可使用复合边框来嵌套多个边框。
setFocusable(boolean focusable)表明此 Component是否可以获得焦点。
java调试中debug怎么用
最基本的操作是：
1.首先在一个java文件中设断点，然后debug as－－>open debug Dialog，然后在对话框中选类后－－> Run
当程序走到断点处就会转到debug视图下。
2.F5键与F6键均为单步调试，F5是step into,也就是进入本行代码中执行，F6是step over，
也就是执行本行代码，跳到下一行，
3.F7是跳出函数
4.F8是执行到最后。
1.Step Into(also F5)跳入
2.Step Over(also F6)跳过
3.Step Return(also F7)执行完当前method，然后return跳出此method
4.step Filter逐步过滤一直执行直到遇到未经过滤的位置或断点(设置Filter:window-preferences-java-Debug-step Filtering)
5.resume重新开始执行debug,一直运行直到遇到breakpoint
6.hit count设置执行次数适合程序中的for循环(设置 breakpoint view-右键hit count)
7.inspect检查运算。执行一个表达式显示执行值
8.watch实时地监视变量的变化
9.我们常说的断点(breakpoints)是指line breakpoints,除了line
breakpoints,还有其他的断点类型：field(watchpoint)breakpoint,method
breakpoint,exception breakpoint.
10.field breakpoint也叫watchpoint(监视点)当成员变量被读取或修改时暂挂
11.添加method breakpoint进入/离开此方法时暂挂(Run-method breakpoint)
12.添加Exception breakpoint捕抓到Execption时暂挂(待续...)
断点属性：
1.hit count执行多少次数后暂挂用于循环
2.enable condition遇到符合你输入条件(为ture\改变时)就暂挂
3.suspend thread多线程时暂挂此线程
4.suspend VM暂挂虚拟机
13.variables视图里的变量可以改变变量值，在variables视图选择变量点击右键--change value.一次来进行快速调试。
14.debug过程中修改了某些code后--〉save&build-->resume-->重新暂挂于断点
---------------------------------------------------------------------------------------------------------------------------------------------------------------
调试运行的快捷键：
Shift+Alt+D弹出菜单后按J：Java程序调试
Shift+Alt+D弹出菜单后按R：在Web Server上调试
Shift+Alt+D弹出菜单后按Q：Ant Build调试
调试过程中的快捷键：
F6：单步执行Step Over。通常如果不关心该语句的调用细节，单步执行就可以了。
F5：跟入Step into。一般会跟踪进入到调用函数的函数体，Step Over则不会跟踪进入，直接把调用当做一个语句处理。
F7：返回到调用处Step Return。如果无意Stepinto了一个不需要关心的函数，或者没有必要再对某个函数跟踪了，直接F7返回到调用语句处。
F8：运行至下一断点Resume。
调试中需要关心的是断点和变量。掌握一定的设置断点技巧是必须的。
1、如何跳过一段循环
有的时候跟踪代码执行，无意中进入了循环中，看了几次发现没什么问题了。是不是要StepOver到循环结束呢，或许你会Step Return，那么循环下面的代码就跟踪不到了。这时候就要利用Resume这个有趣的特性了。
去掉旧断点（循环体内的），增加新断点（循环体外），然后Resume（F8）。
2、如何调试递归调用
还是要巧用F7（StepReturn）、F8（Resume）这两个键。
另外别忘了Debug模式中的Expressions视图（Window->show view-> Expressions）
把你关心的递归变量的表达式都add进来吧，这样看起来就比Variable轻松多了。
Expressions不仅支持显示运算结果、数组元素，还可以显示方法返回值。你只需要将你关心的表达式写进来就可以了。
返回上一层递归，使用F7。跳过循环使用上面的方法。
还有巧设断点。直接让光标运行到你需要关注的地方。
在Expressions中添加能区分递归层次的表达式，这样你看起来就不会乱（不知道调用到哪一层了）。
java中的初始化具体是什么意思
关于Java初始化，有多文章都用了很大篇幅的介绍。经典的>更是用了专门的
一章来介绍Java初始化。但在大量有代码实例后面，感觉上仍然没有真正深入到初始化的本质。
本文以作者对JVM的理解和自己的经验，对Java的初始化做一个比深入的说明，由于作者有水平限制，
以及JDK各实现版本的变化，可能仍然有不少错误和缺点。欢迎行家高手赐教。
要深入了解Java初始化，我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行
机制和堆栈跟踪是有效的手段。可惜的是，到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在
着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况（但我可以证明那确实是一个BUG）
>(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:
以下译文原文:
可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸
的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的
特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来
不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。
我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字""
和""。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化
内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?
""和""方法在哪里？
这两个方法是实际存在而你又找不到的方法，也许正是这样才使得一些大师都犯晕。加上jdk实现上的一
些BUG，如果没有深入了解，真的让人摸不着北。
现在科学体系有一个奇怪的现象，那么庞大的体系最初都是建立在一个假设的基础是，假设1是正确的，
由此推导出2，再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都
是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设，我要确实证明""
和""方法是真真实实的存在的：
packagedebug;
publicclassMyTest{
staticinti=100/0;
publicstaticvoidmain(String[]args){
Ssytem.out.println("Hello,World!");
}
}
执行一下看看,这是jdk1.5的输出：
java.lang.ExceptionInInitializerError
Causedby:java.lang.ArithmeticException:/byzero
atdebug.MyTest.(Test.java:3)
Exceptioninthread"main"
请注意，和其它方法调用时产生的异常一样，异常被定位于debug.MyTest的.
再来看：
packagedebug;
publicclassTest{
Test(){
inti=100/0;
}
publicstaticvoidmain(String[]args){
newTest();
}
}
jdk1.5输入：
Exceptioninthread"main"java.lang.ArithmeticException:/byzero
atdebug.Test.(Test.java:4)
atdebug.Test.main(Test.java:7)
JVM并没有把异常定位在Test()构造方法中，而是在debug.Test.。
当我们看到了这两个方法以后，我们再来详细讨论这两个“内置初始化方法”（我并不喜欢生造一些
非标准的术语，但我确实不知道如何规范地称呼他们）。
内置初始化方法是JVM在内部专门用于初始化的特有方法，而不是提供给程序员调用的方法，事实上
“>”这样的语法在源程序中你连编译都无法通过。这就说明，初始化是由JVM控制而不是让程序员
来控制的。
类初始化方法：
我没有从任何地方了解到的cl是不是class的简写，但这个方法确实是用来对“类”进行初
始化的。换句话说它是用来初始化static上下文的。
在类装载（load）时，JVM会调用内置的方法对类成员和静态初始化块进行初始化调用。它们
的顺序按照源文件的原文顺序。
我们稍微增加两行static语句：
packagedebug;
publicclassTest{
staticintx=0;
staticStrings="123";
static{
Strings1="456";
if(1==1)
thrownewRuntimeException();
}
publicstaticvoidmain(String[]args){
newTest();
}
}
然后进行反编译：
javap-cdebug.Test
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
staticintx;
staticjava.lang.Strings;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:return
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#2;//classdebug/Test
3:dup
4:invokespecial#3;//Method"":()V
7:pop
8:return
static{};
Code:
0:iconst_0
1:putstatic#4;//Fieldx:I
4:ldc#5;//String123
6:putstatic#6;//Fields:Ljava/lang/String;
9:ldc#7;//String456
11:astore_0
12:new#8;//classjava/lang/RuntimeException
15:dup
16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
19:athrow
}
这里，我们不得不说，JDK在javap功能上的实现有一个BUG。static段的16标号，那里标识了异常
的位置发生在""方法中，而实际上这段程序运行时的输出却是：
java.lang.ExceptionInInitializerError
Causedby:java.lang.RuntimeException
atdebug.Test.(Test.java:8)
Exceptioninthread"main"
但我们总可以明白，类初始化正是按照源文件中定义的原文顺序进行。先是声明
staticintx;
staticjava.lang.Strings;
然后对intx和Strings进行赋值：
0:iconst_0
1:putstatic#4;//Fieldx:I
4:ldc#5;//String123
6:putstatic#6;//Fields:Ljava/lang/String;
执行初始化块的Strings1="456";生成一个RuntimeException抛
9:ldc#7;//String456
11:astore_0
12:new#8;//classjava/lang/RuntimeException
15:dup
16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
19:athrow
要明白的是，""方法不仅是类初始化方法，而且也是接口初始化方法。并不是所以接口
的属性都是内联的，只有直接赋常量值的接口常量才会内联。而
[publicstaticfinal]doubled=Math.random()*100;
这样的表达式是需要计算的，在接口中就要由""方法来初始化。
下面我们再来看看实例初始化方法""
""用于对象创建时对对象进行初始化，当在HEAP中创建对象时，一旦在HEAP分配了空间。最
先就会调用""方法。这个方法包括实例变量的赋值（声明不在其中）和初始化块，以及构造
方法调用。如果有多个重载的构造方法，每个构造方法都会有一个对应的""方法。
同样，实例变量和初始化块的顺序也是按源文件的原文顺序执行，构造方法中的代码在最后执行：
packagedebug;
publicclassTest{
intx=0;
Strings="123";
{
Strings1="456";
//if(1==1)
//thrownewRuntimeException();
}
publicTest(){
Stringss="789";
}
publicstaticvoidmain(String[]args){
newTest();
}
}
javap-cdebug.Test的结果：
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
intx;
java.lang.Strings;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:iconst_0
6:putfield#2;//Fieldx:I
9:aload_0
10:ldc#3;//String123
12:putfield#4;//Fields:Ljava/lang/String;
15:ldc#5;//String456
17:astore_1
18:ldc#6;//String789
20:astore_1
21:return
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#7;//classdebug/Test
3:dup
4:invokespecial#8;//Method"":()V
7:pop
8:return
}
如果在同一个类中，一个构造方法调用了另一个构造方法，那么对应的""方法就会调用另一
个""，但是实例变量和初始化块会被忽略，否则它们就会被多次执行。
packagedebug;
publicclassTest{
Strings1=rt("s1");
Strings2="s2";
publicTest(){
s1="s1";
}
publicTest(Strings){
this();
if(1==1)thrownewRuntime();
}
Stringrt(Strings){
returns;
}
publicstaticvoidmain(String[]args){
newTest("");
}
}
反编译的结果：
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
java.lang.Strings1;
java.lang.Strings2;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:aload_0
21:ldc#2;//Strings1
23:putfield#4;//Fields1:Ljava/lang/String;
26:return
publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#7;//Method"":()V
4:new#8;//classjava/lang/RuntimeException
7:dup
8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
11:athrow
java.lang.Stringrt(java.lang.String);
Code:
0:aload_1
1:areturn
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#10;//classdebug/Test
3:dup
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return
}
我们再一次看到了javap实现的bug，虽然有一个"":(Ljava/lang/String;)V签名可以说明
每个构造方法对应一个不同,但Runtime异常仍然被定位到了""()V的方法中：
invokespecial#8;//Methodjava/lang/RuntimeException."":()V,而在main方法中的
调用却明明是"":(Ljava/lang/String;)V.
但是我们看到，由于Test(Strings)调用了Test();所以"":(Ljava/lang/String;)V不再对
实例变量和初始化块进次初始化：
publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#7;//Method"":()V
4:new#8;//classjava/lang/RuntimeException
7:dup
8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
11:athrow
而如果两个构造方法是相互独立的，则每个构造方法调用前都会执行实例变量和初始化块的调用：
packagedebug;
publicclassTest{
Strings1=rt("s1");
Strings2="s2";
{
Strings3="s3";
}
publicTest(){
s1="s1";
}
publicTest(Strings){
if(1==1)
thrownewRuntimeException();
}
Stringrt(Strings){
returns;
}
publicstaticvoidmain(String[]args){
newTest("");
}
}
反编译的结果：
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
java.lang.Strings1;
java.lang.Strings2;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:ldc#7;//Strings3
22:astore_1
23:aload_0
24:ldc#2;//Strings1
26:putfield#4;//Fields1:Ljava/lang/String;
29:return
publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:ldc#7;//Strings3
22:astore_2
23:new#8;//classjava/lang/RuntimeException
26:dup
27:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
30:athrow
java.lang.Stringrt(java.lang.String);
Code:
0:aload_1
1:areturn
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#10;//classdebug/Test
3:dup
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return
}
好了，文章到此结束，希望可以帮助到大家。