我的第三次JAVA作业

------------恢复内容开始------------

1.对象与对象引用的区别是什么? 请举例说明

创建对象被分配在堆中，对象引用分配在栈中。

eg.

new FighterPlane(); //创建对象 (相当于电视机)

FighterPlane fp; //声明一个对象引用(遥控器)

fp = new FighterPlane();  //初始化对象引用(指明遥控对象)

2.对象作为参数传递的特点是什么？请举例说明

对象是引用传递，当对象作为参数传递时，传递的是对象的地址。

 1 class IntClass
 2     {
 3       int value;
 4     }
 5 public class RunIntClass
 6  {
 7    public static void modifyValue(IntClass s,int val)
 8   {
 9    s.value = val;
10   }
11    public static void main(String args[])
12    {
13      IntClass  a = new IntClass();     //产生一个IntClass的对象，被a引用
14      modifyValue(a,8); //对a引用的对象赋值  执行该方法时"s=a"的含义是将a的地址传递给了s，而不是产生了新的对象，这样s和a所指的对象是同一个
15      System.out.println(a.value);     //显示a对象的属性
16    }
17 }

3.对象初始化顺序是怎样的？请举例说明

先初始化父类的静态代码--->初始化子类的静态代码-->初始化父类的非静态代码--->初始化父类构造函数--->初始化子类非静态代码--->初始化子类构造函数

 1 public class Father {
 2
 3   static final String STATIC_FIELD_01 = getFatherField("STATIC_FIELD_01");
 4
 5   private String field01 = getMemberFatherField("field01");
 6
 7   public Father() {
 8     System.out.println("父类构造方法！");
 9   }
10
11   static {
12     System.out.println("父类静态代码块！");
13   }
14
15   static final String STATIC_FIELD_02 = getFatherField("STATIC_FIELD_02");
16
17   static String getFatherField(String str) {
18     System.out.println("父类静态成员变量初始化-" + str);
19     return str;
20   }
21
22   {
23     System.out.println("父类代码块！");
24   }
25
26   private String field02 = getMemberFatherField("field01");
27
28   String getMemberFatherField(String str) {
29     System.out.println("父类静态成员变量初始化-" + str);
30     return str;
31   }
32
33   static class Son extends Father {
34
35   static final String STATIC_FIELD_01 = getSonField("STATIC_FIELD_01");
36
37     private String field01 = getMemberSonField("field01");
38
39     public Son() {
40       System.out.println("子类构造方法！");
41     }
42
43     static {
44       System.out.println("子类静态代码块！");
45     }
46
47     static final String STATIC_FIELD_02 = getSonField("STATIC_FIELD_02");
48
49     static String getSonField(String str) {
50       System.out.println("子类静态成员变量初始化-" + str);
51       return str;
52     }
53
54     {
55       System.out.println("子类代码块！");
56     }
57
58     private String field02 = getMemberSonField("field02");
59
60     String getMemberSonField(String str) {
61       System.out.println("子类成员变量初始化-" + str);
62       return str;
63     }
64
65
66   }
67
68   public static void main(String[] args) {
69     new Son();
70   }
71 }

4.类的static字段与非static字段的区别是什么？什么场景应该使用static修饰符？请举例说明

用static修饰的不属于任何一个类的具体对象，而专属于类。它被保存在类的内存区的公共存储单元中，而不是保存在某个对象的内存区中。因此，一个类的任意对象访问它，存取到的都是相同的数值。
static方法内部的代码，只能访问类中的static属性或方法，不能访问类中的非static属性或方法（因为它们属于对象），但非static可访问static属性或方法。

5.Java中final修饰符都有什么作用？请举例说明

final 变量：

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

 1 public class Test{
 2   final int value = 10;
 3   // 下面是声明常量的实例
 4   public static final int BOXWIDTH = 6;
 5   static final String TITLE = "Manager";
 6
 7   public void changeValue(){
 8      value = 12; //将输出一个错误
 9   }
10 }

final 方法

父类中的 final 方法可以被子类继承，但是不能被子类重写。

声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

1 public class Test{
2     public final void changeName(){
3        // 方法体
4     }
5 }

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。

1 public final class Test {
2    // 类体
3 }

6.Java中float[10] arr; 语句正确么？为什么？

不正确

7.Java数组元素类型为基本类型和引用类型时，有什么不同？请举例说明

数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内存空间，然后直接将数组元素的值存入对应数组元素中。
引用类型数组的数组元素是引用，因此情况变得更加复杂：每个数组元素里存储的还是引用，它指向另一块内存，这块内存里存储了有效数据。

------------恢复内容结束------------