Java第五章

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

访问修饰控制符：
有3种访问修饰符：public、private、protected。
以及不使用关键字的默认访问权限（包访问权限）

访问权限：

 例：

//首先在com.resource包中定义一个SomeVar类，其含有3种修饰符修饰的变量。
package com.resource;
class SomeVar {
    public String varPublic = "Public";
    protected String varProtected = "Protected";
    private String varPrivate = "Private";
}

public class SamePack {
    public static void main(String[] args){
        SomeVar sv = new SomeVar();
        System.out.println(sv.varPublic); // 无报错
        System.out.println(sv.varProtected); // 无报错
        System.out.println(sv.varPrivate); // The field SomeVar.varPrivate is not visible
    }
}
//这里会在引用varPrivate变量时报错，表明private修饰的变量无法被包内其他的类访问，只能被本类访问。

package com.run;
import com.resource.SomeVar;
public class RunVar {
    public static void main(String[] args){
        SomeVar sv = new SomeVar();
        System.out.println(sv.varPublic); // 无报错
        System.out.println(sv.varProtected); // The field SomeVar.varProtected is not visible
        System.out.println(sv.varPrivate); // The field SomeVar.varPrivate is not visible
    }
}
//由于RunVar类与SomeVar类不在同一个包内，所以其不能访问SomeVar类的varProtected与varPrivate属性。

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

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

例子：

class FatherPlane{
    public String namePub = "Public name";
    protected String namePro = "Protected name";
    private String namePri = "Private name";
}

class SonPlane extends FatherPlane{
	public void setName(String name_){
        this.namePri = "new private"; // The field FatherPlane.namePri is not visible
    }
}

public class RunPlane{
    public static void main(String args[]) {
        SonPlane sp = new SonPlane();
        System.out.println(sp.namePub); // 无报错
        System.out.println(sp.namePro); // 无报错
        System.out.println(sp.namePri); // The field FatherPlane.namePri is not visible

    }
}

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; //A对象中拥有了FighterPlane对象的引用
    }
    public void invoke(){
       //A中对象发送消息给FighterPlane的对象
       System.out.println(fp.name); 
    }
}
public class  Run{
   public static void main(String[] args)
   {  
      FighterPlane ftp = new FighterPlane("su35",10);
	//产生A对象，并将ftp对象引用作为参数传入
      A  a   = new A(ftp); 
      //发送消息，产生调用关系
      a.invoke();
   }
}

4. 什么是重载？有什么作用？请构造各种重载示例。

重载(overload)的概念：指的是同一个类中参数个数和类型不同但方法名相同的多个方法，返回类型可以相同也可以不同。调用时，会根据不同的参数表选择对应的方法。

重载的作用：重载可以使得同一个方法处理不同类型的参数并返回不同类型的值，虽然参数不同但这些同名方法所实现的作用是相同的，是实现多态的非常重要的机制。

例：

class StuManage {
    public int getScore(){
        return 3;
    }
    public int getScore(int i){
        return i;
    }
    
    /*public long getScore(int i){
        return i;
    }*/
    
    /*private int getScore(int i){
        return i;
    }*/
     /*public static int getScore(int i){
        return i;
    }*/
    
    /*public final int getScore(int i){
        return i;
    }*/
    
    public int getScore(Integer i){
        return i;
    }
    
    //可变参数，i实质上是数组int[]    
    public int getScore(int ... i){
        return 3;
    }
 }

5. 什么是覆写？有什么作用？覆写父类方法的条件有哪些？请举例说明。

覆写(overriding)的概念：覆写指的是子类对父类中已经定义好的方法进行了重新定义，方法名、返回值类型和形式参数都不能改变。

覆写的作用：使得子类能够灵活的根据自己的需要修改父类中所定义的方法，而无需修改父类中的方法。

例：
class Parent {
    Number getScore(int a) {
      return new Integer(7);
   }
}
class Son extends Parent {
    @Override   //所有的覆写方法需注明
    Number getScore(int b){
      return new Integer(8);
    }
 }
 public class RunSon{
    public static void main(String args[]){
      Son  s = new Son();
      System.out.println(s.getScore());
   }
}

覆写与重载的区别：
覆写：方法名称相同，参数类型、个数一致，子类返回类型可向上转型到父类返回类型 （类族）
重载：方法名称相同，参数类型或个数不同 （同一个类）