Java重写的方法和覆盖

使用重写优化电子宠物系统需求说明:按照方法的重写或方法的覆盖的注意事项:

(1)子类根据需求对从父类继承的方法进行重新编写;

(2)重写时,可以用super.方法的方式来保留父类的方法;
(3)构造方法不能被重写;回顾之前使用继承实现的电子宠物系统,请使用方法的重写或覆盖优化现有代码,重写宠物类的宠物自白方法,在不同类型的宠物进行自白时,介绍其不同的特性,如:狗狗的自白需要介绍其品种、企鹅的自白需要介绍其性别。实现如图所示的输出效果。    

[javascript]  view plain  copy
  1. package cn.java.pet;  
  2.   
  3. /** 
  4. * 宠物抽象类 
  5. */  
  6. public class Pet {  
  7.       private String petName;   //宠物名称  
  8.       private int petHealth;    //宠物健康值  
  9.       private int petLove;      //宠物亲密度  
  10.         
  11.       public Pet(){  
  12.                   
  13.       }  
  14.         
  15.       public Pet(String name){  
  16.                 this.petName = name;  
  17.                 this.petHealth = 100;  
  18.                 this.petLove = 0;  
  19.       }  
  20.         
  21.       /** 
  22.          * 宠物自我介绍 
  23.          */  
  24.       public void printInfo(){  
  25.                 System.out.println("我的名字叫"+this.petName+",我的健康值是"+this.petHealth+",我与主人的亲密程度是"+this.petLove);  
  26.       }  
  27.         
  28.       public String getPetName() {  
  29.                 return petName;  
  30.       }  
  31.   
  32.       public void setPetName(String petName) {  
  33.                 this.petName = petName;  
  34.       }  
  35.   
  36.       public int getPetHealth() {  
  37.                 return petHealth;  
  38.       }  
  39.   
  40.       public void setPetHealth(int petHealth) {  
  41.                 this.petHealth = petHealth;  
  42.       }  
  43.   
  44.       public int getPetLove() {  
  45.                 return petLove;  
  46.       }  
  47.   
  48.       public void setPetLove(int petLove) {  
  49.                 this.petLove = petLove;  
  50.       }  
  51.   
  52.         
  53. }  
  54. package cn.java.pet;  
  55.   
  56. /** 
  57. * 狗狗类 
  58. */  
  59. public class DogPet extends Pet {  
  60.       private String dogBreed;   //狗狗品种  
  61.         
  62.       //如果父类定义带有参数的构造函数未显示定义无参构造函数,那么子类必须需要调用父类需求的构造函数  
  63.       public DogPet(String name,String breed){  
  64.                 super(name);  
  65.                 this.dogBreed = breed;  
  66.       }  
  67.         
  68.         
  69.       /** 
  70.          * 狗狗自我介绍, 对宠物类printInfo()方法进行了重写(覆盖) 
  71.          */  
  72.       public void printInfo(){  
  73.                 super.printInfo();//通过super关键字调用父类的需要的方法,super是指在子类中代表父类对象的引用(指向同一个堆内存中地址)  
  74.                 System.out.println("我是一只"+this.dogBreed);  
  75.       }  
  76. }  
  77.   
  78. package cn.java.pet;  
  79.   
  80. /** 
  81. * 企鹅类 
  82. */  
  83. public class PenguinPet extends Pet {  
  84.       private String penguinSex;   //企鹅性别  
  85.         
  86.       public PenguinPet(String name,String sex){  
  87.                 super(name);  
  88.                 this.penguinSex = sex;  
  89.       }  
  90.         
  91.         
  92.       /** 
  93.          * 企鹅自我介绍 ,对宠物类printInfo()方法进行了重写(覆盖) 
  94.          */  
  95.       public void printInfo() {  
  96.                 super.printInfo();  
  97.                 System.out.println("我的性别是"+this.penguinSex);  
  98.       }  
  99.   
  100.       public String getPenguinSex() {  
  101.                 return penguinSex;  
  102.       }  
  103.   
  104.       public void setPenguinSex(String penguinSex) {  
  105.                 this.penguinSex = penguinSex;  
  106.       }  
  107. }  
  108.   
  109. package cn.java.pet.test;  
  110.   
  111. import cn.java.pet.DogPet;  
  112. import cn.java.pet.PenguinPet;  
  113. import cn.java.pet.Pet;  
  114.   
  115. /** 
  116. * 测试类 
  117. */  
  118. public class PetTest {  
  119.   
  120.       public static void main(String[] args) {  
  121.                 //创建狗狗实例对象  
  122.                 Pet dogPet = new DogPet("欧欧","雪娜瑞犬");  
  123.                 //狗狗自我介绍  
  124.                 dogPet.printInfo();  
  125.   
  126.                 //创建企鹅实例对象  
  127.                 Pet penguinPet = new PenguinPet("楠楠","Q妹");  
  128.                 //企鹅自我介绍  
  129.                 penguinPet.printInfo();  
  130.       }  
  131.   
  132. }  
