继承
1、继承概述
继承的格式:
- 格式:public class 子类名 extends 父类名
- 范例:public class Zi extends Fu
- Fu:父类、基类、超类
- Zi:子类、派生类
public class Fu {
public void show() {
System.out.println("show方法被调用");
}
}
public class Zi extends Fu{
public void method() {
System.out.println("method被调用");
}
}
public class Demo {
public static void main(String[] args) {
Fu f = new Fu();
f.show();
Zi z =new Zi();
z.method();
z.show();
}
}
2、继承的好处和弊端
- 好处:
- 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
- 提高了代码的维护性(如果方法的代码需要修改,修改一处即可)
- 弊端:
- 继承让类与类之间产生了关系,类的耦合性增强了,当父类发生变化时,子类实现也不得不跟着变化,削弱了子类的独立性
3、什么时候使用继承?
- 继承体现关系:is xxx,包含关系
- 假设法:我有两个类A和B,如果他们满足A是B的一种,或者B是A的一种,就说明他们存在继承关系,这个时候就可以使用继承来体现,否则就不能滥用继承
- 举例:苹果和水果、猫和动物、猫和狗(x)
4、继承中变量访问的特点
在子类方法中访问一个变量时:(就近原则)
- 先在子类局部范围内找
- 在子类成员范围内找
- 在父类成员范围内找
public class Fu {
public int age = 20;
}
public class Zi extends Fu{
public int height = 163;
public void show() {
System.out.println(age);//Zi类中没有,但是继承了父类的
System.out.println(height);//Zi类中有,就会使用子类中的不会去使用父类的
}
}
输出结果:
20
163
public class Demo {
public static void main(String[] args) {
Zi z =new Zi();
z.show();
}
}
5、super关键字
回顾this关键字:在方法中使用this关键字代表使用的是成员变量this,不是局部变量this。
public class Zi extends Fu{
public int height = 163;
public void show() {
int height = 199;
System.out.println(age);//Zi类中没有,但是继承了父类的
System.out.println(this.height);//这里使用了this关键字,则待变使用的是类中的成员变量height而不是方法中的局部变量height
}
}
输出结果:
20
163
super关键字:(用法与this相似)
->在方法中使用了super关键字则代表使用的是父类中的成员变量
this:代表本类对象的引用
super:代表父类存储空间的表示->父类对象的引用
关键字 | 访问成员变量 |
---|---|
this | this.成员变量,访问本类成员变量 |
super | super.成员变量,访问父类成员变量 |
public class Fu {
public int age = 20;
public int height = 170;
}
public class Zi extends Fu{
public int height = 163;
public void show() {
int height = 199;
System.out.println(age);//Zi类中没有,但是继承了父类的
System.out.println(this.height);//this代表使用子类中成员变量
System.out.println(super.height);//super代表使用父类中成员变量
}
}
public class Demo {
public static void main(String[] args) {
Zi z =new Zi();
z.show();
}
}
输出结果:
20
163
170
6、继承中构造方法的访问特点
子类中所有的构造方法默认都会访问父类中的无参构造方法
为什么?
- 因为子类会继承父类中的数据,可能还会使用父类的数据。所以,子类在初始化之前,一定要先完成父类数据的初始化
- 每一个子类构造方法的第一条语句默认都是super()
- 如果父类中没有无参构造方法时,子类中需要使用super去显式调用有参构造。->一般直接给父类加个无参构造方法
public class Fu {
public Fu() {
System.out.println("父类中无参构造方法被调用");
}
public Fu(int age) {
System.out.println("父类中有参构造方法被调用");
}
}
public class Zi extends Fu{
public Zi() {
//super(); //super可不写,默认就会去调用父类的无参构造。
//如果父类中没有无参构造方法时,子类中需要使用super去显式调用有参构造。
System.out.println("子类中无参构造方法被调用");
}
public Zi(int age) {
//super(); //super可不写,默认就会去调用父类的无参构造
//如果父类中没有无参构造方法时,子类中需要使用super去显式调用有参构造。
System.out.println("子类中有参构造方法被调用");
}
}
public class Demo {
public static void main(String[] args) {
Zi z = new Zi();//默认先去访问父类的父类的无参构造方法
Zi z2 =new Zi(20);//默认先去访问父类的父类的无参构造方法
}
}
输出结果:
父类中无参构造方法被调用
子类中无参构造方法被调用
父类中无参构造方法被调用
子类中有参构造方法被调用
7、继承中成员方法的访问特点
通过子类对象访问一个方法的时:
- 先在子类成员范围内查找
- 再在父类成员范围内查找
- 如果找不到就报错
public class Fu {
public void method() {
System.out.println("Fu中的method方法被调用");
}
}
public class Zi extends Fu{
public void method() {
super.method();//这里注释的话,不会访问父类的method方法
System.out.println("Zi中的method方法被调用");
}
}
public class Demo {
public static void main(String[] args) {
Zi z = new Zi();
z.method();
}
}
8、super内存图
9、方法重写
方法重写概述:
- 子类中出现了和父类中一模一样的方法声明
方法重写的应用:
- 当子类中需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样既沿袭了父类的功能,又定义了子类特有的内容
案例:手机类和新手机类
//手机类
public class Phone {
public void call(String name) {
System.out.println("给"+name+"打电话");
}
}
//新手机类->重写手机类
public class NewPhone extends Phone {
@Overirde
public void call(String name) {
System.out.println("先打开视频"); //子类特有的内容
super.call(name); //直接调用父类的方法,完成方法的重写
}
}
public class PhoneDemo {
public static void main(String[] args) {
Phone p = new Phone();
p.call("luna");
System.out.println("------------------");
NewPhone np = new NewPhone();
np.call("luna");
}
}
@Override
- 注解annotation
- 可以帮助我们检查重写方法的方法声明的正确性
方法重写的注意事项:
- 私有方法private不能被继承(父类的私有成员子类不能继承)
- 子类的访问权限不能低于父类的访问权限
(public > protected > default(不写) > private) - Java中的类只支持单继承,不支持多继承(即一个子类不能同时继承父类A和父类B)
- Java中的类支持多层继承(即子类继承于父类,父类继承自超父类,那么子类可以同时拥有父类和超父类的方法)
案例:老师和学生
需求:定义老师类和学生类,然后写代码测试;最后找到老师类和学生类当中的共性内容,抽取一个父类,用继承的方式改写代码,并进行测试。
思路:
1、定义老师类->姓名、年龄、教书()
2、定义学生类->姓名、年龄、学习()
3、定义测试类,写代码测试
4、共性抽取父类,定义人类(姓名、年龄)
5、定义老师类,继承人类,并给出自己特有的方法:教书()
6、定义学生类,继承人类,并给出自己特有的方法:学习()
7、定义测试类,写代码测试
public class People {
private String name;
private int age;
public People() {
//无参构造
}
public People(String name, int age) {
//有参构造
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Teacher extends People{
public Teacher() {
//无参构造
}
public Teacher(String name,int age) {
//有参构造
super(name,age);
}
public void teach() {
System.out.println("老师教书");
}
}
public class Student extends People{
public Student() {
}
public Student(String name,int age) {
super(name,age);
}
public void Study() {
System.out.println("好好学习,天天向上");
}
}
public class PeopleDemo {
public static void main(String[] args) {
Teacher t1 = new Teacher();
t1.setName("陈老师");
t1.setAge(30);
System.out.println(t1.getName()+","+t1.getAge());
t1.teach();
Teacher t2 = new Teacher("刘老师",33);
System.out.println(t2.getName()+","+t2.getAge());
t2.teach();
Student s1 = new Student();
s1.setName("luna");
s1.setAge(18);
System.out.println(s1.getName()+","+s1.getAge());
s1.Study();
Student s2 = new Student("tom",19);
System.out.println(s2.getName()+","+s2.getAge());
s2.Study();
}
}
输出结果:
陈老师,30
老师教书
刘老师,33
老师教书
luna,18
好好学习,天天向上
tom,19
好好学习,天天向上
案例:猫和狗
需求:请采用继承的思想实现猫和狗的案例,并在测试类中进行测试
思路:
1、定义动物类Animal
共性:
成员变量:姓名,年龄;构造方法:无参,带参;成员方法:get/set方法
2、定义猫类Cat
cat:
成员变量:姓名,年龄
构造方法:无参,带参
成员方法:get/set方法,抓老鼠()
3、定义狗类Dog
dog:
成员变量:姓名,年龄
构造方法:无参,带参
成员方法:get/set方法,看门()
4、定义测试类AnimalDemo
public class Animal{
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Cat extends Animal {
public Cat(){
}
public Cat(String name, int age) {
super(name, age);
// TODO Auto-generated constructor stub
}
public void catchMouse() {
System.out.println("Cat can catch mouse");
}
}
public class Dog extends Animal{
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
// TODO Auto-generated constructor stub
}
public void doorKeep() {
System.out.println("dog is the doorkeeper");
}
}
public class AnimalDemo {
public static void main(String[] args) {
Cat c1 = new Cat();
c1.setName("orange cat");
c1.setAge(1);
System.out.println(c1.getName()+","+c1.getAge());
c1.catchMouse();
Dog d1 = new Dog();
d1.setName("black dog");
d1.setAge(2);
System.out.println(d1.getName()+","+d1.getAge());
d1.doorKeep();
}
}
测试输出结果:
orange cat,1
Cat can catch mouse
black dog,2
dog is the doorkeeper