2020/10/17java作业四

第五章

1.public.protected.private.默认。以类前的修饰符为public为例,当类的属性和方法前的修饰符为public，则该属性和方法可以被所有类访问；当属性和方法前的修饰符为protected时，在类定义层面，访问权限为包中的类和所有子类，在类对象层面，则为包中的类；当属性和方法前的修饰符为默认时，访问权限为包中的类；当属性和方法前的修饰符为private时，只能被本类内部的方法所访问。

同一个包public类的protected属性可以被同一个包的所有类访问 
public class FighterPlane{ 
   public String name; 
   public int missileNum; 
   public void fire(){ 
      if(missileNum>0){ 
         System.out.println("now fire a missile!");
         missileNum-=1; 
       } 
      else{ 
         System.out.println("No missile left!"); 
      }
   } 
 } 
public class RunPlane{ 
   public static void main(String args[]){ 
      FighterPlane fp=new FighterPlane();      
      fp.name="王 85";      
      fp.missileNum=7;    
      fp.fire();   
  } 
}

修饰符为public,另外的包可以访问对象的属性和方法
package com.resource;
public class FighterPlane{
  public String name;
  public int missileNum;
  public void fire(){
  	if(missileNum>0){
  	   System.out.println("now fire a missile!");
  	   missileNum-=1;
  	}
  	else{
  	  System.out.println("No missile left!");
  	}
  }
 }
 package com.run;
 package com.resource.*;
 public class RunPlane{
   public static void main (String args[]){
      FighterPlane fp=new FighterPlane();
      fp.name="王 85";
      fp.missileNum=7;
       fp.fire();
   }
}   

若FighterPlane修饰符为protected,则RunPlane没有访问权限。

修饰符为protected,不同包的子类可以访问protected的属性和方法
package com.resource;
public class FighterPlane{
  protected 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!");
  	}
  }
 }
 package com.run;
 import com.resource.FighterPlane;
 public class RunPlane extends FighterPlane{
   public static void main (String args[]){
      RunPlane fp=new RunPlane();
      fp.init();
      fp.fire();
   }
}   
   private void init(){
     name="www";
     missileNum=8;
 }
}

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

子类可以直接访问父类的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 Run{
    public static void main(String []args){
      FighterPlane p=new FighterPlane;
      p.name="sss";
      p.setName="subs";
      System.out.println(p.getName());
      p.fire();
}
}

​子类不能直接访问父类的private属性和方法,可以调用父类的公用方法间接访问私有属性
class Plane{
  private 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="sss";
      p.setName="subs";
      System.out.println(p.getName());
      p.fire();
}
}​

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 fireMissile(){
     fp.fire();
  }
}
public class Run{
    public static void main(String []args){
      FighterPlane ftp=new FighterPlane("subs",9);
      A a=new A(ftp);
      a.fireMissile();
}
}​

4.重载：在类中定义了多个同名而不同内容参数的成员方法，称这些方法为重载。重载使旧的接口方法得以保留以保障原先使用程序的稳定，同时增加带参数的新的重载方法以满足扩充需求，并且新增加的重载方法于原先旧方法之间存在功能复用关系。

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

5.覆盖：子类对父类参数相同，返回类型相同的同名方法重新进行定义。覆盖可使抽象类申明在保证消息发送统一性的前提下，具有消息结果执行上的相异性特点。

class Parent{
    public int getScore()
    {return 3;}
    public String getCountry()
    {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.getCountry());
 }
}
输出结果：
4 
CHINA