12.10作业

最新推荐文章于 2024-04-30 19:58:19 发布

原创最新推荐文章于 2024-04-30 19:58:19 发布 · 205 阅读

0 ·

CC 4.0 BY-SA版权

homework 专栏收录该内容

6 篇文章

订阅专栏

本文详细解析了重载(Overload)与重写(Override)的概念区别，并通过具体的编程实例展示了如何在Java中实现这两种多态形式。此外，还提供了长方形类的设计、刺客刺杀总统的场景模拟以及继承结构中的方法展示等实用案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.简述重载(Overload)与重写(Override)的区别。

2.完成刺客刺杀总统的场景，要求：刺杀成功后，将刺客的名字和总统的名字
都显示出来。

3.建立一个长方形的类包括属性，长、宽

1）在构造方法中，给长方形的属性初始化。

2）写两个方法，分别求出长方形的周长和面积。

3）写一个方法，以长方形的对象为参数，求出两个长方形的周长差。

4.创建拥有继承结构的两个类，两个类拥有相同定义的show（）方法，但是方法体中
的内容不同，分别创建一个父类对象和子类对象，分别调用show()方法，观察结果。

1.
重载：只看同名函数的参数列表。
1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载是一个类中多态性的一种表现。
2) Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
3) 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

重写：子父类方法要一样。
1) 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
2) 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
3) 子类函数的访问修饰权限不能少于父类的；

package rectangle;

public class RectangleDemo 
{
    double len;
    double width;

    RectangleDemo()
    {

    }
    RectangleDemo(double len,double width)
    {
        this.len=len;
        this.width=width;
    }

public double caculatePerimeter() 
    {
        double per=(this.len+this.width)*2;
        System.out.println("长方形的周长是"+per);
        return per;
    } 



public double calculateArea() 
    {
        double ar=this.len*this.width;
        System.out.println("长方形面积是"+ar);
        return ar;

    }

}

package rectangle;

public class RectangleTest 
{

    public static void main(String[] args)
    {
        RectangleDemo re1=new RectangleDemo(6.0,5.8);
        RectangleDemo re2=new RectangleDemo(2.0,5.0);
        re1.caculatePerimeter();
        re1.calculateArea();
        double errandrectangle=re1.caculatePerimeter()-re2.caculatePerimeter();
        if(errandrectangle>0) 
        {
            //double errandretangle1=errandrectangle;


            System.out.print("re1与re2两个长方形的周长差为:"+errandrectangle);

        }
        else 
        {
            double errandrectangle1=-errandrectangle;
            System.out.print("re1与re2两个长方形的周长差为:"+errandrectangle1);
        }

    }

}

package org.westos.www;

public class President
{
    String name;
    President()
    {

    }
    President(String n)
    {
        name=n;
    }

}

package org.westos.www;

public class Assassin 
{
    String name;
    int age;
    String sex;
    Assassin()
    {

    }
    Assassin(String name,int age,String sex)
    {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    public void assassinatePresident(President p) 
    {
        System.out.print("一名"+age+"岁的"+sex+"性刺客，名叫"+name+",刺杀"+p.name+"总统成功！");
    }


}

package org.westos.www;

public class Murder {

    public static void main(String[] args)
    {
        President p=new President("zhangsan");
        Assassin a=new Assassin("lisi",20,"女");
        a.assassinatePresident(p);

    }

}

package org.westos.www;

public class Fu 
{
    int num;
    public Fu()
    {

    }
    public Fu(int num)
    {
        this.num=num;
        System.out.println("父类带参构造:"+num);
    }
    public void show()
    {
        System.out.println("~~~~~~~~~");
    }
}

package org.westos.www;

public class Zi extends Fu
{
     int haha;

     public Zi()
     {
         super();
         System.out.println("子类无参构造：");
     }
     public Zi(int haha)
     {
         this.haha=haha;
         System.out.println("子类带参构造："+haha);
     }
     public  void show()
     {
         System.out.println("........");
     }
}

package org.westos.www;

class ExtendsDemo
{
    public static void main(String [] args)
    {
         Fu f=new Fu(20);              
         Zi z=new Zi(11);       
         f.show();                                                  //父类对象调用show()方法
         z.show();    

    }
}