类与对象（作业）

一：默认构造

public class Test {
    public static void main(String[] args)
    {
        Foo obj1=new Foo();
    }
}
class Foo{
    int value;
    public Foo(int initValue)//自定义构造，导致系统不再提供默认的构造方法
    {
        value=initValue;
    }
}

以上代码错误，如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。

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

package lei;

public class mafan {
    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=200;
    }
    public int field=100;
    public InitializeBlockClass(int value)
    {
        this.field=value;
    }
    public InitializeBlockClass(){
        
    }
}

结果截图

结论：

所有类的变量都默认初始化null，数字类的原始数据类型默认初始化为0。

执行类成员定义的默认值或初始化块，优先于最新的那个，如上式的100。

执行类的构造函数，有多个构造函数，通过参数区分执行，创建类的对象时，就会立即执行。因此，适合于封装那些“对象创建时必须执行的代码”。

三：当多个类之间有继承关系时，创建子类对象会导致父类初始化块的执行

package lei;

class Da
{
    static
    {
        System.out.println("Da的初始化块");
    }
}
class Zhong extends Da
{
    static
    {
        System.out.println("Zhong的初始化块");
    }
}
class Xiao extends Zhong
{
    static
    {
        System.out.println("Xiao的初始化块");
    }
}
public class jicheng {
    public static void main(String[] args)
    {
        new Xiao();
    }
}

结果截图

四：静态初始化块的执行顺序

package lei;


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.创建子类型的对象时，也会导致父类型的静态初始化块的执行。

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

package lei;

class Fangfa
{
    public static void a()
    {
        System.out.println("类的方法");
    }
    public void b()
    {
        System.out.println("对象的方法");
    }
}
public class jingshi {
    public static void main(String[] args)
    {
        Fangfa.a();
        Fangfa LOL=new Fangfa();
        LOL.b();
        LOL.a();
    }
}

结果截图

六：神奇代码

package lei;

public class StrangeIntegerBehavior 
{
    public static void main(String[] args)
    {
        Integer i1=100;
        Integer j1=100;
        System.out.println(i1==j1);
        Integer i2=129;
        Integer j2=129;
        System.out.println(i2==j2);
    }
}

结果截图

结论：

Integer=100; 实际上调用的是Integer.valueOf(int i);
因为从-127到128之间的Integer数，Java在Integer中有事先缓存好的原型对象，每次返回的都是同一个Integer对象，只有不在这个范围的数才会新创建出一个Integer,最后所指都不是同一个对象，所以比较的不是同一个对象。

七：出问题啦！

建立包jxl后，将Hello.class移入jxl包里后，可运行

八：不使用Eclipse，直接使用命令行运行Test1.java，Test2.java，Test3.java

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

package lei;

public class countDuixiang {
    public static void main(String[] args)
    {
        Face w1=new Face();
        Face w2=new Face();
        Face w3=new Face();
        System.out.println("你已经创建了"+Face.count+"个对象");
    }
}
class Face
{
    static int count;
    public Face()
    {
        count++;
    }
}

结果截图