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. }