首页 > 代码库 > JAVA作业 04 类与对象

JAVA作业 04 类与对象

一.动手动脑

1)题目要求:验证ClassAndObjectTest.java(使用自定义类)

2)源代码:

技术分享
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 = http://www.mamicode.com/value;>

3)实验结果截图:

技术分享

4)实验分析:从结果来看,我们需要定义一个对象变量,然后“创建(new)”一个对象,赋值给对象变量。

 

二.解决问题

早期我们经常这样定义变量“int value=http://www.mamicode.com/100;”,而前面的示例中这样定义变量“MyClass obj=new MyClass();”,这两种方式定义的变量是一样的吗?

不一样。

前者为“原始数据类型”,诸如int,float之类的变量;

后者为“引用类型”变量,“引用”一个对象的变量称为“引用类型”的变量,有时又简称为“对象变量”。

从变量与内存分配上讲,当声明一个对象类型的变量时,实际上并没有创建一个对象,此变量=null。定义一个原始类型的变量时,会马上给其分配内存。
从变量的初始化上讲,在定义原始变量时,Java要求必须显式初始化变量;而对象变量的初始化:对象变量如果不引用一个真实的对象,则必须声明为null。
而且引用对象后的对象变量,如果不再使用此变量,JVM会回收MyClass对象所占用的内存(垃圾回收)。

 

三 解决问题

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

验证相关程序:

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
Foo obj1 = new Foo();
Foo obj2 = new Foo();
System.out.println(obj1==obj2);
    }
}
class Foo{
    int value=http://www.mamicode.com/100;>

运行结果:

技术分享

结论:不可以,类似于字符串的比较大小,使用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=http://www.mamicode.com/=this.Value;>

其运行结果如下:

技术分享

 

四.解决问题

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

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

注:当你定义一个类时,如果不显式指明它的“父亲”类是哪个,则默认是Object。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;
    
    //注意:只有参数类型为Object的,才是重写了Object的equals方法
    
    //参数类型为MyTestClass的,仅仅是Overload了equals方法。
 
      @Override

     public boolean equals(Object obj) 
   {
 return ((MyTestClass)obj).Value=http://www.mamicode.com/=this.Value;>

运行结果:

技术分享

2)除了重写基类的equals方法,我们也可以“重载(overload)”equals( )方法:

注意:与前面“重写”方式的代码相比,equals( )方法的参数类型是MyTestClass而不是Object,并且方法本身也没有附加“@Override”标记。

 

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方法。
 
      public boolean equals(MyTestClass obj)
   
    {
       
        return obj.Value=http://www.mamicode.com/=this.Value;>

运行结果:

技术分享

 

五.解决问题

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

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
     Foo obj1 = new Foo();
    }
}
class Foo{
    int value;
public Foo(int initValue){
    value=http://www.mamicode.com/initValue;>

结论:如果类提供了一个自定义的构造方法,将导致系统不再提供默认构造方法。所以可以将“Foo obj1 = new Foo();”改为“Foo obj1 = new Foo(4);”。

 

 六.解决问题

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

如:技术分享

 在“public int field = 100;”在“{field=200;}”之前时,是“{field=200;}”说了算;在之后时,是“public int field = 100;”说了算。也就是谁比较靠后就是谁初始化起作用。

注:执行类成员定义时指定的默认值或类的初始化块,到底执行哪一个要看哪一个“排在前面”。执行类的构造函数。类的初始化块不接收任何的参数,而且只要一创建类的对象,它们就会被执行。因此,适合于封装那些“对象创建时必须执行的代码”。

具体程序如下:

public class InitializeBlockDemo {

    /**
     * @param args
     */
    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字段的初始值
    public int field=100;//在之前
    {
        field=200;
    }
    //public int field=100;//在之后
    public InitializeBlockClass(int value){
        this.field=value;
    }
    public InitializeBlockClass(){   
    }
}

运行结果:

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

技术分享

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

技术分享

 

七.解决问题

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

 运行结果:

技术分享

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

 

 

八.解决问题

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

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

public class text4 {

 public static void main(String[] args) {
 // TODO Auto-generated method stub
  //静态
  System.out.println("(静态变量)total_employees =  "+Employee.clear());
  //实例
  Employee e = new Employee();
  System.out.print("(实例变量)name =  "+e.name);
 }

}
class Employee
{
 String name = "2";
 //long salary;
 //short employee_id;
 static int total_employees = 0;
 static int clear(){
  return total_employees;
 }
 static void clear2(){
 }
 }

运行结果:

技术分享

 

JAVA作业 04 类与对象