课后作业

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

设计思路：定义类的构造函数时使静态变量i进行i++,即每构造一次就叠加一个构造的对象数。

程序流程图：

　　 

源程序代码：

package tiaoshi;
import java.util.Scanner;
public class Tiaoshi 
{
    static int i=0;
    public Tiaoshi()
    {
        i++;
    }
    public static int getTimes()
    {
        return i;
    }
    public static void main(String[] args) 
    {
        int x=1;
        Scanner con=new Scanner(System.in);
        for(;x!=0;)
        {
            System.out.print("构建个数(0退出)：");
            x=con.nextInt();
            for(int t=0;t<x;t++)
            {
                Tiaoshi g=new Tiaoshi();
            }    
            System.out.println("程序已经创建对象的个数为："+getTimes());
        }
    }
}

结果截图：

　　 

2、验证ClassAndObjectTest.java（使用自定义类）

public class ClassAndObjectTest
{
    public static void main(String[] args)
    {
        //创建类的实例，定义一个对象变量引用这一实例
        MyClass obj = new MyClass();
        //通过对象变量调用类的公有方法
        obj.myMethod("Hello");
        //给属性赋值
        obj.setValue(100);
        //输出属性的当前值
        System.out.println(obj.getValue());
        //直接访问对象公有字段
        obj.Information = "Information";
        //输出对象公有字段的当前值
        System.out.println(obj.Information);
    }
}
class MyClass
{
    public String Information = "";
    public void myMethod(String argu)
    {
        System.out.println(argu);
    }
    private int value;
    public int getValue()
    {
        return value;
    }
    public void setValue(int value)
    {
        this.value = value;
    }
}

验证结果：

　　 

3、早期我们经常这样定义变量“int value=100;”,而前面的示例中这样定义变量“MyClass obj=new MyClass();”,这两种方式定义的变量是一样的吗？

　　这两种变量是不一样的。

　　前者是原始数据类型，例如int，float之类的变量，当声明一个原始数据类型的变量时,实际上并没有创建一个对象，此变量=null。

　　后者是引用类型变量，“引用”一个对象的变量称为“引用类型”的变量，定义一个原始类型的变量时,会马上给其分配内存，而对象变量的初始化中，该变量若不引用一个真实的对象，则必须声明为null。而且引用对象后的对象变量，且如果不再使用此变量，将会回收类定义的对象所占用的内存。

4、对于原始数据类型的变量（比如int)，可以直接使用“==”判断两变量值是否相等，那么对象变量也可以使用“==”判断两变量值是否相等吗？

　　不可以，类似于字符串的比较大小，使用equals()进行比较，用法与其相同。当“==”施加于“原始数据类型”变量时，是比较变量所保存的数据是否相等，当“==”施加于“引用类型”变量时，是比较这两个变量是否引用同一对象。引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。

5、请输入并运行以下代码，得到什么结果?

public class Test
{
    public static void main(String[] args)
    {
        Foo obj1 = new Foo();
        Foo obj2 = new Foo();
        System.out.println(obj1==obj2);
    }
} 
class Foo
{ 
    int value=100;
}

结果截图：

　　 

6、如何比较两个对象的“内容”是否一样？

　　“内容相等”，其实是就“对应字段值”一致。

　　在JAVA中要比对两个对象的字段值，可以 重写基类的equals()方法；Object是Java的最顶层基类，其中定义了equals( )方法。

　　重写基类的equals()方法：

public class ObjectEquals
{
    public static void main(String[] args)
    {
        MyTestClass obj1=new MyTestClass(100);
        MyTestClass obj2=new MyTestClass(100);
        System.out.println(obj1==obj2);
        System.out.println(obj1.equals(obj2));
    }
}
class MyTestClass
{
    public int Value;
     public boolean equals(Object obj)
     {
          return ((MyTestClass)obj).Value==this.Value;
     }
    public MyTestClass(int initValue)
    {      
        Value=initValue;
    }
}

结果截图：

　　 

7、以下代码为何无法通过编译？哪儿出错了？

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

　　结论：如果类提供了一个自定义的构造方法，就将导致系统不再提供默认构造方法。所以，“Foo obj1 = new Foo();”中需要添加默认的参数。

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

package tiaoshi;
public class Tiaoshi
{
    public static void main(String[] args)
    {
        tiao obj=new tiao();
        System.out.println(obj.field);
        obj=new tiao(300);
        System.out.println(obj.field);
    }
}
class tiao
{
    {
         field=200;
    }
    public int field=100;
    public tiao(int value)
    {
         this.field=value;
    }
    public tiao()
   {

    }
}

　　在“public int field = 100;”在“{field=200;}”之前时，是“{field=200;}”说了算；在之后时，是“public int field = 100;”说了算。也就是谁比较靠后就是谁初始化起作用。执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。

　　构造函数，类的初始化块不接收任何的参数，只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。

　　运行结果：

　　①“public int field = 100;”在“{field=200;}”之前：

　　 

　　②“public int field = 100;”在“{field=200;}”之后：

　　 

9、请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序”。

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();
        System.out.println("Mid的带参数构造器，其参数值：" + msg);
    }
}
class Leaf extends Mid
{
    static
    {
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }    
    public Leaf()
    {
        super("Java初始化顺序演示");
        System.out.println("执行Leaf的构造器");
    }
}
public class TestStaticInitializeBlock
{
    public static void main(String[] args)
    {
        new Leaf();
    }
}

结果截图：

　　 

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

public class text4
{
     public static void main(String[] args)
    {
          System.out.println("(静态变量)total_employees =  "+Employee.clear());
          Employee e = new Employee();
          System.out.print("(实例变量)name =  "+e.name);
    }
}
class Employee
{
     String name = "2";
     static int total_employees = 0;
     static int clear()
    {
         return total_employees;
     }
     static void clear2()
    {

    }
}

结果截图：

　　 

11、 两对整数明明完全一样，为何一个输出true，一个输出false？

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

　　通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，将返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。i1和i2的数值为100，所以会直接从cache中取已经存在的对象，所以i1和j1指向的是同一个对象，而i2和j2则是分别指向不同的对象。