java基础（5）继承与多态
目录
编辑
1.前言
2.正文
2.1继承
2.1.1继承概念
2.1.2继承语法
2.1.3子类访问父类
2.1.4super关键字
2.2多态
2.2.1多态概念
2.2.2多态条件
2.2.3重写
2.2.4向上转型与向下转型
2.2.5为什么要使用多态
3.小结
1.前言
哈喽大家好啊，今天继续来为大家分享java基础语法的学习，今天分享的是java中的继承与多态，也是Java基础学习当中非常重要的一部分，话不多说让我们开始吧。
2.正文
2.1继承
2.1.1继承概念
先让我们来引入一下继承，当我们在java编写程序的时候，会创建许多个类，如果每个类都单独创建的话，会使代码看起来非常的冗长，于是对于有相同特点的类，我们对其进行共性的抽取，便有了继承的概念。
继承是一种面向对象编程（OOP）的核心概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。使用继承可以创建一个层次结构，其中子类继承父类的属性和方法，并且可以添加或覆盖它们。
2.1.2继承语法
那么继承的语法是如何实现的呢。这里我们就需要运用extends关键字，具体例子参照上面那个图，让我们附上代码。
person父类：
public class person {
String name;
int age;
public person(String name,int age) {
this.name = name;
this.age = age;
}
public void func(){
System.out.println("目前在学校");
}
}student子类：
public class student extends person {
int id;
public student(String name, int age, int id) {
super(name, age);
this.id = id;
}
public void havaClass() {
System.out.println("在听课");
}
}teacher子类：
public class teacher extends person{
String subject;
public teacher(String name, int age, String subject) {
super(name, age);
this.subject = subject;
}
public void makeClass() {
System.out.println("在上课");
}
}测试类：
public class test {
public static void main(String[] args) {
student s1 = new student("张三",16,001);
teacher t1 = new teacher("李四",42,"语文");
s1.havaClass();
s1.func();
t1.func();
t1.makeClass();
}
}运行结果如图：
2.1.3子类访问父类
让我们先来观察下面这段代码：
public class test {
static public class A{
int a = 1;
}
static public class B extends A{
int a = 2;
int b = 3;
}
public static void main(String[] args) {
B b = new B();
System.out.println(b.a);
System.out.println(b.b);
}
}我们可以看到，在类A与类B中均对a整型进行了定义，那么打印的结果会是怎样呢？
我们可以看到，打印的是子类定义的a与b而非父类中的定义。那如果我们将类B中的int a删除呢？
这里打印出来的就是父类中定义的a和子类中定义的b，如果我们再将父类A中的int a删除呢，很显然编译器直接报错，由此我们可以得出：
- 如果访问的成员变量子类中有，优先访问自己的成员变量。
- 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
同理，访问成员方法也是这个道理：
- 如果一个方法子类中定义就优先子类，子类中没有就去父类里面，父类也没有编译器就报错。
- 如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错
2.1.4super关键字
学到这里，我们已经基本明白了如何通过子类访问父类，但如果我们遇到，子类与父类存在变量名相同的情况，此时想访问父类里的同名变量时如何更好的去访问呢？这里我们就引入了super关键字。
super关键字可以访问父类的成员变量，构造方法以及成员方法，下面这段代码将都展示出来：
成员变量：
public class A{
int a = 1;
}
public class B extends A{
public void func() {
System.out.println(super.a);
}
}构造方法：
public class A{
int num;
public A(int num) {
this.num = num;
}
}
public class B extends A{
String str ;
public B(int num, String str) {
super(num);
this.str = str;
}
}成员方法：
public class test {
public static class A {
public void func() {
System.out.println(1);
}
}
public static class B extends A {
public void func() {
super.func();
}
}
public static void main(String[] args) {
B b = new B();
b.func();
}
} 
另外有一些需要注意的点：
- 用户没有写构造方法时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句。
- 当子类继承父类需要先初始化继承过来的父类的成员，此时需要通过super来完成。如果没有通过super调用父类的构造方法，编译器会报错。
2.1.5final关键字
final关键字可以用于类，变量，方法上，接下来附上代码方便理解
当修饰类时，该类则不能被继承：
public class test {
public static final class A {
public void func() {
System.out.println(1);
}
}
public static class B extends A {
@Override
public void func() {
super.func(); // 调用父类的func方法
System.out.println(2);
}
}
public static void main(String[] args) {
B b = new B();
b.func(); // 调用b的func方法
}
}
当修饰方法时，该方法仅能被调用与继承，而并不能被重写：
public class test {
public static class A {
public final void func() {
System.out.println(1);
}
}
public static class B extends A {
@Override
public void func() {
super.func(); // 调用父类的func方法
System.out.println(2);
}
}
public static void main(String[] args) {
B b = new B();
b.func(); // 调用b的func方法
}
}
当修饰变量时，该变量则不能被修改：
public static void main(String[] args) {
final int a = 10;
a = 20;
} 
2.2多态
2.2.1多态概念
让我们先引入多态这个概念，当我们在书写代码时创建多个类时，如学生类和老师类，创建俩个类的方法时，有的方法可能存在类似，但处理后的结果却不同，如老师拿到试题是改作业，学生拿到试题是写试题。鉴于这种情况，我们便引入了多态。
多态（Polymorphism）是面向对象编程（OOP）的一个核心概念。它允许同一个类型的对象在不同的情况下表现出不同的行为。这种特性使得Java程序具有更好的可扩展性、可维护性和可重用性。
2.2.2多态条件
达成多态的条件有以下几个：
- 必须在继承体系下
- 子类必须对父类中方法进行重写（何为重写下文讲解）
- 必须通过父类来引用重写的方法
附上代码：
public class test {
public static class A {
public void func() {
System.out.println(1);
}
}
public static class B extends A {
@Override//标记重写
public void func(){
System.out.println(2);
}
}
public static class C extends A {
@Override//标记重写
public void func(){
System.out.println(3);
}
}
public static void main(String[] args) {
B b = new B();
C c = new C();
b.func();
c.func();
}
}我们可以看到实例化b与实例化c都调用了func函数，那么究竟是父类还是子类的func呢？
根据上文的讲解我们也应该很容易得出，分别调用的是子类重写后的方法。
2.2.3重写
我们上文用了这么多重写，那么到底何为重写呢，下文我们详细盘一盘：
重写（Override）是面向对象编程中的一个重要概念，子类可以重新定义父类中已经定义过的方法，这样当通过子类的实例来调用该方法时，就会执行子类中的实现版本，而不是父类中的版本。
重写的具体规则如下：
方法签名必须相同：重写的方法必须与父类中被重写的方法具有相同的名称、返回类型和参数列表。
访问修饰符：子类重写的方法的访问修饰符不能比父类中被重写的方法的访问修饰符更严格。例如，如果父类中的方法是
public，那么子类中的重写方法也必须是public。但是，子类可以使用更宽松的访问修饰符，如protected。不能重写
final方法：如果父类中的方法是final的，那么子类不能重写该方法。不能重写
static方法：静态方法属于类本身，而不是类的实例。因此，子类不能重写父类中的静态方法。
2.2.4向上转型与向下转型
向上转型与向下转型有点类似于数据类型中int与long之间的强转，接下来就让我们来分别介绍何为向上转型，何为向下转型。
向上转型，指的是将一个子类对象的引用赋值给一个父类类型的变量，而向下转型（Downcasting）是指将父类引用类型转换为子类引用类型的过程。
代码如下：
public class test {
public static class A {
int a = 1;
}
public static class B extends A {
int b = 2;
}
public static void main(String[] args) {
A a = new B();//向上转型
if (a instanceof B) {
B b = (B) a; // 强制类型转换//向下转型
}
}
}其中在进行向下转型之前，通常需要使用instanceof关键字来判断父类引用是否指向了一个子类对象，这是为了确保类型转换的安全性。
2.2.5为什么要使用多态
到此为止我们已经大概讲解完了堕胎的概念以及重写的使用，那我们这样编写代码有什么优缺点呢？
优点有以下主要几点：
提高代码的灵活性和可扩展性：
- 多态允许在运行时动态地决定调用哪个方法，这使得代码更加灵活，易于扩展。
- 当需要添加新的子类时，只需确保新子类实现了父类或接口中的方法，而无需修改现有代码。
简化代码：
- 通过多态，可以使用父类引用来操作子类对象，从而简化代码结构，减少重复代码。
- 多态使得代码更加通用，因为父类引用可以指向任何子类对象。
而缺点也显而易见：
性能开销：
- 多态的实现通常依赖于动态绑定，即在运行时决定调用哪个方法。
- 这可能会使代码的运行效率降低。
复杂性增加：
- 多态使得代码结构更加复杂，因为需要理解父类、子类以及它们之间的关系。
调试难度增加：
- 由于多态允许在运行时动态地决定调用哪个方法，因此调试时可能难以确定哪个方法被实际调用。
- 会增加调试的难度和时间成本。
3.小结
今天关于继承与多态的讲解到这里就结束了，喜欢的小伙伴不要忘了点点关注点点收藏支持一下哦，你的支持就是对我最大的鼓励。