类与对象 - 课后作业2

Posted 2020-10-11

1 . Demo: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);
}
}
/**
* 自定义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;
}

}

 

 

      运行截图：

 

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

不一样，第一种方式定义的是普通类成员变量，定义这样的原始类型变量时，会马上给其分配内存。第二种定义的是类对象变量时，实际上并没有创建一个对象，此变量=null

 

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

 

结果截图：

4 . Demo: ObjectEquals.java

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(MyTestClass obj)
   
		{
			return obj.Value==this.Value;
		}
    
		public MyTestClass(int initValue)
    
		{
			Value=initValue;    
		}
}

　　结果截图：

5 . 请总结一下，这个方法有哪些“与众不同之处”，你能列出几条？

 

没有基本类型，没有返回值。类的构造方法也叫构造函数，构造方法与类名相同，没有返回值。如果类没有定义构造函数，java会自动提供一个没有参数的默认构造方法。

 

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

 

class foo{}类提供了一个自定义构造方法public foo(int v),导致系统不再提供默认构造方法。

 

7 . 以下代码输出结果是什么？

 

结果截图：

依据代码的输出结果，自行总结Java字段初始化的规律。

初始化顺序：执行类成员定义时指定的默认值或类的初始化块，哪一个在前面就先执行哪一个。类的初始化块适合封装那些对象创建时必须执行的代码。

 

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

　　结果截图：

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

静态初始化块只执行一次。创建子类型的对象时，也会导致父类型的静态初始化块的执行。其执行顺序为1.父类的静态初始块2.子类的静态初始块3.父类的静态初始化块4.子类初始化块。

 

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

编写代码：

public class Jingtai {
public  int num;
 static void change(Jingtai a)
 {
 a.num=10;
 }

public static void main(String[] args)
{

Jingtai b=new Jingtai();

b.num=100;

b.change(b);

System.out.println(b.num);
}
}

　　输出结果为10

分析：通常情况下，静态方法是不能访问类的非静态成员函数以及非静态的变量，因为类里边的静态成员属于类，不用声明类的对象时，静态成员就已经存在了，而非静态成员必须在声明类的对象后才可以分配内存空间，所以类的对象不可以访问类中静态成员。但是，如果先要在静态成原函数中调用非静态中的变量或方法，可以在静态成员函数中声明一个类的对象，然后再调用类的非静态成员或方法。

 

10 .  Integer类的装箱和拆箱到底是怎样实现的？

装箱，就是把基本类型用他们相对应的引用类型包装起来，使他们可以具有对象的特质，如可以把int型包装成Integer类的对象，或者把double包装成Double等等。

拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据。

在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。以这两种方法实现拆箱装箱。

 

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

 

输出结果表明i1和j1指向的是同一个对象，而i2和j2指向的是不同的对象。

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