JAVA第三次作业

1.对象和对象引用的区别是什么？请举例说明。

1.创建一个对象(堆）new FighterPlane();
2.声明对象引用 (栈）FighterPlane fp;
3.初始化对象引用 fp = new FighterPlane();

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

地址传递。值在修改后可以传回来。对象只有一个。

class IntClass {
	int value;
}
public class RunIntClass{
	public static void modifyValue(IntClass s,int val){
		s.vlaue=val;
	}
}
public static void main(String args[]){
		IntClass a =new IntClass();
		modifyValue(a,8);
		System.out.println(a.value);
	}
}

3.对象初始化顺序是什么？请举例说明。

//父类Animal
class Animal {  
/*8、执行初始化*/  
    private int i = 9;  
    protected int j;  
 
/*7、调用构造方法，创建默认属性和方法，完成后发现自己没有父类*/  
    public Animal() {  
/*9、执行构造方法剩下的内容，结束后回到子类构造函数中*/  
        System.out.println("i = " + i + ", j = " + j);  
        j = 39;  
     }  
 
/*2、初始化根基类的静态对象和静态方法*/  
    private static int x1 = print("static Animal.x1 initialized");  
    static int print(String s) {  
        System.out.println(s);  
        return 47;  
    }  
}  
 
//子类 Dog
public class Dog extends Animal {  
/*10、初始化默认的属性和方法*/ 
    private int k = print("Dog.k initialized");  
 
/*6、开始创建对象，即分配存储空间->创建默认的属性和方法。 
     * 遇到隐式或者显式写出的super()跳转到父类Animal的构造函数。
     * super()要写在构造函数第一行 */  
    public Dog() { 
/*11、初始化结束执行剩下的语句*/
        System.out.println("k = " + k);  
        System.out.println("j = " + j);  
    }  
 
/*3、初始化子类的静态对象静态方法，当然mian函数也是静态方法*/  
    private static int x2 = print("static Dog.x2 initialized");
 
/*1、要执行静态main，首先要加载Dog.class文件，加载过程中发现有父类Animal， 
    *所以也要加载Animal.class文件，直至找到根基类，这里就是Animal*/       
    public static void main(String[] args) {  
 
/*4、前面步骤完成后执行main方法，输出语句*/ 
        System.out.println("Dog constructor"); 
/*5、遇到new Dog()，调用Dog对象的构造函数*/  
        Dog dog = new Dog();   
/*12、运行main函数余下的部分程序*/            
        System.out.println("Main Left"); 
    }  
}

输出结果：
static Animal.x1 initialized
static Dog.x2 initialized
Dog constructor
i = 9, j = 0
Dog.k initialized
k = 47
j = 39
Main Left

参考原文

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

4.类的static字段和非static字段的区别是什么？什么情况一个使用static修饰符？请举例说明。

static 修饰的域变量不属于具体的对象而属于类，保存在堆中。
一个类的对象访问它得到的都是相同的数值。
1.类的静态属性可以被多类、多个对象引用共享访问。
2.充当类对象计数器。

public class CountObject(){
	private static int i = 0;
	CountObject(){
		i++;
	}
	public int getI(){
		return i;
	}
	public static void main (String args[]){
		CountObject t = new CountObject();
		t = CountObject();
		System.out.println(t.getI());
	}
}

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

以final修饰类属性，则该属性为常量；修饰方法，则方法为最终方法（在字类中不能被覆盖）

class Cat{
       private final int age = 0;
       public Cat(){
             age = 1;
             final Object obj = new Object();
              obj = new Object();
      }
}

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

不正确。定义数组不能在[ ]内指定数组大小。

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

前者数组中的元素全部为基本数据类型，后者存储的为对象的地址。
例：

MyClass[] mc = new MyClass[10];

产生一个类型为MyClass，可容纳10个MyClass对象引用的数组对象，每个单元的初始值为null