课后作业3

一：使用自定义类

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

/**
 * 自定义Java类的示例
 */
class MyClass
{
    // 公有字段
    public String Information = "";

    // 自定义公有Java实例方法
    public void myMethod(String argu)
    {
        System.out.println(argu);
    }

    // 定义属性：私有字段+get方法+set方法
    private int value;
    public int getValue()
    {
        return value;
    }
    public void setValue(int value)
    {
        this.value = value;
    }

}

运行结果：

 小结：

需要定义一个对象变量 然后“创建（new）”一个对象，赋值给对象变量 现在就可以通过对象变量使用对象，主要方式有： （1）直接调用类的方法； （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

结论：

当“==”施加于原始数据类型变量时，是比较变量所保存的数据是否相等 当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象。 引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。

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

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

}

结果：

false

true

结论：两个对象的“内容”，其实是指它们在某一时刻的所有字段的值，“内容相等”，其实是就“对应字段值”一致。 在Java中要比对两个对象的字段值，可以 “重写（override）”基类的equals()方法

当你定义一个类时，如果不显式指明它的“父亲”类是哪个，则默认是Object。 Object是Java的最顶层基类，其中定义了equals( )方法

四、动手动脑：下面代码为何无法通过编译

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

结论：如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。

 五、进行实验：如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？以下代码输出结果是什么？

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

结果：

100

300

结论：类字段的初始化顺序：1执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”，排到后面的是最终执行的。 2执行类的构造函数

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

六、动手动脑：请运行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调用同一类中重载的构造器
        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();


    }
}

结果:

Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：Java初始化顺序演示
Leaf的普通初始化块
执行Leaf的构造器

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

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

解决方法：把静态方法的参数设置为类的实例，这样通过参数传递的方式就可以访问实例的成员了

public class Test
{
    public static void main(String[] args)
    {
    Testgaga T=new Testgaga();
    Testgaga X=new Testgaga();
    T.show(X);
    }
}
class Testgaga{
    int num=10;
    static void show(Testgaga T){
        System.out.println(T.num);
    }
}

结果：10

八、Integer的“诡异”特性”，上述神奇代码（StrangeIntegerBehavior.java）输出诡异的结果，原因何在？

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

    }


}

结果：

true 

false

结论：

当我们使用Integer类来包装整型数据时，Java会自动进行装箱操作，将整型数据封装为Integer对象。在这个过程中，对于较小的整数（范围在-128到127之间），Java会将它们缓存起来，以便提高性能和节省内存。

在你的代码中，i1和j1的值都是100，这个值在缓存范围内，因此当装箱操作发生时，Java会从缓存中返回同一个Integer对象。换句话说，i1和j1实际上引用的是同一个对象，因此它们比较相等，输出结果为true。

而对于i2和j2的值都是129，超出了缓存范围。当装箱操作发生时，Java会创建新的Integer对象来表示这个值。所以i2和j2实际上引用的是两个不同的对象，它们比较不相等，输出结果为false。

需要注意的是，这种缓存机制只适用于自动装箱，如果是使用new关键字手动创建Integer对象，不会应用缓存，即使数值相同，比较结果也会是false。