java第五章作业

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

public（接口访问权限）
protected（包访问权限、继承访问权限）
“默认”（包访问权限）
private（无法直接访问）


访问权限首先看类前的修饰符，再看属性和方法前的修饰符。

首先在com.resource包内建立FighterPlane类，

package com.resource;
public class FighterPlane{
    public String name;
    protected int missileNum;
    public void fire(){
        if(missileNum > 0){
            System.out.println("Now fire a missile!");
            missileNum -= 1;
        } else {
            System.out.println("No missile left!");
        }
    }
}

然后在com.run包内定义RunPlane类，并调用FighterPlane类

package com.run;

import com.resource.*;

public class RunPlane {
    public static void main(String[] args){
        FighterPlane fp = new FighterPlane();
        fp.name = "苏35";
        fp.missileNum = 10; // The field FighterPlane.missileNum is not visible
        fp.fire();
    }
}

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

子类继承了父类的所有属性和方法， 但只有public、protected的属性和方法在子类是可见的。

举例如下：

class Plane{
   public String publicName = "Plane";
   protected String protectedName = "Plane";
   private String privateName = "Plane";
}

class SonPlane extends Plane{
}

public class Test{
   public static void main(String[] args){
      SonPlane sp = new SonPlane();
      System.out.println(sp.publicName);
      System.out.println(sp.protectedName);
      System.out.println(sp.privateName); // The field Plane.privateName is not visible
   }
}

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

把一个类当成另一个类的组合成分，从而允许新类直接复用该类的public方法，用以实现新类的功能，用户看到的是新类的方法，而不能看到被组合对象的方法，通常在新类里使用private修饰被组合的旧类对象。
相比于继承，组合的方式更加灵活，不需要继承父类的全部内容。

class Plane{
   String name = "Plane";
   void changeName(String n){
      this.name = n;
   }
}

class UsePlane{
   Plane p = new Plane();  // 这里即体现了组合，在UsePlane中使用Plane对象引用
   void changeName(String n){
      p.changeName(n);
      System.out.println("New name is "+p.name);

   }
}

public class Test{
   public static void main(String[] args){
      UsePlane up = new UsePlane();
      up.changeName("HAHA");
   }
}

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

多态是指一个程序中同名的不同方法共存的情况，重载是多态的一种机制。
重载时，方法名称相同，参数类型或个数不同。使用相同的方法名来表示功能相同的多个方法。

举例如下：

public class Test {
   public void print(){
       System.out.println("no args");
   }

   public void print(int a){
       System.out.println("args int");
   }   

   public String print(int a, String s){
       System.out.println("args String");
       return "int String";
   }   

   public static void main(String[] args){
       Test t = new Test();
       t.print();
       t.print(1);
       System.out.println(t.print(1,"test3"));
   }
}

结果输出为：

no args
args int
args String
int String

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

覆盖是多态的另一种机制。
子类对父类的同名方法覆盖时，方法名称相同，参数相同，返回类型相同，对方法的内容重新进行定义。
覆盖一个方法可以对其重写来实现不同的功能，例如对接口方法的实现，在接口中一般只是对方法进行了声明，在实现时，就需要覆盖接口声明的所有方法。

举例如下：

class Plane{
   public void print(){
      System.out.println("Plane!");
   }
}

class FighterPlane extends Plane{
   public void print(){
      System.out.println("FighterPlane");
   }
}

public class RunFighterPlane{
   public static void main(String[] args){
      FighterPlane fp = new FighterPlane();
      fp.print(); // 输出FighterPlane
   }
}