目录
前言
本文为继承和多态的学习笔记,刚开始学习Java,有错误及不完善的地方还请大佬们指出~
1.继承
1.1 定义
类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类或超类,子类会自动拥有父类所有非私有的属性和方法。
继承分为两种:
- 显式继承:通过extends关键字实现继承
class Person { //创建Person类
String name;
int age ;
}
class Teacher extends Person { //子类Teacher类继承于父类Person
void teach(){
System.out.println(name + "是老师,今年" + age + "岁");
}
}
class Student extends Person { //子类Student类继承于父类Person
void study(){
System.out.println(name + "是学生,今年" + age + "岁");
}
}
class Test {
public static void main(String[] args){
Teacher t = new Teacher(); //创建Teacher对象
t. name = "张三" ; //继承了父类的name属性
t. age = 30; //继承了父类的age属性
t.teach(); //调用子类的方法
Student s = new Student(); //创建Student对象
s. name = "李四" ;
s. age = 20;
s.study();
}
}
- 隐式继承:不写extends关键字,自动继承Object类的属性和方法
1.2 作用
通过继承可以快速创建新的类,实现代码的重用,提高程序的可维护性,节省大量创建新类的时间,提高开发效率和开发质量。
1.3 特点
Java中子类不允许同时继承于多个父类,只能单继承
- 一个子类只能继承于一个父类
- 一个父类可以有多个子类
- 允许多层继承,即子类继承于父类,父类再继承于其他父类(A继承于B,B继承于C,则A也为C的子类)
1.4 super关键字
用于指代父类的对象
- super(); → 调用父类的构造函数
【tips】必须写在构造函数内,且必须为第一句
public class A {
String str;
int num;
public A() {
System.out.println("这是A类无参的构造函数");
}
public A(String str) {
System.out.println("这是A类1个参的构造函数");
}
public A(String str, int num) {
System.out.println("这是A类2个参的构造函数");
}
}
public class B extends A {
public B() {
//默认调用父类无参构造函数
System.out.println("这是B类无参的构造函数");
}
public B(String str) {
super(str,20); //调用A类2个参数的构造函数
System.out.println("这是B类1个参的构造函数");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B(); //创建B类对象(无参)
System.out.println("--------------------------");
B b2 = new B("123"); //创建B类对象(1个参数)
}
}
运行结果:
- 用于调用父类的属性和方法
public class A {
public int add(int x, int y) {
return x + y;
}
}
public class B extends A {
public B() {
System.out.println(super.add(15, 20)); //调用父类add方法
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
}
}
运行结果:
- 子类和父类中成员属性同名用super指代父类
public class A {
String str = "A的str";
}
public class B extends A {
String str = "B的str";
public B() {
System.out.println(super.str); //输出A类str
System.out.println(str); //输出B类str
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
}
}
运行结果:
1.5 重写(override)
子类中将父类方法重写一遍,用于子类需要父类主体功能,而主体功能又有子类特定内容时。
重写要求:子类中方法声明与父类中的完全相同,即返回值、方法名、形参(类型、个数、顺序)均相同
public class A {
public void hello() {
System.out.println("Hello, world!");
}
public void bye() {
System.out.println("Goodbye~");
}
}
public class B extends A {
public void hello() { //重写父类hello方法
System.out.println("你好,世界!");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.hello(); //调用子类hello()
b1.bye(); //调用父类继承的bye()
}
}
运行结果:
【tips】
- 重写后返回值可以缩小,即父类中返回父类对象,则子类中可以改为返回子类对象
- 重写后抛出异常可以缩小
- 重写后访问权限只能放大或不变,不能缩小
2.多态
2.1 具体体现
- 重载(overload)
- 重写(override)
- 父类引用指向子类对象
- 接口可以有多个实现类
2.2 父类引用指向子类对象
父类类型 对象名 = new 子类类型();
例:A a = new B(); 其中B继承于A
【tips】
- 在B类中定义A类没有的方法,A类引用无法调用该方法
- 如果B类中没有重写A类的方法,则继承A类方法,否则调用B类
public class A {
public void hello() {
System.out.println("Hello, world!");
}
public void bye() {
System.out.println("Goodbye~");
}
}
public class B extends A {
public void hello() {
System.out.println("你好,世界!");
}
public void goodbye() { //子类中定义而父类中没有,因此无法调用
System.out.println("拜拜~");
}
}
public class Test {
public static void main(String[] args) {
A a = new B();
a.hello(); //子类中重写,调用子类
a.bye(); //子类中未重写,继承父类
}
}
运行结果:
2.3 接口
2.3.1 抽象类
含有抽象方法的类称为抽象类,其中抽象方法为只有方法声明而没有方法体的方法。抽象方法和抽象类都必须用abstract关键字修饰
- 抽象类中可以既有抽象方法又有非抽象方法
- 抽象类用于给子类提供统一的功能声明
- 抽象类不能创建对象
- 抽象类中可以有构造函数
2.3.2 接口 —— 特殊的抽象类
用于解决Java中类只能单继承的问题,通过interface关键字定义接口,一个类可以实现(关键字implements)多个接口。而一个类实现了某个接口,则这个类称为实现类。
【tips】
- jdk8之前
- 接口中所有方法都必须是抽象方法
- 不能直接在接口中实现
- jdk8之后
- 接口中允许有实现方法,但需要写为静态方法,通过接口名调用
- 实现方法不写静态时,必须用default修饰,通过实现类对象调用
- 接口中所有属性默认为public static final类型
//单实现
public interface InterfaceA { //定义接口InterfaceA
public void printA();
}
public class ImplementA implements InterfaceA { //实现类实现接口
@Override
public void printA() { //重写InterfaceA接口中的printA方法
System.out.println("实现了接口A");
}
}
//多实现
public interface InterfaceB { //定义新的接口InterfaceB
public void printB();
}
public class ImplementB implements InterfaceA,InterfaceB { //实现类ImplementB同时实现InterfaceA和InterfaceB两个接口
@Override
public void printA() { //重写InterfaceA接口中的printA方法
System.out.println("实现了接口A");
}
@Override
public void printB() { //重写InterfaceB接口中的printB方法
System.out.println("实现了接口B");
}
}