java第五章作业

面向对象的特征：

• 封装：利用抽象数据类型将数据和基于数据的操作绑定在一起，数据被保存在抽象数据类型内部，系统只有通过被授权的操作方法才能够访问数据。
• 继承：extends关键字，子类从父类继承相应的属性和方法
• 多态：一个程序中同名但是不同方法共存的情况
  • 重载：类中定义了多个同名而不同内容参数的成员方法叫重载
  • 覆盖：子类对父类参数相同、返回类型相同的同名方法重新进行定义称为覆盖。子类覆盖父类方法时，子类访问权限必须大于或者等于父类访问权限。

对象之间发生相互作用—在对象的世界里，对象之间都不是孤立的，它们之间的相互联系就是以消息的形式体现的，当对象A拥有对象B的引用作为自己的属性，且具备发送消息的条件后，A对象就可以向B对象发送消息，控制B对象产生相应的操作。

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
   }
}