第三次作业

    此程序 出错再哪里？

public class Test {

public static void main(String[] ss)

{Foo obj =new Foo();

}

}

class Foo

{

int value;

public Foo(int initValue)

{

value=initValue;

}}

错的贼明显 这个Foo类构造带参数的方法调用时必须使用带参数的方法。或者你把默认构造方法参数写上去public Foo（）{}也不会报错；

如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？

思路 ：所谓非静态初始化块 定义为{}

执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，在每个对象生成时都会被执行一次，它可以初始化类的实例变量。非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。

执行优先级：2

class InitializeBlockClass

{

{ field=200;}

public int field=100; 

public InitializeBlockClass(int value)

{ 

 this.field=value;}

public InitializeBlockClass()

{

}

public static void main(String[] args) {

InitializeBlockClass obj=new InitializeBlockClass(); 

System.out.println(obj.field);

obj=new InitializeBlockClass(300); 

System.out.println(obj.field);

}

}

运行结果为 100 300 

初始化第一次是用了类的初始化块，第二次用了public的int初始化，所以第二次覆盖了第一次，输出了100；

         在main函数中给类InitializeBlockClass赋初值300，所以覆盖100，输出300；                                                                                                                                                                                                                                                                     

         所以类的初始化有类的初始化块，还可以直接在类中赋值，还可以用一个函数为类的属性赋值，还可以构造函数

但是你如果将{ field=200;} public int field=100; 这两句话换换位置输出结果就位 200 300 后来定义的被覆盖了....执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。

          初始化顺序和初始化块问题

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的构造器");

}

}

class jingtai

 {

public static void main(String[] args) 

{

new Leaf();

}

}

运行结果如下

Root的静态初始化块

Mid的静态初始化块

Leaf的静态初始化块

Root的普通初始化块

Root的无参数的构造器

Mid的普通初始化块

Mid的无参数的构造器

Mid的带参数构造器，其参数值：Java初始化顺序演示

Leaf的普通初始化块

执行Leaf的构造器

1 父类静态初始化块执行

2 子类静态初始化块依次执行

3 父类普通初始化块和无参数构造器依次执行

4带参数构造器依次执行

5最后执行本类普通初始化块 和构造器

静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?

public class demo {

int x=88;

static int y=99;

public static void sop()

{

System.out.println("非静态输出"+new demo().x);

System.out.println("静态数字输出"+y);

}

public static void main(String[] args)

{

sop();

}

}

静态引用非静态除了加关键字static就是new出对象调用其中的变量或者不是静态方法的成员函数。

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

import java.util.Scanner;

 class countobject {

public static void main(String[] dd)

{Demo1 d =new Demo1();

Scanner sc =new Scanner(System.in);

int search=0;

while(true)

{System.out.println("输入你要选项-----输入-1关闭");

System.out.println("1 创建");

System.out.println("2 查询次数");

search=sc.nextInt();

if(search==1)

{

d.creatDemo();

}

if(search==2)

System.out.println("你创了对象"+(d.count-1)+"次");

if(search==-1)break;

}

}

}

class Demo1

{

static int count=1;

public void creatDemo()

{new Demo1();

}

public Demo1 ()

{System.out.println("创建了"+count+++"次");

}

}