Java从零开始学十五(继承)
一、继承作用
继承使用复用以前的代码非常容易，能够大大的缩短开发周期，降低开发成本，同时增加程序的易维护性
继承使重一个类A能够直接使用另外一个类B的属性和方法的一种途径
类A可以有自己的属性和方法
二、继承实现
类的继承格式
在Java中使用extends关键字完成类的继承关系，操作格式：
class 父类{} // 定义父类
class 子类 extends 父类{} // 使用extends关键字实现继承
package com.pb.person; /* * 父类 */ public class Person { private String name; //姓名 private String sex; //性别 private int age;//年龄 //设置getter和setter方法 public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { if(sex.equals("男") || sex.equals("女")){ //设置性别限制，不合法的值将提示错误 this.sex = sex; }else{ System.out.println("性别不合法，性别只能是：男或者女"); } } public int getAge() { return age; } public void setAge(int age) { if(age>0 && age<=150){ //设置年龄限制 this.age = age; }else{ System.out.println("年龄只能在1-150岁之间"); } } public Person() { this.name = "无名氏"; this.sex = "男"; this.age = 22; } public Person(String name, String sex, int age) { this.name = name; this.sex = sex; this.age = age; } public void say(){ System.out.println("自我介绍："); System.out.println("姓名:"+this.name); System.out.println("性别:"+this.sex); System.out.println("年龄:"+this.age); } }
子类:
package com.pb.person; /* * 子类 */ public class Student extends Person { private int stuNo ; //学号 private String specialty; //专业 public Student() { } public Student(String name, String sex, int age,int stuNo,String specialty) { super(name, sex, age); this.stuNo=stuNo; this.specialty=specialty; } //getter/setter方法 public int getStuNo() { return stuNo; } public void setStuNo(int stuNo) { this.stuNo = stuNo; } public String getSpecialty() { return specialty; } public void setSpecialty(String specialty) { this.specialty = specialty; } }
测试类
package com.pb.persontest; import com.pb.person.Student; public class Test { public static void main(String[] args) { Student stu=new Student("张三", "男", 22, 121, "计算机科学与技术") ; stu.say(); } }
结果:
自我介绍：
姓名:张三
性别:男
年龄:22
以下可以发现，子类的学号，和专业并没有输出，
默认调用的父类的say()方法
需要子类重写父类的方法
三、方法的重写
方法的重写是发生的子类对父类的过程中，是在2个类中，和方法重载是在一个类中
方法重写有以下要求
Student类重写Person类中的say()方法
package com.pb.person; /* * 子类 */ public class Student extends Person { private int stuNo ; //学号 private String specialty; //专业 public Student() { } public Student(String name, String sex, int age,int stuNo,String specialty) { super(name, sex, age); this.stuNo=stuNo; this.specialty=specialty; } //方法重写 @Override public void say() { super.say(); System.out.println("学号是:"+this.stuNo); System.out.println("专业是："+this.specialty); } //getter/setter方法 public int getStuNo() { return stuNo; } public void setStuNo(int stuNo) { this.stuNo = stuNo; } public String getSpecialty() { return specialty; } public void setSpecialty(String specialty) { this.specialty = specialty; } }
测试类不变:
package com.pb.persontest; import com.pb.person.Student; public class Test { public static void main(String[] args) { Student stu=new Student("张三", "男", 22, 121, "计算机科学与技术") ; stu.say(); } }
结果:
自我介绍：
姓名:张三
性别:男
年龄:22
学号是:121
专业是：计算机科学与技术
重写以后，调用的就是子类重写后的方法
四、super关键字
super必须是出现在子类中(子类的方法和构造方法中),而不是其他位置,在构造方法中必须出现在第一行
用以访问父类的成员，例如：父类的属性、方法、构造方法
访问权限的限制，例如无法通过super访问private成员
五、继承条件下构造方法的调用规则
规则一:如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法
规则二:如果子类的构造方法中通过super显示调用父类的有参构造方法,那将执行父类的相应的构造方法，而不执行父类无参数构造方法
规则三：如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上2条规则
5.1、例一
package compb.demo4; /* * 父类 */ public class StaticSuper { public static String staticGet() { return "父类静态方法"; } public String dynamicGet() { return "父类动态方法"; } } package compb.demo4; /* * 子类 */ public class StaticSub extends StaticSuper{ //静态方法不能重写 public static String staticGet() { return "子类静态方法"; } @Override public String dynamicGet() { return "子类动态方法重写父类动态方法"; } } package compb.demo4; /* * 测试 */ public class Test { public static void main(String[] args) { StaticSub s= new StaticSub(); //声明子类对象 System.out.println(s.staticGet()); //调用子类静态方法 System.out.println(s.dynamicGet()); //调用子类动态方法 } }
结果:
子类静态方法
子类动态方法重写父类动态方法
5.2、例二、
package com.pb.demo5; /* * 父类 */ public class VenderLate { public VenderLate() { System.out.print("VenderLate out"); } } package com.pb.demo5; public class MoveGoods extends VenderLate{ public MoveGoods( ) { System.out.println("MoveGoods out!"); } public MoveGoods(String s) { System.out.println(s); } } package com.pb.demo5; /* * 测试类 */ public class Test { public static void main(String[] args) { MoveGoods m=new MoveGoods(); MoveGoods g=new MoveGoods(" child"); } }
结果:
VenderLate outMoveGoods out!
VenderLate out child
5.3 、例三
package com.pb.demo4; /* * 父类 */ public class SuperClass { private String name; public SuperClass() { System.out.println("父类的无参数构造方法"); } public SuperClass(String name) { System.out.println("父类有一个参数的构造方法:"+name); } //setter/getter方法 public String getName() { return name; } public void setName(String name) { this.name = name; } }
子类
package com.pb.demo4; public class SubClass extends SuperClass { private String name; private int count; public SubClass() { System.out.println("子类无参数构造方法"); } public SubClass(int count) { System.out.println("子类有一个参数构造方法:"+count); } //调用父类有参数的构造方法 public SubClass(String name) { super(name); this.name=name; System.out.println("调用子类有一个参数构造方法，同时使用super显示调用"+name); } //setter/getter方法 public String getName() { return name; } public void setName(String name) { this.name = name; } public int getCount() { return count; } public void setCount(int count) { this.count = count; } }
测试类:
package com.pb.demo4; public class Test { public static void main(String[] args) { System.out.println("*******调用子类无参数构造方法**********"); SubClass s1=new SubClass(); System.out.println("*******调用子类有一个参数构造方法但是没有使用super显示调用**********"); SubClass s2=new SubClass(34); System.out.println("*******调用子类有一个参数构造方法，同时使用super显示调用**********"); SubClass s3=new SubClass("张三"); } }
结果:
*******调用子类无参数构造方法********** 父类的无参数构造方法 子类无参数构造方法 *******调用子类有一个参数构造方法但是没有使用super显示调用********** 父类的无参数构造方法 子类有一个参数构造方法:34 *******调用子类有一个参数构造方法，同时使用super显示调用********** 父类有一个参数的构造方法:张三 调用子类有一个参数构造方法，同时使用super显示调用张三
六、Object类
所有的有类都自动继承java.lang包中的Object类
Object类是所有类的父类(基类)
在定义一个类时如果没有使用extends关键字，则默认继承Object类
Object常被重写的方法:
