继承和多态（java）

最新推荐文章于 2024-09-13 21:40:38 发布

桂圆八宝周

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量106

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_62787658/article/details/127835533

版权

1.继承

1.1 继承概念

继承 (inheritance) 机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能 ，这样产生新的类，称 派生类 。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用 。

举个栗子

1.2 继承的语法

在Java 中如果要表示类之间的继承关系，需要借extends关键字

修饰符 class 子类 extends 父类 { 
// ... 
}

注意：

1. 子类会将父类中的成员变量或者成员方法继承到子类中了

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

1.3 父类成员访问

在子类方法中或者通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。

如果访问的成员变量子类中无，则访问父类继承下来的，如果父类未定义，则编译报错。

如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找

1.4 super 关键字

Java提供了 super 关键字，该关键字主要作用：在子类方法中访问父

类的成员。

public class Base { 
    int a; 
    int b;
  public void methodA() { 
    System.out.println("Base中的methodA()"); 
 }
public void methodB(){ 
    System.out.println("Base中的methodB()"); 
  }
}

public class Derived extends Base{ 
    int a; 
// 与父类中成员变量同名且类型相同
    char b; 
// 与父类中成员变量同名但类型不同 
// 与父类中methodA()构成重载
public void methodA(int a) { 
    System.out.println("Derived中的method()方法"); 
}
// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
  public void methodB(){ 
    System.out.println("Derived中的methodB()方法"); 
}
    public void methodC(){ 
// 对于同名的成员变量，直接访问时，访问的都是子类的 
    a = 100;   // 等价于： this.a = 100; 
    b = 101;   // 等价于： this.b = 101; 
// 注意：this是当前对象的引用 
// 访问父类的成员变量时，需要借助super关键字 
// super是获取到子类对象中从基类继承下来的部分 
    super.a = 200; super.b = 201; 
// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
    methodA(); 
// 没有传参，访问父类中的methodA()
    methodA(20); 
// 传递int参数，访问子类中的methodA(int) 
// 如果在子类中要访问重写的基类方法，则需要借助super关键字
    methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到 
    super.methodB(); // 访问基类的methodB() 
}
 }

【 注意事项 】

1. 只能在非静态方法中使用

2. 在子类方法中，访问父类的成员变量和方法 。

1.5 子类构造方法

public class Base {
    public Base(){ 
      System.out.println("Base()"); 
  }
}
    public class Derived extends Base{
    public Derived(){ 
  // super(); 
  // 注意子类构造方法中默认会调用基类的无参构造方法：super(), 
  // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句， 
  // 并且只能出现一次                 
  System.out.println("Derived()"); 
  } 
}
    public class Test {    
        public static void main(String[] args) { Derived d = new Derived(); 
  } 
}
    结果打印： Base() Derived()

1.6 super 和 this

super和 this 都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

【 相同点 】

1. 都是 Java 中的关键字

2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段

3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

【 不同点 】

1. this是当前对象的引用，当前对象即调用实例方法的对象， super 相当于是子类对象中从父类继承下来部分成员的引用

1.8 再谈初始化

class Person {
    public String name;
    public int age;
  public Person(String name, int age) { 
    this.name = name; 
    this.age = age; 
    System.out.println("Person：构造方法执行"); }
{ 
    System.out.println("Person：实例代码块执行"); 
}

    static { 
        System.out.println("Person：静态代码块执行"); 
}
  }
class Student extends Person{
    public Student(String name,int age) { 
    super(name,age); 
    System.out.println("Student：构造方法执行"); 
}

{ 
    System.out.println("Student：实例代码块执行"); 
}

    static { 
        System.out.println("Student：静态代码块执行"); 
}
 }
    public class TestDemo4 {
    public static void main(String[] args) { 
        Student student1 = new Student("张三",19);             
        System.out.println("==========================="); 
        Student student2 = new Student("李四",20);

}
    public static void main1(String[] args) { 
    Person person1 = new Person("xq",10);         
    System.out.println("============================"); 
    Person person2 = new Person("lyr",20); 
} 
  }

执行结果：

Person：静态代码块执行

Student：静态代码块执行

Person：实例代码块执行

Person：构造方法执行

Student：实例代码块执行

===========================

Person：实例代码块执行

Person：构造方法执行

Student：实例代码块执行

Student：构造方法执行

结论：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

1.9 继承方式

1.10 fifinal 关键字、

fifinal关键可以用来修饰变量、成员方法以及类。

1. 修饰变量或字段，表示常量 ( 即不能修改 )

2. 修饰类：表示此类不能被继承

我们平时是用的 String 字符串类 , 就是用 fifinal 修饰的 , 不能被继承 .

3. 修饰方法：表示该方法不能被重写 ( 后序介绍 )

1.11 继承与组合

和继承类似, 组合也是一种表达类之间关系的方式 , 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法

(诸如 extends 这样的关键字 ), 仅仅是将一个类的实例作为另外一个类的字段。

继承表示对象之间是is-a 的关系 ，比如：狗是动物，猫是动物

组合表示对象之间是has-a 的关系 ，比如：汽车

2. 多态

2.1 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状 态。

2.2 多态实现条件

在java 中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

3. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

2.3 重写

重写(override) ：也称为覆盖。重写是子类对父类非静态、非 private 修饰，非 fifinal修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变 。 即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

【 方法重写的规则 】

子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 ( 参数列表 ) 要完全一致被重写的方法返回值类型可以不同，但是必须是具有父子关系的

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public 修饰，则子类中重写该方法就不能声明为 protected

父类被static 、 private 修饰的方法、构造方法都不能被重写。

重写的方法, 可以使用 @Override 注解来显式指定 . 有了这个注解能帮我们进行一些合法性校验 . 例如不小心

将方法名字拼写错了 ( 比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法 , 就会编译报错 , 提示无法构成重写.

2.4 向上转移和向下转型

2.4.1 向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型对象名 = new 子类类型 ()

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

2.4.2 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

Java 中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为 true ，则可以安全转换。

public class TestAnimal {

        public static void main ( String [] args ) {

        Cat cat = new Cat ( " 元宝 " , 2 );

        Dog dog = new Dog ( " 小七 " , 1 );

// 向上转型

        Animal animal = cat ;

        animal . eat ();

        animal = dog ;

        animal . eat ();

        if ( animal instanceof Cat ) {

                cat = ( Cat ) animal ;

                cat . mew ();

}

        if ( animal instanceof Dog ) {

        dog = ( Dog ) animal ;

dog . bark ();

}

}

}

2.5 多态的优缺点

假设有如下代码：

class Shape {

        //属性 ....

        public void draw () {

        System . out . println ( " 画图形！ " );

}

}

        class Rect extends Shape {

        @Override

        public void draw () {

        System . out . println ( " ♦ " );

}

}

        class Cycle extends Shape {

        @Override

        public void draw () {

        System . out . println ( " ● " );

}

}

        class Flower extends Shape {

        @Override

        public void draw () {

        System . out . println ( " ❀ " );

}

}