第五周Java作业-多态

最新推荐文章于 2024-09-24 20:15:08 发布

whynowhere

最新推荐文章于 2024-09-24 20:15:08 发布

阅读量152

点赞数

CC 4.0 BY-SA版权

分类专栏： Java作业文章标签： java 多态

本文链接：https://blog.youkuaiyun.com/whynowhere/article/details/109993417

Java作业专栏收录该内容

10 篇文章

订阅专栏

//修饰符为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和protect

//子类可以直接访问父类的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*/

1.子类构造函数→父类构造函数→父类属性→父类构造函数→子类属性→子类构造函数

子类对象的实例化过程：
（1）在方法区先加载父类，再加载子类；
（2）然后在栈中申请空间，声明变量P；
（3）在堆内存中开辟空间，分配对象地址；
（4）在对象空间中，对对象的属性（包括父类的属性）进行默认初始化；
（5）子类构造方法进栈；
（6）显示初始化父类的属性；
（7）父类构造方法进栈，执行完毕出栈；
（8）显示初始化子类的属性；
（9）初始化完毕后，将堆内存中的地址值赋给引用变量P，子类构造方法出栈。

2.通过对象引用的方法，创建两个类，这两个类中都包含另一个类的成员。

class FighterPlane{
  private B b;
  public void setB(B _b){
  if(_b!=null){b=_b}
  }
  public B getB(){
  if(b!=null){return b}
  else return null;
  }
}
class B{
  FighterPlane fp;
  public B(FighterPlane fpp){
  this.fp=aa;
  fpp.setB(this);
  }
}

3.组合是将两个类结合起来,其中一个类是另外一个类的域变量,两个类之间平级。
而继承则是子类沿用父类的对象与方法，是父类的下级。
当只需要使用另外一个类的方法时使用组合；当需要使用另外一个类的方法但不想被其他类访问时用继承。

4.运行时多态即覆盖，子类方法覆盖父类方法。

//父类
class A {  
    void fun()  
    {  
        System.out.println(“I am A”);  
    }  
}  
//A的子类B
class B extends A  
{  
    void fun()  
    {      
        System.out.println(“I am B”);  
    }  
}  
//A的子类C  
class C extends A  
{  
    void fun()  
    {      
        System.out.println(“I am C”);  
    }  
}  

class Test  
{  
    public static void main(String[] args)  
    {  
        //定义父类对象引用变量
        A a;
        //子类对象  
        B  b = new B();  
        C  c = new C();
        //父类对象引用变量 引用 子类对象  
        a=b;  
        a.fun();  //输出   I am B
        a=c;  
        a.fun();  //输出   I am C
    }  
}

interface Shapes 
{  public double getArea();
   public double getPerimeter();
}
class Rect implements Shapes 
{ private int k;
  private int m;
  public Rect(int k, int m){
        this.k=m;
        this.k=m;
    }
  public double getArea()
	  { return(k*m); }
  public double getPerimeter()
	  { return(2*k+2*m);}
}
class Triangle implements Shapes
{   private int k;
    private int x;
    private int y;
    public Triangle(int k, int x, int y){
        this.k=k;
        this.x=x;
        this.y=y;
    }
    public double getArea()
    { double m=(x+y+z)/2.0;
      return(Math.sqrt(m*( m-k)*( m-x)*(m-y)));}
    public double getPerimeter()
	 {return(k+x+y);}
   }
class Circle implements Shapes
{   private int m;
    public Circle(int m){
        this.m=m;
    }
   public double getArea()
		{return(m* m *Math.PI);}
    public double getPerimeter()
		{return(2*Math.PI* m);}
}
public class RunShape extends Applet
{ Rect rect=new Rect(5,15,25,25);
  Triangle tri=new Triangle(5,5,8);
  Circle cir =new Circle(13,90,25);
  public void paint(Graphics g)
  { 
	
	g.drawRect(rect.x,rect.y,rect.k,(int)rect.m);
	g.drawString("Rect Area:"+rect.getArea(),50,35);
	g.drawString("Rect Perimeter:"+rect.getPerimeter(),50,55);
	
	g.drawString("Triangle Area:"+tri.getArea(),50,75);
	g.drawString("Triangle Perimeter:"+tri.getPerimeter(),50,95);
	
    g.drawOval(cir.x-(int)cir.k/2,cir.y-(int)cir.k/2,cir.k,cir.k);	
    g.drawString("Circle Area:"+cir.getArea(),50,115);
	g.drawString("Circle Perimeter:"+cir. getPerimeter(),50,135); 
  }
}

6.instanceof用来测试一个对象是否为一个类的实例。