Java第五次作业

1. 实验：利用IDE的debug功能给例6.4和例6.5的new语句设置断点，使用单步调试（step into/step over）跟踪子类对象实例化（初始化）的执行顺序，并总结该过程。      

1）为对象分配内存空间，对成员变量进行默认的初始化。（局部变量必须进行显示初始化）

2）绑定构造方法，将new中的参数传递给构造方法的形式参数。

3）调用this或super语句（二者必居其一，不能同时存在）

4）进行实例变量的显示初始化操作。如：

public class A{
2     int value=4;        //显示初始化
3     B b = new B();    //显示初始化，注： B为另一个类
4 }

5）执行当前构造方法的方法体中的程序代码。

2. 如何实现两个对象之间互发消息，请举例说明。      

运用类的组合，把一个类的引用作为另一个类的属性.

class A{
	private int x;
	public A(){x=5;}
	public void show(){
	System.out.println(x);
	}
}

class B{
     private A a; 
     public void show(){
     a=new A();
     A.show();}
}
}

3. 谈谈组合与继承的区别以及两者的使用场景（即什么时候宜用组合 ？什么时候宜用继承？）。  

组合与继承的区别：
继承是子类继承父类，父类的所有属性和方法都可以被子类访问和调用。

组合是指将已存在的类型作为一个新建类的成员变量类型，两个类之间无上下级关系。

使用场景
当你只需要使用另外一个类的方法时使用组合。
但是如果你需要使用另外一个类的作用时但你不想被其他的类访问用继承。

4. Java中的运行时多态的含义是什么？有什么作用？请举例说明。      

     从字面上理解为，一类事物在不同的环境下以不同的形态存在并发挥着不同的功能。就好比是一个人他从事多项不同的工作，那么他在不同的工作中所承担着的作用和具体的职位是不同的，他具体是什么形态取决于他当前正在干的工作。

      在 Java 及其他的编程语言中，多态是一种很重要的特性。它是面向对象编程 4 种特性（封装、继承、多态、抽象）其中一种。体现了面向对象编程同面向过程编程的不同。

6. 自定义一个类，覆写equals方法，以满足自身业务需求      

public class Student {
    public String sn;
    public String name;
    public int age;
    public int gender;

    public static boolean equals(Object obj){
        if(obj==null)
            return false;
        if(!(obj instanceof Student))
            return false;
        if(this==obj)
            return true;
        return sn.equals((Student)obj.sn);
        
    }
}

7. 举例说明运算符instanceof的使用场景。      

public interface A {
}
 
public class B implements A{
 
}
 
public class C extends B{
}
public class InstanceofTest3 {
 
    public static void main(String[] args) {
        A a = null;
        B b = null;
        boolean result;
        result = a instanceof A;
        System.out.println(result); // 结果：false null用instanceof跟任何类型比较时都是false
        result = b instanceof B;
        System.out.println(result); // 结果：false null用instanceof跟任何类型比较时都是false
 
 
        a = new B();
        b = new B();
        result = a instanceof A;
        System.out.println(result); // 结果：true a是接口A的实例对象引用指向子类类B，类B实现了接口A，所以属于同一个继承树分支
        result = a instanceof B;
        System.out.println(result); // 结果：true a是接口A的实例对象引用指向子类类B，类B实现了接口A，所以属于同一个继承树分支
        result = b instanceof A;
        System.out.println(result);// 结果：true b是类B的实例对象，类B实现了接口A，所以属于同一个继承树分支
        result = b instanceof B;
        System.out.println(result);// 结果：true b是类B的实例对象，类B实现了接口A，所以属于同一个继承树分支
 
 
        B b2 = new C();
        result = b2 instanceof A;
        System.out.println(result); // 结果：true b2是父类B引用指向子类C，类B实现了接口A，所以属于同一个继承树分支
        result = b2 instanceof B;
        System.out.println(result); // 结果：true b2是父类B引用指向子类C，所以属于同一个继承树分支
        result = b2 instanceof C;
        System.out.println(result); // 结果：true b2是父类B引用指向子类C，所以属于同一个继承树分支
    }
}

8. 谈谈抽象类与接口的异同以及两者的使用场景。

相同点：

1)抽象类和接口都不能被实例化

2) 抽象类和接口都可以定义抽象方法，子类/实现类必须覆写这些抽象方法

不同点：

1) 抽象类有构造方法，接口没有构造方法

2) 抽象类可以包含普通方法，接口中只能是public abstract修饰抽象方法

3) 抽象类只能单继承，接口可以多继承

4)抽象类可以定义各种类型的成员变量，接口中只能是public static final修饰的静态常量

5) 抽象类在被继承时体现的是is-a关系，接口在被实现时体现的是can-do关系。

抽象类使用场景：

继承父类的子类之间具有共同的行为，父类设计成抽象类是对同类对象抽象方法的共同行为的抽取。

接口的使用场景：

1. 约束多个实现类具有统一的行为，但是不在乎每个实现类如何具体实现

2. 作为能够实现特定功能的标识存在，也可以是什么接口方法都没有的纯粹标识。

3. 实现类需要具备很多不同的功能，但各个功能之间可能没有任何联系。

4. 使用接口的引用调用具体实现类中实现的方法（多态）