class A
{
        static int i;
        static int j = 10;
        static boolean falg;
        public static void show()
        {
                System.out.println("i=" + i);
                System.out.println("j=" + j);
                System.out.println("falg=" + falg);
        }
}
class B
{
        static int i;
        static int j = 10;
        static boolean falg;
        public B()
        {
                System.out.println("以前的值是" + i +""+ j +"" +falg);
                i = 88;
                j = 99;
          falg = true;
        }
        public static void show()
        {
                System.out.println("i =" + i);
                System.out.println("j =" + j);
                System.out.println("falg =" + falg);
        }
}
public class test
{
        public static void main(String[] arge)
        {
   A.show();
   B.show();
          }
}如上所示：A.show(); B.show();输出为0 。10 。false ，类B中构造函数赋值没有发挥作用？是什么原因导致的？

你的代码先执行的输出，然后执行的赋值动作啊！

1.   public static void main(String[] arge)
   
2.         {
   
3.                 //B b=new B(); 因为你都是静态方法 B的构造方法没有执行， 你把我注释的加进去就好了
   
4.    A.show();
   
5.    B.show();
   
6.           }
   
7. }

复制代码

     }
        public static void show()//因为show()方法是静态的
        {
                System.out.println("i =" + i);
                System.out.println("j =" + j);
                System.out.println("falg =" + falg);
        }
}
public class test
{
        public static void main(String[] arge)
        {
   A.show();，
   B.show();//因为show()方法是静态的，你用类名直接调用，也就是说你没创建对象，所以没用调用构造方法啊
          }
}

static：关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。
特点：
1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
2，被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
3，静态随着类的加载而加载。而且优先于对象存在。

弊端：
1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
2，静态方法只能访问静态成员，不可以访问非静态成员。
　　因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
3，静态方法中不能使用this，super关键字。
　　因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
4，主函数是静态的。

B类中的show方法是静态的，
构造函数之间的调用只能通过this语句来完成
构造函数之间进行调用时this语句只能出现在第一行,初始化要先执行，如果初始化当中还有初始化，那就去执行更细节的初始化
在java中定义静态方法
1.静态的方法只能访问静态的成员
2.非静态的方法既能访问静态的成员（成员变量，成员方法）也能访问非静态成员
3.静态的方法中是不可以定义this super关键字
因为静态优先于对象存在，所以静态方法不可以出现this

1. class A
   
2. {
   
3.         static int i;
   
4.         static int j = 10;
   
5.         static boolean falg;
   
6.         public static void show()
   
7.         {
   
8.                 System.out.println("i=" + i);
   
9.                 System.out.println("j=" + j);
   
10.                 System.out.println("falg=" + falg);
    
11.         }
    
12. }
    
13. class B
    
14. {
    
15.         static int i;
    
16.         static int j = 10;
    
17.         static boolean falg;
    
18.      
    
19.         {
    
20.                 System.out.println("以前的值是" + i +""+ j +"" +falg);
    
21.                 i = 88;
    
22.                 j = 99;
    
23.           falg = true;
    
24.         }
    
25.         public void show()//把这里改成非静态的方法
    
26.         {
    
27.                 System.out.println("i =" + i);
    
28.                 System.out.println("j =" + j);
    
29.                 System.out.println("falg =" + falg);
    
30.         }
    
31. }
    
32. public class Test
    
33. {
    
34.         public static void main(String[] arge)
    
35.         {
    
36.                 B b=new B();
    
37.                 b.show();
    
38.                 A.show();
    
39.                 //在这里做了一些改动，希望你能看的明白
    
40.    
    
41.           }
    
42. }

复制代码

class A {
        static int i;
        static int j = 10;
        static boolean falg;

        public static void show() {
                System.out.println("i=" + i);
                System.out.println("j=" + j);
                System.out.println("falg=" + falg);
                System.out.println();
        }
}

class B {
        static int i;
        static int j = 10;
        static boolean falg;

        public B() {
                System.out.println("以前的值是: " + i + " " + j + " " + falg);
                i = 88;
                j = 99;
                falg = true;
        }

        public static void show() {
                System.out.println("i =" + i);
                System.out.println("j =" + j);
                System.out.println("falg =" + falg);
                System.out.println();
        }
       
        public static void show1() {
                System.out.println("现在的值是: " + i + " " + j + " " + falg);
        }
}

public class test {
        public static void main(String[] arge) {
                /*
                 * 由于静态成员变量是在类加载时就放入内存的方法区中了，并且给予赋值
                 * 所以A.show()打印的就是classA中三个静态成员变量的初始值
                 */
                A.show();//打印结果为0、10、false
               
                /*
                 * 静态成员变量和静态成员方法在调用时不需要创建对象，直接用类名即可调用。
                 * 所以B.show()并不触发classB的构造方法，也是直接打印的classB中三个静态成员变量的初始值
                 */
                B.show();//打印结果为0、10、false
               
                /*
                 * 以下方法实现方法会导致classB中三个静态成员变量的值发生变化
                 * 即在创建classB的对象b时触发了调用classB的构造函数B()
                 * 使得classB中三个静态成员变量的值分别被修改为88、99、true
                 */
                B b = new B();
                B.show1();//打印结果为88、99、true
        }
}

有对象才会运行构造函数的，你都没建立对象，

执笔梦 发表于 2014-4-27 20:48
}
        public static void show()//因为show()方法是静态的
        {

那为什么A。show（）又生效了呢？

爱翚 发表于 2014-4-27 23:22
class A {
        static int i;
        static int j = 10;

那classA是否运行了构造函数？直接用类名加方法访问类，不能是类中的构造函数生效？而构造函数是否属于类本身？

houyudong 发表于 2014-4-28 09:45
那classA是否运行了构造函数？直接用类名加方法访问类，不能是类中的构造函数生效？而构造函数是否属于类 ...

类中的静态成员变量和静态成员方法，都是在类一加载时就进入了内存的方法区，通过类名是可以直接使用的。
而构造函数是在创建类的对象时调用的，其它情况不会调用构造函数。
也就是说通过类名直接调用静态成员或静态方法时是不会调用构造函数的。

在内存的方法区中也分静态和非静态，也就说静态成员变量和静态成员方法和构造函数在方法区中是存储在不同区域的。

A.show()和B.show()都是一样的，都没有调用任何构造函数。