类与对象——动手动脑

一、

public class Test{
 
       public static void main(String[] args){
                foo obj1=new Foo();
       }
}

class Foo{
      int value;
      public Foo(int initValue){
             value=initValue;
      }
}

错误的原因是foo（）里面没参数 因为函数定义了一个带有一个参数的构造函数 ,当调用函数是如果自己定义了必须使用这个方法.

二、

public class InitializeBlockDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        InitializeBlockClass obj=new InitializeBlockClass();
        System.out.println(obj.field);
        
        obj=new InitializeBlockClass(300);
        System.out.println(obj.field);
    }

}

class InitializeBlockClass{
    //下面这句在初始化块之前与之后，会影响到field字段的初始值
    //public int field=100;
    
    {
        field=200;
    }
    public int field=100;
    public InitializeBlockClass(int value){
        this.field=value;
    }
    public InitializeBlockClass(){
        
    }
}

静态初始化生成实例（new之后）变成你赋给他的值，先执行静态初始化，如果没有实例化，按照初始化和构造方法在程序中出现的顺序执行。

三、

class Root
{
    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root()
    {
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root
{
    static{
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid()
    {
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String msg)
    {
        //通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值：" + msg);
    }
}
class Leaf extends Mid
{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }    
    public Leaf()
    {
        //通过super调用父类中有一个字符串参数的构造器
        super("Java初始化顺序演示");
        System.out.println("执行Leaf的构造器");
    }

}

public class TestStaticInitializeBlock
{
    public static void main(String[] args) 
    {
        new Leaf();
        

    }
}

首先执行的是父类静态初始化模块，然后是子类静态初始化模块，然后再是由父类到子类依次执行普通、无参、有参的构造器。

静态初始化块的执行顺序：1.静态初始化块只执行一次。2.创建子类型的对象时，也会导致父类型的静态初始化块的执行。

四、在静态方法中访问类的实例成员

public class Test
{
 int x=1;
 static int  y=2;
 public static void method()//静态方法
  {   
   System.out.println("实例变量x = " + new Test().x);//在静态方法中访问类的实例变量需首先进行类的实例化
   System.out.println("静态变量y = " + y);//在静态方法中可直接访问类的静态变量
  }
 public static void main(String[] args) 
    {
         Test.method();
         Test t = new Test();
        System.out.println("x = " + t.x);
    }
}

先实例化类，得到一个实例变量，将要使用的类作为参数传给静态方法

五、使用类的静态字段和构造函数，可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？“。

public class Test {
    private static int n = 0;
    public Test() {
        n++;
    }
    public static int getNum() {
        return n;
    }
    
    public static void main(String[] args) {
     Test t1 = new Test();
     Test t2 = new Test();
     Test t3 = new Test();
        System.out.println("已生成对象个数为：" + Test.getNum());
    }
}