<think>好的,我现在需要帮助用户了解在Java中正确重写方法签名的规则示例。首先,我得回忆一下Java方法重写的基本概念。重写发生在子类继承父类的时候,子类提供一个与父类方法有相同签名的方法实现。 接下来,用户提到的是方法签名的规则,所以我需要明确哪些部分构成方法签名。通常,方法签名包括方法名、参数类型列表以及返回类型(在协变返回类型的情况下可以不同)。不过,Java中严格的方法重写要求返回类型必须兼容,参数列表必须完全相同。 然后,我需要考虑用户可能的疑问点,比如访问修饰符的限制。父类的方法如果是public,子类重写时不能缩小访问权限,比如改为private,这会导致编译错误。但反过来,扩大访问权限是可以的,比如从protected改为public。 异常处理也是一个重点。重写方法不能抛出比父类方法更宽泛的检查异常,或者新的检查异常,但可以抛出不抛出异常,或者抛出非检查异常(RuntimeException等)。这点可能需要用例子来说明。 然后是@Override注解的使用,虽然这不是强制的,但加上这个注解可以让编译器检查是否正确重写了父类的方法,避免因为拼写错误或参数不匹配导致的问题。引用中提到的Google Java Style Guide的Javadoc格式示例,可能文档注释有关,但用户的问题更关注方法签名本身,所以可能需要提到在重写时保持或完善Javadoc注释。 用户提供的引用里有关于继承super关键字的例子,比如“Inheritance 2: Extends with Overriding (Example VengefulSLList) keyword super call superclass’s method.”这说明用户可能对如何在子类中调用父类方法感兴趣,所以应该在示例中包含使用super调用父类方法的例子。 另外,引用中提到规则的应用场景设置,这可能某些代码规范或静态检查工具相关,但核心还是方法签名的规则。需要确保覆盖所有关键点:方法名、参数列表、返回类型、访问修饰符、异常、静态方法不能重写等。 可能的误区包括认为参数列表顺序不影响,但实际上参数类型顺序必须完全一致。还有协变返回类型的情况,即子类方法可以返回父类方法返回类型的子类,这是允许的,但需要明确说明。 现在需要组织这些点,用清晰的规则示例来展示。每个规则后面跟一个例子,代码示例用正确的格式,行内公式用$...$,独立公式不需要,但代码块需要用```java标注。同时,生成相关问题,帮助用户进一步学习。 最后,检查是否有遗漏的规则,比如静态方法不能被重写,只能被隐藏;final方法不能被重写重写方法可以使用@Override注解等。确保所有引用适当,比如引用[^2]关于继承super的使用,引用[^1]关于代码风格中的Javadoc示例,可能在示例中加入Javadoc注释,但用户的问题可能更关注方法签名本身。</think>### Java方法重写的签名规则与示例 在Java中,方法重写(Override)需要严格遵循以下规则,确保子类方法与父类方法在签名类型上保持兼容: --- #### 一、核心规则 1. **方法签名必须完全一致** 包括方法名、参数类型及顺序。例如: ```java // 父类 class Animal { public void move(int meters) { /*...*/ } } // 子类正确重写 class Dog extends Animal { @Override public void move(int meters) { /*...*/ } // ✅ 参数类型名称一致 } ``` 2. **返回类型协变(Covariant Return Types)** 子类方法的返回类型可以是父类方法返回类型的子类: ```java class Fruit {} class Apple extends Fruit {} class Farm { Fruit harvest() { return new Fruit(); } } class AppleFarm extends Farm { @Override Apple harvest() { return new Apple(); } // ✅ 返回子类类型 } ``` 3. **访问修饰符不能更严格** 子类方法的访问权限必须 ≥ 父类方法(例如父类为 `protected`,子类可为 `public`,但不可为 `private`): ```java class Parent { protected void save() { /*...*/ } } class Child extends Parent { @Override public void save() { /*...*/ } // ✅ 权限扩大 // ❌ private void save() 会编译错误 } ``` 4. **异常限制** 子类方法不能抛出比父类方法**更宽泛的检查异常**,但可以不抛出异常或抛出非检查异常(如 `RuntimeException`): ```java class Database { void connect() throws SQLException { /*...*/ } } class LocalDB extends Database { @Override void connect() throws SQLException { /*...*/ } // ✅ 相同异常 // @Override void connect() throws Exception {} ❌ 更宽泛 } ``` 5. **静态方法不能被重写** 若父类方法为 `static`,子类中同名方法会隐藏(Hide)父类方法,而非重写: ```java class Calculator { static void printType() { System.out.println("Calculator"); } } class ScientificCalculator extends Calculator { static void printType() { System.out.println("Scientific"); } // ❌ 隐藏而非重写 } ``` --- #### 二、附加要求 - **使用 `@Override` 注解** 显式声明方法重写,编译器会检查签名是否符合规范[^1]: ```java class Child extends Parent { @Override // 若签名不匹配会报错 public void method() { /*...*/ } } ``` - **调用父类方法** 可通过 `super` 关键字调用父类被重写方法: ```java class VengefulSLList<T> extends SLList<T> { @Override public T removeLast() { T item = super.removeLast(); // 调用父类实现 // 自定义逻辑... return item; } } ``` --- #### 三、常见错误示例 ```java class Parent { void process(String input) { /*...*/ } } class Child extends Parent { // ❌ 错误1:参数类型不匹配(String vs int) void process(int input) { /*...*/ } // ❌ 错误2:返回类型不兼容(void vs String) String process(String input) { /*...*/ } // ❌ 错误3:访问权限更严格(public → private) private void process(String input) { /*...*/ } } ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值