《Java面对对象程序设计》第六章课后习题

这篇博客是老师布置的作业。
《Java面对对象程序设计》第六章课后习题
开始吧！

1. this和super各有几种用法？

this：

1. 消除歧义，区分同名的成员变量和形参
2. 在构造函数中我们可以使用this来调用同一类的其他构造函数
3. 内部类中的this仍旧代表内部类所在类，即外部类对象。可以使用它从内部类访问外部类实例

super：

1. 可以使用super调用父类构造函数，且放在构造函数的第一句。
2. 访问父类变量

2. 子类对象实例化的具体过程是什么？

Person p = new Person();
1、JVM会读取指定路径下的Person.class文件，并加载进内存。并会先加载Person的父类（如果有直接的父类的情况下）
2、在堆内存中开辟空间，分配地址。
3、并在对象空间中，对对象中的属性进行默认初始化。（不是显式初始化）
4、调用对应的构造函数进行初始化。
5、在构造函数中，第一行会先调用父类的构造函数进行初始化。
6、父类初始化完毕后，在对子类的属性进行显式初始化。
7、再进行子类构造函数的特定初始化。
8、初始化完毕够，将地址值赋值给引用变量。

3. 类的域变量和方法中定义的局部变量在初始化上有何区别？

类的域变量在类实例化的时候进行初始化，方法中的局部变量在方法内部显式初始化

4.模仿形成抽象类的过程，自选角度，形成一个自己的抽象类，并在程序的类继承和引用中体现抽象类的作用。

abstract class Bird {  //抽象类中可以有非抽象方法，也可以有成员变量
	  private int a = 10;
	  public abstract void fly();      //如果没有此抽象方法，但是class前有absract修饰，也是抽象类，也不能实例化
	  public void say() {            //普通成员方法
	    System.out.println("我是抽象类中的非抽象方法，此抽象类中的私有成员变量a= " + a);
	  }
	  public int getA() {
	    return a;
	  }
	  public void setA(int a) {
	    this.a = a;
	  }
	}
	class Gezi extends Bird{
	  public void fly() {        //子类实现Bird的抽象方法
	    System.out.println("咕咕咕");   
	    System.out.println("我是子类，只有通过super.getA()调用父类的私有变量a：" + super.getA());  
	  }
	}
	public class Test {
	  public static void main(String[] args) {
	    Gezi gezi = new Gezi();
	    gezi.say();    //子类继承调用Bird的普通成员方法
	    gezi.fly();    //子类调用已经实现过的方法
	  }
	}

5.接口有什么作用？自己定义一个接口，并给出实现类和使用类。

1.可以使项目分层，所有层都面向接口开发，开发效率提高
2.接口使代码与代码之间的耦合度降低，就像内存条和主板，可随意更换
3.接口可以实现多继承，并且一个类除了实现接口之外，还可以继承其他类

interface CustomerService {
	void logout();
}

class CustomerServiceImpl implements CustomerService{
	public void logout() {
		System.out.println("成功退出系统");
	}
}

public class Test01 {
	public static void main(String[] args) {
		CustomerService cs=new CustomerServiceImpl();
		cs.logout();
	}
}

6. 抽象类与接口的异同点是什么？

共同点：都有抽象方法，不能实例化，都有自己的声明
不同点：

1. 属性 接口只有静态常量
2. 抽象类可以有集体方法，接口只有抽象方法
3. 抽象类必须有子类继承，接口必须有实现类实现

7.引用比较方法有哪些？

1. equals()
2. ==
3. instanceof

8.内部类的作用是什么？什么情况下使用匿名内部类？

内部类可以访问类的所有成员，外部类无法访问内部类。保证对其他类封装，只对一个类（内部类）开发
情况：

1. 只用到类的一个实例
2. 类在定义后马上用到
3. 类非常小（4行代码以下）

9.不上机，判断下面程序的输岀结果。

class X {
       Y b = new Y();
X() {
       System.out.println(“X”);
}
}
class Y {
Y() {
       System.out.println(“Y”);
}
}
public class Z extends X{
       Y y = new Y();
Z() {
       System.out.println(“Z”);
}
public static void main(String[] args) {
       new Z();
}
}
//输出结果：YXYZ

10. 什么是数据隐藏？如何证明子类对父类同名方法进行重新定义，只能是方法的覆盖而不是隐藏？

只提供public方法来访问类中的私有属性

11. A1、A2分别是具体类A的子类，A3为A1的子类，A1、A2之间的关系为平行类， 如图6.15所示。下面的代码为连续的程序片段，请问哪些是正确的？

A a = new A();
a = new A1();
a = new A2();
a = new A3();
A1 a1 = new A3 ();
A3 a3 = a1; //×
A2 a2 = new A1(); //×
a3 = new A2(); //×

12. 借助JDK完成：Applet当中的 TextField,每次输入任一字符，在一个label中都能动态跟踪刷新。

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
class Listener implements KeyListener  
{    
    private myApplet mya;  //myApplet对象引用
    
    public Listener(myApplet a){
        this.mya = a;
    }
    public void keyPressed(KeyEvent arg0) {
     }
     public void keyReleased(KeyEvent arg0) {
     }
     public void keyTyped(KeyEvent ke) {
      //mya.l.setText(mya.input.getText()+ke.getKeyChar());
         mya.c = ke.getKeyChar();
         mya.refresh();
     }
};
public class myApplet extends Applet 
{
    public TextField input; //修改为public
    char c;
    Label l = new Label();
    public void init()
    {
        input = new TextField(10); 

        add(input); 
        add(l);
        input.addKeyListener(new Listener(this));
            
    }
    
    public void paint(Graphics g)
    {
        //l.setText(input.getText()+c);
        g.drawString("您输入了字符:"+c,10,50);
    }
 //增加刷新方法进行刷新
    public void refresh(){
        repaint();
    }   
}