Java程序设计第五章作业

1 问答题

1.Java的访问控制修饰符有哪些？各有什么访问权限？请对照第7页ppt的表格分别写程序验证

private修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。
default表示没有修饰符，只有同一个包的类能访问。
protected表示可以被同一个包的类以及其他包中的子类访问。
public表示可以被改项目的所有包中的所有类访问。
例如：

class Control {
    private int a;
    public int b;
    protected int c;
}

public class Test{
    public static  void main(String[] args){
        Control s = new Control();
        //s.a=5; 错误
        s.b=6;
        s.c=8;
        System.out.println(s.b);
        System.out.println(s.c);
    }
}

2.子类对于从父类继承的哪些属性与方法是可见的？请分别写程序进行验证

public、protected的属性和方法在子类是可见的。
例如：

class Plane{
    protected  String name;
    public void setName(String _name){
        name = _name;
    }
    public String getName(){
        return name;
    }
}

class FighterPlane extends Plane{
    private int missileNum;
    public void setNum(int _missileNum) {
        missileNum = _missileNum;
    }
    public void fire(){
        missileNum -= 1;
    }
}

class Test{
    public static void main(String[] args){
        FighterPlane p = new FighterPlane();
        p.name = "su35";
        p.setName("f35");
        System.out.println(p.getName());
        p.fire();
    }
}

输出结果：

f35

3.什么是组合？有什么作用？请举例说明。

把旧类对象作为新类的成员变量。可实现类的复用。
例如：

class FighterPlane
{
    String name;
    int missileNum;
    public FighterPlane(String _name, int _missileNum) {
        name = _name;
        missileNum = _missileNum;
    }
    public void fire(){
        if (missileNum>0){
            System.out.println("now fire a missile !");
            missileNum -= 1;
        }else{
            System.out.println("No missile left !");
        }
    }
}

class A
{
    FighterPlane fp;
    public A(FighterPlane fpp){
        this.fp = fpp;
    }
    public void fireMissle(){
        fp.fire();
    }
}

public class Run{
    public static void main(String[] args){
        FighterPlane ftp = new FighterPlane("su35",10);
        A a = new A(ftp);
        a.fireMissle();
    }
}

4.什么是重载？有什么作用？请举例说明

重载：方法名称相同，参数类型或个数不同。对象在不同状态下（多态）调用重载函数得到的结果可以不一样。
例如：

public class Parent{
    public int getScore(){
        return 3;
    }
    public int getScore(int i){
        return i;
    }
    public String getScore(String c){
        return c;
    }
    public static void main(String[] args){
        Parent p = new Parent();
        Parent t = new Parent();
        Parent m = new Parent();
        System.out.println(p.getScore());
        System.out.println(t.getScore(5));
        System.out.println(m.getScore("A"));
    }
}

输出结果：

3
5
A

5.什么是覆盖？有什么作用？请举例说明

覆盖：子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。这使得子类能够根据需要实现父类的方法，是父类和子类之间多态的一种表现。
例如：

class Parent {
    public int getScore(){
        return 3;
    }
    public String getCountryName(){
        return "China";
    }
}

class Son extends Parent {
    public int getScore(){
        return 4;
    }
}

public class RunSon{
    public static void main(String[] args){
        Son s = new Son();
        System.out.println(s.getScore());
        System.out.println(s.getCountryName());
    }
}

输出结果：

4
China