访问修饰符及其权限 继承 组合 重载 覆盖

• Java的访问控制修饰符有哪些？各有什么访问权限？
• 

/*同一包中：public类public属性/方法的访问*/
public class FighterPlane {
    public String name;
    public int missileNum;
    public void fire(){
        if (missi1eNum>0){
            System. out . print1n("now fire a missile!");missileNum -= 1;
        }
        else{
            System. out . print1n("No missile left !");
        }
    }
}
public class RunPIane {
    public static void main(String args[]){
    FighterPlane fp = new FighterPlane();
    fp.name = "cjr";
    fp. missileNum = 6;
    fp. fire();
    }
}

/*同一包中：public类protected属性/方法访问*/
public class FighterPlane {

    protected String name;
    protected int missileNum;
    protected void fire(){
        if (missi1eNum>0){
            System. out . print1n("now fire a missile!");missileNum -= 1;
        }
        else{
            System. out . print1n("No missile left !");
        }
    }
}
pub1ic class RunPIane {
    public static void main(String args[]){
    FighterPlane fp = new FighterPlane();
    fp.name = "cjr";
    fp. missileNum = 6;
    fp. fire();
    }
}

/*在不同的包中，protected属性的访问：不能通过对象引用fp来访问不在同一包的类的protected属性和方法*/
package com. resource ;
pub1ic class FighterPlane {
    protected String name ;
    protected int mi ssileNum;
    pub1ic void fire(){
        if(x=missileNum>0){
            System. out . print1n("now fire a missile !");
            missileNum -= 1;
        }
        else{
            System. out. print1n("No missile left !");
       }
     }
 }

package com. run;
import com. resource. FighterPlane;
public class RunPlane {
    pub1ic static void main(String args[]){
        FighterPlane fp = new FighterPlane();
        ***fp.name ="yyy";
        fp. missileNum = 6;***
        fp. fire();
     }
}

/*不同包继承关系，public类属性访问：子类的类定义中可以访问父亲类的protected属性和方法，无论在不在同一包中*/
package com. resource ;
pub1ic class FighterPlane {
    protected String name ;
    protected int mi ssileNum;
    pub1ic void fire(){
        if (missileNum>8){
            System. out . print1n("now fire a missile !");missileNum -= 1;
        }
        else{
            Svstem ouut. nrint1n("No missile left ");
        }
    }
}

package com. run;
import com. resource.FighterPlane;
public class RunPlane extends FighterPlane{
    pub1ic static void main(String args[ ]){
        RunPlane fp = new RunPlane( ) ;
        fp. init();
        fp. fire();
     }
    private void init(){
        name = "yyy";
        missileNum = 6;
    }
}

/*不同包中，public类的private属性*/
package com. resource;
public class FighterPlane{
    private String name ;
    private int missil eNum;
    private static FighterPlane fp;
    private FighterPlane(String_ name, int_ missileNum{
         name =_ name ;
         missi1eNum =_ _missileNum;
    }
    public static FighterP1ane getInstance(String_ name,int_ missileNum){
        if (fp==null){
            fp = new FighterPlane(_ name,. missi1eNum);
        }
        return fp;
    }
}

package com. run;
import com. resource.*;
public class RunPlane{
    public static void main(String args[]){
       FighterPlane fp;
       // fp = new FighterPlane; 不允许调用构造器，无法创建对象
       fp=FighterPlane . getInstance("yyy",6);//保证该类只能有一个实例对象
    }
}

• 子类对于从父类继承的哪些属性与方法是可见的？请分别写程序进行验证。
  继承通过extends关键字实现；子类继承了父类的所有属性和方法， 但只有public、protected的属性和方法在子类是可见的。（当子类和父类不在同一个包当中时，父类修饰符必为public）

子类对于从父类继承的public，protected属性与方法是可见的.

/*子类可以直接访问父类的protected属性和方法*/
classPlane{
    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 Run{
    public static void main(String[] args){
        FighterPlane p = new FighterPlane( );
        p.name = "cjr";
        p. setName("cqq");
        System. out . println(p. getName());
        p. fire();
    }
}

/*子类不能直接访问父类的private属性和方法，可以调用父类公共的方法来简介访问私有属性*/
classPlane{
    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 Run{
    public static void main(String[] args){
        FighterPlane p = new FighterPlane( );
        //p.name = "cjr";
        p. setName("cqq");
        System. out . println(p. getName());
        p. fire();
    }
}

• 什么是组合？有什么作用？请举例说明。
  组合用来表示拥有关系。
  当我们创建一个A类对象时，也会随着产生一个B类对象；当A类对象消亡时，它所包含的B类的对象随之消亡，就是说两个生命周期一致。
  面向对象程序设计其所以能比面向过程设计有较大影响力,其中的一个关键是具有“高内聚,松耦合”的特点,这个特点就是通过封装与组合技术的综合运用来实现的。封装是利用访问控制符来实现的，而组合则通过对象内部的属性引用来实现。

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

引用fp就将A对象和FighterPlane对象组合起来: A对象和FighterPlane对象虽然在内存当中是两个对象,但是由于A中拥有FighterPlane 对象的引用，就可以把A对象看成是由FighterPlane对象组合而成的。
组合会使对象之间的耦合性较为松散，因为A对象通过引用向FighterPlane对象发送消息从而使A与FighterPlane产生相互关联,这种联系是建立在FighterPlane的授权基础上的，FighterPlane对象私有的属性和私有方法A是无法访问的。因而，消息和内部私有方法之间就没有直接的联系，这就为阻断变化在软件系统内的传播提供了可能。

• 什么是重载？有什么作用？请举例说明。
  重载：方法名称相同，参数类型或个数不同
  注意：若方法名称相同，参数相同，返回类型不同，则编译不能通过。

• 什么是覆盖？有什么作用？请举例说明。
  子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。
  
  

覆盖与重载的区别：
覆盖：方法名称相同，参数相同，返回类型相同
重载：方法名称相同，参数类型或个数不同