课后作业

Posted 2020-10-11 什么名都不好

课后作业一：

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

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

程序流程图：

import java.util.Scanner;

public class Test {
    static int i = 0;
    public Test(){
        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++){
                Testi g = new Test();
            } 
            System.out.println("程序已经创建对象的个数为：" + getTimes());
        }
    }
}

 课后作业二：

1.这两种方式定义的变量是一样的吗？

Int value = 100;

MyClass obj = new MyClass();

不一样。

int “是原始数据类型”的变量。定义后，会马上给其分配内存。

MyClass “是对象变量”。声明一个对象类型变量时，实际没有创建一个对象，变量 = null。

2.对象变量可以用“==”判断两变量值是否相等吗？运行以下代码，得到什么结果？

不可以。判断的不是变量值。

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;
}

结果：false

当“==”施加于引用类型变量时，比较的是两个变量是否引用同一个对象。

3.如何比较两个对象“内容”是否一样？

比较“字段值”。可以重写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;
    /*注意：只有参数类型为Object的，才是重写了Object的equals方法
      参数类型为MyTestClass的，仅仅是Overload了equals方法。
       @Override
       public boolean equals(Object obj) {
       　　return ((MyTestClass)obj).Value == this.Value;
       }
　　*/
        public boolean equals(MyTestClass obj){
            return obj.Value == this.Value;
        }
        public MyTestClass(int initValue){
            Value = initValue;
        }
}

结果：flase 

　　　true

4.总结一下，这个方法有那些“与众不同”之处？

public MyTestClass(int initValue){
            Value = initValue;
}

这个方法是类的构造方法。它有参数值。

5.以下代码为何无法通过编译？哪出错了？

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()错误。

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

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

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

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

对象变量可以用“==”判断两变量值是否相等吗？运行以下代码，得到什么结果？

不可以。判断的不是变量值。

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

7.请运行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();
    }
}

结论： 1.静态初始化块只执行一次。

　　　 2.创建子类型对象时，父类静态初始化块也执行。

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

public class Test{
    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(){
    }
}    

9. 输出诡异的结果，原因何在？

public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
}
Integer cache类的实现：
 private static class IntegerCache {
        static final int high;
        static final Integer cache[];
        static {
            final int low = -128;
            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer\'s autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }
        private IntegerCache() {}
}

在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

上面的代码中i1和j1的数值为100，因此会直接从cache中取已经存在的对象，所以i1和j1指向的是同一个对象，而i2和j2则是分别指向不同的对象。所以输出不同。