关于继承说明
定义两个类 Door 和 MyDoor ,如果其中MyDoor继承了 Door类,那么 MyDoor 就是子类, Door就是父类,子类继承了父类的所有方法和属性。子类可以对直接设置父类的属性和调用方法,也可以对父类的方法进行重写或扩展。但是,重写的方法在子类被实例化后,调用此方法时,输出的内容是子类的实现内容。如果要调用父类中被重写的方法,可以使用关键字:super进行调用
1、继承
父类:Door
Door类
1 /**
2 * Door类
3 */
4 package com.smile;
5
6 public class Door {
7 private int height;
8
9 public int getHeight() {
10 return height;
11 }
12 public void setHeight(int height) {
13 this.height = height;
14 }
15
16 public void opendoor(String doorName)
17 {
18 //
19 System.out.println(doorName+" ,"+this.getHeight() +"m , is open");
20
21 }
22 }
子类:MyDoor
MyDoor类
1 /**
2 * 定义我的门,使其继承Door类
3 * 1、继承使用关键字:extends
4 */
5 package com.smile;
6
7 public class MyDoor extends Door {
8
9 String doorName="";
10 public MyDoor(String doorName,int height)
11 {
12 this.setHeight(height);//这步不可少,顺序不可乱,否者测试的时候,door的高度就为0
13
14 //继承了父类的opendoor方法
15 this.opendoor(doorName);
16 this.doorName=doorName;
17
18 }
19
20 }
测试类
测试类
1 package com.smile;
2
3 public class Studyobject {
4
5 /**
6 * @param args
7 */
8 public static void main(String[] args) {
9 // TODO Auto-generated method stub
10 System.out.println("Hello MyJava!");
11
12
13 //继承测试代码调用
14 MyDoor myDoor =new MyDoor("MyDoor",123);
15 //调用方法
16 myDoor.opendoor(myDoor.doorName);
17
18
19
20 }
21
22 }
2、继承的重写
重写就是在父类的属性、方法不适用的的情况下,对父类中的某些方法进行重新实现。被重写后,应用中使用实例化类调用该方法输出的是子类的实现内容,只有在使用关键字super进行调用输出的才是父类的实现内容。
这里父类不变,修改子类如下
子类代码:(重写后)
重写后的子类
1 /**
2 * 定义我的门,使其继承Door类
3 * 1、继承使用关键字:extends
4 * 2、可以进行父类方法重写、扩展
5 */
6 package com.smile;
7
8 public class MyDoor extends Door {
9
10 String doorName="";
11 public MyDoor(String doorName,int height)
12 {
13 this.setHeight(height);//这步不可少,顺序不可乱,否者测试的时候,door的高度就为0
14 //在重写情况下,使用super调用父类方法
15 System.out.println("在被重写的情况下,只有使用关键字super进行调用输出的才是父类的实现内容");
16 super.opendoor(doorName);
17
18 //继承了父类的opendoor方法
19 System.out.println("在被重写的情况下,调用的是子类的方法,实现的是子类的实现内容");
20 this.opendoor(doorName);
21 this.doorName=doorName;
22
23 }
24
25 //重写了父类opendoor方法
26
27 public void opendoor(String doorName)
28 {
29 System.out.println(doorName+" is a automatic door");
30 }
31
32
33 }
测试类
测试类
1 package com.smile;
2
3 public class Studyobject {
4
5 /**
6 * @param args
7 */
8 public static void main(String[] args) {
9 // TODO Auto-generated method stub
10 System.out.println("Hello MyJava!");
11
12 //继承测试代码调用
13 MyDoor myDoor =new MyDoor("MyDoor",123);
14 //调用方法
15 System.out.println("在未被重写的情况下,调用的是父类的方法,实现的是父类的实现内容");
16 myDoor.opendoor(myDoor.doorName);
17
18
19
20 }
21
22 }
23
3、继承的扩展
扩展就是在父类的属性、方法不够的的情况下,子类中对父类中的方法或属性进行补充。
这里父类不变,修改子类如下
子类(扩展后)
扩展后的子类
/**
* 定义我的门,使其继承Door类
* 1、继承使用关键字:extends
* 2、可以进行父类方法重写、扩展
*/
package com.smile;
public class MyDoor extends Door {
String doorName="";
public MyDoor(String doorName,int height)
{
this.setHeight(height);//这步不可少,顺序不可乱,否者测试的时候,door的高度就为0
//在重写情况下,使用super调用父类方法
System.out.println("在被重写的情况下,只有使用关键字super进行调用输出的才是父类的实现内容");
super.opendoor(doorName);
//继承了父类的opendoor方法
System.out.println("在被重写的情况下,调用的是子类的方法,实现的是子类的实现内容");
this.opendoor(doorName);
this.doorName=doorName;
}
//重写了父类opendoor方法
public void opendoor(String doorName)
{
System.out.println(doorName+" is a automatic door");
}
//扩展
public void Close()
{
System.out.println("MyDoor is close.");
}
}
测试类
测试类
1 package com.smile;
2
3 public class Studyobject {
4
5 /**
6 * @param args
7 */
8 public static void main(String[] args) {
9 // TODO Auto-generated method stub
10 System.out.println("Hello MyJava!");
11
12
13 //继承测试代码调用
14 MyDoor myDoor =new MyDoor("MyDoor",123);
15 //调用方法
16 myDoor.opendoor(myDoor.doorName);
17 //扩展方法调用
18 myDoor.Close();
19
20
21 }
22
23 }