[Java入门] 多态
多态
1. 多态的概念
多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。
2. 多态的实现条件
实现多态有三个必要条件,缺一不可:
- 向上转型
- 方法重写
- 通过父类引用,调用子类对象重写的方法
多态体现:在代码运行时,当传递不同类对象时,会调用对应该类中重写的方法。
class Person{
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void play(){
System.out.println(name + " 在玩!");
}
}
class Student extends Person{
public Student(String name, int age) {
super(name, age);
}
@Override
public void play() {
System.out.println(name + " 在打篮球!");
}
public void study() {
System.out.println(name + " 在学习!");
}
}
class Employee extends Person{
public Employee(String name, int age) {
super(name, age);
}
@Override
public void play() {
System.out.println(name + " 在团建!");
}
public void work() {
System.out.println(name + " 在工作!");
}
}
public class Main {
public static void play(Person person) {
person.play();
}
public static void main(String[] args) {
Student student = new Student("小明", 15);
Employee employee = new Employee("小兰", 25);
//传递不同对象,会调用不同对象重写的方法
play(student); //结果: 小明在打篮球!
play(employee); //结果: 小兰在团建!
}
阅读上述代码,可明显看出当传递不同类对象时,会调用对应该类中重写的方法。而发生这种情况的原理就是 ‘向上转型’
3. 向上转型
3.1 向上转型
所谓向上转型, 即就是实例化一个子类对象,把它当作父类对象来使用。
那怎么构成向上转型呢? 我们参考上面代码,通过创建 Student类 和 Employee类 的引用 student 和 employee,传参给形参为它们父类 Person类 的play方法,通过调用play方法便实现了向上转型。
所以,我们可以推出 向上转型的语法格式:父类类型 对象名 = new 子类类型()
Person person1 = new Student("小明", 15);
Person person2 = new Employee("小兰", 25);
可见, 向上转型是从小范围向大范围转移。
3.2 发生向上转型的方式
发生向上转型的方式 有3种:
- 直接赋值
Person person1 = new Student("小明", 15);
Person person2 = new Employee("小兰", 25);
- 方法传参
public static void main(String[] args) {
Student student = new Student("小明", 15);
Employee employee = new Employee("小兰", 25);
func1(student);
func1(employee);
}
public static void func1(Person person) {
}
看完代码后,也许会有点眼熟,没错!与前面的代码是类似的,它们都是通过方法传参的方式实现向上转型的。
- 返回值
public static void main(String[] args) {
//两个方法通过返回值都能实现向上转型
//但是 func2 不够灵活, 因为 func2 的返回值只能是 Student类型
//而 func3 的返回值就能返回 Person类 的所有子类类型
//因此 func3 更加灵活, 一般建议多使用 func3 这种方式!
Person person1 = func2();
Person person2 = func3();
}
public static Student func2(){
return new Student("小明", 15);
}
public static Person func3(){
return new Student("小明", 15);
}
向上转型的优点:让代码实现更简单灵活。
向上转型的缺陷:不能调用到子类特有的方法。
3.3 向下转型
所谓向下转型,即将父类引用再还原为子类对象。
我们将子类对象向上转型后就不能再使用子类特有的方法了,但是,有时我们需要调用子类特有的方法,那么仅需将向上转型后的子类对象再次强转为子类引用,就可以使用子类特有的方法了,这就是向下转型。
public static void main(String[] args) {
Person person1 = new Student("小明", 15);
//person1.study(); 报错 向上转型后无法再调用子类特有方法!
Student student = (Student) person1;
student.study(); // 向下转型后 便可再次调用子类特有方法了!
}
向下转型还有一个需要注意的点,就是再次强转的类型一定是与向上转型前的类型一致,否则会报错。
通俗点讲,就是你原来是学生,不可能后面变回来就不再是学生了。
这就体现出了向下转型的不安全,所以Java中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为true,则可以安全转换。
instanceof 关键字主要用法就是用于判断前者是否引用了后者
public static void main(String[] args) {
Person person1 = new Student("小明", 15);
Employee employee = (Employee) person1;
//employee.work();//运行报错 java.lang.ClassCastException:class Student cannot be cast to class Employee
Person person2 = new Employee("小兰", 25);
if(person2 instanceof Student) {
Student student = (Student) person2;
student.study();
}else {
System.out.println("我已经上班很久了!!!!");
}
//一般进行向下转型前都需用instanceof判断
}
4. 方法重写
重写(override):也称为覆盖。重写是子类对父类非静态、非private修饰,非final修饰,非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
4.1 方法重写的规则
- 在子类重写父类方法时,一般要求外壳不变,即方法名、参数列表和返回值类型要完全相同
- 若子类与父类构成继承关系,那么返回值类型可以不同,但必须具有父子关系
- 若方法被static、private修饰 或者 是构造方法,则此方法不可重写
- 方法的访问权限不能比父类中被重写的方法访问权限更低。如,若父类方法被public修饰, 那么在子类重写的方法是不能用protected 或 default 修饰,可以用public修饰
- 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.
4.2 重写和重载的区别
即:方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
方法重载
class A {
public void B(int n){
System.out.println(n);
}
public int B(int n,int m){
return n+m;
}
}
public static void main(String[] args) {
int n = 10;
int m = 20;
A a = new A();
a.B(n);
System.out.println(a.B(n, m));
}
//结果:
//10
//30
方法重写
class Person{
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void play(){
System.out.println(name + " 在玩!");
}
}
class Student extends Person{
public Student(String name, int age) {
super(name, age);
}
@Override
public void play() {
System.out.println(name + " 在打篮球!");
}
}
//结果:小明 在打篮球!
[两种绑定]
静态绑定:也称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。典型代表方法重载。
动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。典型代表方法重写。
5. 避免在构造方法中调用重写的方法
class B{
public B() {
func();
}
public void func(){
System.out.println("B.func()");
}
}
class C extends B{
public int c = 10;
public void func(){
System.out.println("C.func() " + c);
}
}
public class test {
public static void main(String[] args) {
C c = new C();
}
}
//结果:C.func() 0
看到结果后,有人可能觉得疑惑为什么不是 C.func() 10 呢?这就是因为构造方法没有多态性。
我们先来解释一下上述代码的运行步骤:
- 首先在main方法中构造了c对象,由于继承关系,会先调用父类 即B的构造方法
- 然后在B的构造方法中调用了func方法,由于子类C重写了func方法,那么就会直接调用子类C中的func方法
- 由于是直接调用C的func方法,变量c并未初始化为10,而是存储着未初始化状态下的默认值0,最后打印结果 C.func() 0 ,这是不具有多态性的情况
- 若构造方法存在多态性,就会直接调用子类构造对c初始化,结果就为C.func 10
- 所以,在构造函数内,尽量避免使用实例方法,除了final和private方法。
结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.
本期内容到这就结束了,欢迎大家多多提出疑问 或 内容存在的问题!!!