java类和对象上机作业,java 作业04 类和对象

思考问题1

早期我们经常这样定义变量

int value=100；

前面的示例中这样定义变量

MyClass.obj=new MyClass();

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

不一样。前者定义的是原始数据类型变量，在定义原始数据变量时就为变量开辟了空间；后者是定义了对象的变量，并用构造方法为其开辟内存空间。

思考问题2：

对原始数据类型，可以直接使用“==”来判断两个变量的值是否相等。

对象变量也可以使用“==”来判断两变量的值是否相等吗？

不可以。

当“==”施加在两个原始数据类型变量时，是比较两个变量的值是否相等。施加在引用类型变量时，是比较这两个变量是否引用同一个对象。即比较两个引用类型变量所保存的对象地址是否一样。

在java中要比较两个对象的字段值，可以“重写(override)”基类的equals()方法，只有参数类型为Object的，才是重写了Object的equals方法；参数类型为其他类时要Overload了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;

}

}

思考问题3：

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

1)方法名与类名相同；

2)方法名的第一个首字母大写了；

思考问题4：

上面代码为何无法通过编译？哪儿出错了？

引用构造方法new Foo()时缺少参数。

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

思考问题5：

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

如果父类中有静态成员赋值或静态初始化块，执行静态成员赋值或静态初始化块。如果类中有静态成员赋值或静态初始化块，执行静态成员赋值或静态初始化块将类的成员赋予初值。类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。如果有构造方法，则以构造方法为准。

实例

执行示例，输出结果为

根据输出结果，总结java初始化输出字段的规律

1.执行类成员定义时指定的默认值或类的初始化模块，到底执行哪一个要看哪一个“排在前面”,执行排在后面的。

2、如果有构造方法，则以构造方法为准。

3、类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。

思考问题6：

运行示例，观察结果，总结静态初始化块的执行顺序：

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、super()可以访问父类中初始化方法。有静态初始化块的，从父类开始执行静态初始化块，再执行子类的静态初始化块；再开始执行父类普通的初始化块，原始构造函数，重载构造函数，子类的同理。

思考问题7：

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

通过参数访问实例成员 具体代码如下：

public class Test2 {

public static void main(String[] args)

{

Test t=new Test();

int a=t.getyear();

t.input1();

Test.input(a);

t.input(a);

}

}

class Test

{

int year = 100;

public int getyear()

{

return year;

}

public static void input(int a)

{

System.out.println("静态"+a);

}

public void input1()

{

System.out.println("实例");

}

}

运行结果

思考问题8：

两个整数明明完全一样，为何一个输出

true，一个输出false？

调用了java.lang.String类，包含了字符串的值和实现比较特殊，可以不适用构造方法，就可以直接获得一个字符串对象。

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

package text;

class Number

{

static int i=0;

public Number()

{

i++;

}

public void out()

{

System.out.println("你已经创建了"+i+"个对象！");

}

}

public class Text {

public static void main(String[] args) {

// TODO Auto-generated method stub

Number n1=new Number();

n1.out();

Number n2=new Number();

n2.out();

Number n3=new Number();

n3.out();

}

}

原文：http://www.cnblogs.com/jingxiaopu/p/5978343.html