‘壹’ 如何静态测试 java 代码
所有的这些新的工具使得确保代码质量比以前简单得多，不过您还需要知道如何使用它们。 代码度量 “监视圈复杂度”展示如何使用简单的代码度量工具和基于 Java 的工具来监视代码复杂度。 “软件架构的代码质量”解释了如何持续地监视并纠正会影响软件架构的长期生存能力的代码质量方面。 “用代码度量进行重构”介绍如何使用相同的代码度量方法和提取方法模式进行有针对性的重构。 静态分析工具 静态分析工具承诺无需开发人员费劲就能找出代码中已有的缺陷。当然，如果有多年的编写经验，就会知道这些承诺并不是一定能兑现。尽管如此，好的静态分析工具仍然是工具箱中的无价之宝： FindBugs 是一个静态分析工具，它检查类或者 JAR 文件，将字节码与一组缺陷模式进行对比以发现可能的问题： “FindBugs，第 1 部分”和“第 2 部分”分别介绍使用 FindBugs 的原因和方法以及如何编写自定义检测器以查找特定于应用程序的问题。 “消除 bug”展示了这个静态分析工具如何帮助分析代码。 “平衡测试，第 1 部分、第 2 部分 和第 3 部分”讨论如何通过引进 FindBugs 静态代码分析工具来改进管理软件质量的方式。 PMD 是一个开源的静态分析工具，它分析 Java 源代码，并找出潜在的 bug： “用 PMD 铲除 bug”解释如何使用 PMD 内置的规则以及您自己定制的规则集来提高 Java 代码质量。
‘贰’ Java 中 静态方法与非静态方法的区别
静态方法和实例方法的区别主要体现在两个方面：
在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
下面几个例子展示了这一区别。
1、调用静态方法示例。
//-----------文件名hasStaticMethod.java，程序编号1-----------------public
class hasStaticMethod{//定义一个静态方法public static void
callMe(){System.out.println("This is a static method.");}}
下面这个程序使用两种形式来调用静态方法。
//-----------文件名invokeStaticMethod.java，2-----------------
public class invokeStaticMethod{
public static void main(String args[]){
hasStaticMethod.callMe(); //不创建对象，直接调用静态方法
hasStaticMethod oa = new hasStaticMethod(); //创建一个对象oa.callMe(); //利用对象来调用静态方法}}
程序3.36两次调用静态方法，都是允许的，程序的输出如下：
This is a static method.This is a static method.
允许不创建对象而调用静态方法，是Java为了减少程序员调用某些常用方法时的麻烦，而允许程序员按照传统的C语言中使用函数的方式来使用方法。典型的例子是前面某些程序中使用"Math.ramdon()"来获取随机数。
2、静态方法访问成员变量示例。
//-----------文件名accessMember.java，程序编号3.37-----------------class
accessMember{private static int sa; //定义一个静态成员变量private int ia;
//定义一个实例成员变量//下面定义一个静态方法static void statMethod(){int i = 0;
//正确，可以有自己的局部变量sa = 10; //正确，静态方法可以使用静态变量otherStat(); //正确，可以调用静态方法ia =
20; //错误，不能使用实例变量insMethod(); //错误，不能调用实例方法}static void otherStat(){}
//下面定义一个实例方法 void insMethod(){int i = 0; //正确，可以有自己的局部变量sa = 15;
//正确，可以使用静态变量ia = 30; //正确，可以使用实例变量statMethod(); //正确，可以调用静态方法}}
本例其实可以概括成一句话：静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许它使用实例成员变量，所以它也不能调用实例方法。基于同样的道理，静态方法中也不能使用关键字this。
main()方法是一个典型的静态方法，它同样遵循一般静态方法的规则，所以它可以由系统在创建对象之前就调用。
‘叁’ java static问题
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。
只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名
用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。
1、static变量
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。
两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
所以一般在需要实现以下两个功能时使用静态变量：
在对象之间共享值时
方便访问变量时
2、静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，
因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。
因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。
静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的
3、static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：
public class Test5 {
private static int a;
private int b;
static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
}
运行结果：
3
hhahhahah
1000
4
5
利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。
4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
•
它们仅能调用其他的static 方法。
•
它们只能访问static数据。
•
它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[]) {
meth(42);
}
}
一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。
注意：在一个static 方法中引用任何实例变量都是非法的。
下面是该程序的输出：
Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：
classname.method( )
这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。
下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是该程序的输出：
a = 42
b = 99
static成员是不能被其所在class创建的实例访问的。
如果不加static修饰的成员是对象成员，也就是归每个对象所有的。
加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的
‘肆’ java的静态变量 static
1.首先你 for (i = 0; i < 3; i++) 里的i就是那个静态的i了 你把i=0了 于是静态的i就变成0了 于是执行完循环i就变成3了
2.你的for循环并没有定义局部的i 亲
把那个for循环改成for ( int i = 0; i < 3; i++)
就可以了
‘伍’ java静态方法和动态方法的区别，本人初学者，要有例子的。详细的话可以给精彩。
1.静态的方法在整个应用程序其间存储在内存中,速度快，但占用内存.
class A
{
public static string b()
{
return "Hello";
}
}
用法: A.b(); //调用方便
静态方法可以通过类名直接调用，
2.动态的方法在先声明类实例才能调用类中的方法.
class A
{
public string b()
{
return "Hello";
}
}
用法: A a = new a(); a.b();
3.一般使用频繁的方法用静态方法，用的少的方法用动态的。静态的速度快，占内存。动态的速度相对慢些，但调用完后，立即释放类，可以节省内存，可以根据自己的需要选择是用动态方法还是静态方法。
4.静态方法主要的问题就是数据同步的问题。如果你的静态方法的类中不保存私有变量那么什么问题都不会有的。最好是包要操作的数据全部以参数的方式传到方法中去
5. 静态方法是类方法，调用时不需要创建类实例。
6. 静态方法是静态绑定到子类，不是被继承。
‘陆’ JAVA 里什么是静态方法,什么是动态方法
请先看下面这段程序：
public class Hello{
public static void main(String[] args){ //(1)
System.out.println("Hello,world!"); //(2)
}
}
看过这段程序，对于大多数学过Java 的从来说，都不生疏。即使没有学过Java，而学过其它的高
级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点
别的用处都没有，然而，它却展示了static要害字的主要用法。
在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：
javac Hello.java
java Hello
Hello,world!
这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，假如你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（假如没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，假如你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：
public void println(String x)。好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。
静态方法
通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：
class Simple{
static void go(){
System.out.println("Go...");
}
}
public class Cal{
public static void main(String[] args){
Simple.go();
}
}
调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法经常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
静态变量
静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：
class Value{
static int c=0;
static void inc(){
c++;
}}
class Count{
public static void prt(String s){
System.out.println(s);
}
public static void main(String[] args){
Value v1,v2;
v1=new Value();
v2=new Value();
prt("v1.c="+v1.c+"
v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
}}
结果如下：
v1.c=0 v2.c=0
v1.c=1 v2.c=1
由此可以证实它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：
class Value{
static int c=0;
Value(){
c=15;
}
Value(int i){
c=i;
}
static void inc(){
c++;
}}
class Count{
public static void prt(String s){
System.out.println(s);
}
Value v=new Value(10);
static Value v1,v2;
static{
prt("v1.c="+v1.c+"
v2.c="+v2.c);
v1=new Value(27);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v2=new Value(15);
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
public static void main(String[] args){
Count ct=new Count();
prt("ct.c="+ct.v.c);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
prt("ct.c="+ct.v.c);
}}
运行结果如下：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
这个程序展示了静态初始化的各种特性。假如你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。假如你能读懂并理解这段代码，会帮助你对static要害字的熟悉。在涉及到继续的时候，会先初始化父类的static变量，然后是子类的，依次类推。非静态变量不是本文的主题，在此不做具体讨论，请参考Think in Java中的讲解。
静态类
通常一个普通类不答应声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：
public class StaticCls{
public static void main(String[] args){
OuterCls.InnerCls oi=new OuterCls.InnerCls();
}}
class OuterCls{
public static class InnerCls{
InnerCls(){
System.out.println("InnerCls");
}
}}
输出结果会如你所料：
InnerCls
‘柒’ JUnit test 如何做Java静态方法测试
使用junit测试Java静态私有方法，通过以下案例进行分析：
测试目标类如下：
packagecn.outofmemory.junit;
publicclassTestTarget{
/**
*移除正则表达式中需要转义的字符
*@paramwword
*@return移除正则表达式中需要转义的字符
*@authorAdministrator
*@date2015-7-11
*/
(Stringw){
if(w==null){
returnnull;
}
String[]convertedChars={"\",".","+","*","(",")","{","}","[","]","?","/","^","$","|"};
for(Stringc:convertedChars){
w=w.replace(c,"\"+c);
}
returnw;
}
}
测试方法：
@Test
publicvoidtestConvert4Regex()throwsException{
Stringinput="A+";
Stringexpected="A\+";
MethodtargetMethod=TestTarget.class.getDeclaredMethod("convert4Regex",String.class);
targetMethod.setAccessible(true);
Objectactual=targetMethod.invoke(TestTarget.class,newObject[]{input});
assertEquals(expected,actual);
}
‘捌’ Java静态代码块和静态方法的区别
没有静态类，如果有什么需要提前实例化的话，参考下面方式
static
int
i;
static{
i=1;
}
public
static
void
f(){
system.out.println(i);
}
‘玖’ 请分析在JAVA中,静态类,抽象类,实例类,静态方法,抽象方法,接口,以及继承,实现的关系概念
如果真要看数的话，这些概念几页书都看不完！看完了你看不懂，还必须看十几页的范例，自己练习几十遍才能搞懂！
先声明一点：下面都是我个人的理解，但是否理解正确我不敢保证，所以如果因为我的误导使你有错误的理解，我在此表示抱歉。
我这里就用最简单的例子简单的说明：
1.静态方法：
1>类A里面有非静态方法b，则调用b方法是：new A().b();
实际原理：b并不存在内存中，需要实例化A来获取b
实际应用：b方法中需要用到A类里的变量
2>类A里面有静态方法b，则调用b方法是：A.b();
实际原理：b已经存在内存中，可通过A的名称直接调用，无需实例化A类
实际应用：b方法中不需要用到A类里的变量
2.静态类，只存在于内部类，如果内部类里面有静态方法，则内部类必须是静态类。实际应用中极少用到，至少我出来工作后从来没用到过。
1>类A里面啊有非静态类B，B里面有非静态方法c，调用c方法是：new A().new B().c();
2>类A里面啊有非静态类B，B里面有静态方法c，这种情况不存在！因为c是静态方法，B就必须是静态类！
3>类A里面啊有静态类B，B里面有静态方法c，调用c方法是：A.B.c();
1>类A里面啊有静态类B，B里面有非静态方法c，调用c方法是：new A.B().c();
3.实例类，就是一般的类和非静态内部类。没啥好说的。
4.抽象方法
只有方法名和传入参数，没有实现内容。
例如有一个方法c如下：
public void c(String printText) {
System.out.println(printText);
}
对应的抽象方法就是：
public void c(String printText);
但抽象方法只能放在“抽象类”和“接口”中
5.接口类，接口类里面只能放抽象方法，需要实现类来实现接口的抽象方法。
接口的目的有点类似书本的“目录”所起的作用，用户只需要关注方法实现了什么功能，而不用去关注具体实现方法的内容。
常见的例子有:
Set<String> set = new TreeSet<String>();
Set<String> set = new HashSet<String>();
同一个接口，则必须接口规定的固有属性，Set接口就是唯一性。
不同实现类，则具备不一样特殊属性：
TreeSet具备自动排序功能，但不能保存null
HashSet无序，但能存null
另外，一个实现类可实现（implements）多个接口类，但必须实现所有接口里面的所有抽象方法。
6.抽象类，夹在一般类和接口中间，可放普通方法，也可放抽象方法，但抽象方法必须加abstract。
例如：
abstract public void test();
抽象类如果被一般类所继承（extends），则一般类必须实现抽象类的抽象方法。
7.继承，所有类之间都有可以有一个继承关系，但要注意以下几点：
1>接口类只能继承接口类，可多继承
2>除接口类以为的所有类，只能单继承，即只能继承一个类，并且不能继承接口！
3>一般而言继承之后，子类就拥有父类的方法，但如果父类有方法是私有的，则即使继承也无法调用。
以上所说只是一个简单的概括，肯定有很多遗漏的细节！还是必须多看书！多练习！！
‘拾’ java中静态方法与非静态方法的区别
在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。