类与对象--课后作业2

一、

1、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、InitializeBlockDemo.java

代码:

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(){

 

}

}

截图:

3、ObjectEquals

代码:

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;

    

}

 

}

截图:

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

    

}

 

 

}

截图：

5、Test1.java

代码：

public class Test1

{

public static void main(String args[])

{

String str="abcd";

    StringBuffer buff=new StringBuffer();

for(int i=str.length()-1;i>=0;i--)

buff.append(str.charAt(i));

System.out.println(buff.toString());

}

}

截图：

6、Test2.java

代码：

public class Test2

{

public static String reverseString(String inputStr)

{

StringBuffer buff=new StringBuffer();

 

for(int i=inputStr.length()-1;i>=0;i--)

buff.append(inputStr.charAt(i));

 

return buff.toString();

}

 

public static void main(String args[])

{

String str="abcd";

System.out.println(reverseString(str));

}

}

截图：

7、Test3.java

代码：

import jxlPacakge.MyPackageClass;

 

public class Test3

{

public static void main(String args[])

{

String str="abcd";

System.out.println(MyPackageClass.reverseString(str));

}

}

截图：

8、Root.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();

 

 

}

}

截图：

9、BoxAndUnbox.java

代码：

public class BoxAndUnbox {

 

/**

 * @param args

 */

public static void main(String[] args) {

int value=100;

 

Integer obj=value;  //装箱

 

int result=obj*2;     //拆箱

 

}

 

}

二、

1、int value=100;

   MyClass obj=new MyClass();

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

答：一样。只不过前者为原始数据类型，后者为引用类型，该类型定义后开辟内存空间。

2、对象变量也可以用”==”判断两变量值是否相等吗？

答：不可以，只能用”equals”。”==”比较的是两个对象的地址，而”equals”比较的是两个对象的内容。

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

  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=100;

}

结果截图

4、代码如下：class MyTestClass{

public int value;

public boolean equals(MyTestClass obj){

return obj.value==this.value;}

public MyTestClass(int initValue){

value=initValue;}

}

请判断public MyTestClass(int initValue){value=initValue;}这个方法有哪些与众不同之处。

答：1、方法名与类方法名相同；

    2、该方法没有类型；

    3、参数列表中参数的类型与类中变量的类型一致，并对类中的变量进行了赋值；

 

5、以下代码为何无法通过编译？

   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;

  public Foo(int initValue) {

value=initValue;

  }

}

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

6、代码如下

   public class Test {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

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

{}

}

请依据代码的输出结果，总结java字段初始化的规律。

结果截图

java进行初始化的地方有两个：初始化块和构造函数，其中初始化块又分为静态初始化块和实例初始化块。静态初始化块是类中由static修饰的初始化块，实例初始化块为类中没有任何关键字修饰的初始化语句。如果在主函数中创建对象时没有形参时，如果在类中定义了公共的变量并给与了赋值，那么就会把值赋给主函数中的变量，再调用类中的默认构造函数，如果在主函数中创建对象时有形参，则调用类中对应的构造函数。

7、请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序“。

结果截图

结论：静态初始化块的优先级最高，也就是最先执行，并且仅在类第一次被加载时执行；

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

答：可以先创建对象，再通过对象访问实例成员。

例：代码如下：

public class Test {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

Temp t=new Temp();

t.show();

}

 

}

class Temp{

public int t1=100;

public static int t2=200;

public static void show()

{

System.out.println(t2);

Temp t3=new Temp();

System.out.println(t3.t1);

}

}

结果截图

9、Integer类的装箱和拆箱到底是怎样实现的？

答：装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。

10、看以下代码 public static void main(String args[]){

Integer i1=100;

Integer j1=100;

System.out.println(i1==j1); //true

Integer i2=129;

Integer i3=129;

System.out.println(i2==i3);  //false

}

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

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