Java面向对象编程之多态
一.对于多态的理解:
通俗点理解,多态其实就是一词多义,就是一种方法的多种状态,即不同的类对象,调用同一个方法名,有不同的实现效果,如下面这段代码块:
public class Test { public static void main(String[] args) { Dog dog = new Dog("豆豆"); Cat cat = new Cat("花花"); dog.eat(); cat.eat(); } }
对象dog和cat看似都调用了eat方法,都没有传参,按理说输出的结果应该一样,但其实不是这样的,让我们来看一下输出的结果:
这就是多态的一种表现,所属不同类的不同对象调用同一个方法名,却有着不同的实现效果。
二.多态的实现方法
Java中通过 方法重写(也叫方法覆写)、方法重载和接口实现多态(主要依赖于继承机制+方法覆写)
1.方法重载
方法重载十分好理解,就是子类和父类的方法名相同,但是参数个数或类型不一样,返回值不作要求,这里不再赘述
2.方法重写
对于方法重写,通常结合向上转型和向下转型两种形式进行应用,其中向上转型更为常见,向下转型相对使用较少
(1)向上转型:就是子类向父类转,向上转型最大的好处就是可以实现参数统一化,向上转型可以表现在三个地方:
其一:产生对象时:
注意:用这种形式创建的实例化对象dog1,其能调用的方法范围由父类Animal决定,即只能调用Animal类中的方法,而不能调用子类独有的方法,只有当子类有对父类的方法重写时,才调用子类重写后的方法!!!
其二:方法参数的传递:
其三:方法返回值的传递
向上转型的最大好处就是——参数统一化,父类引用可以接收子类所有对象
看下面这个例子:
完整代码为:
public class Animal { public String name; public Animal(String a){ name = a; } public void eat(){ System.out.println("食物"); } public static void fun(Animal animal){ animal.eat(); } } public class Dog extends Animal{ public Dog(String name){ super(name); } public void eat(){ System.out.println("骨头"); } } public class Cat extends Animal{ public Cat(String name){ super(name); } public void eat(){ System.out.println("鱼"); } } public class Test { public static void main(String[] args) { Dog dog = new Dog("豆豆"); Cat cat = new Cat("花花"); dog.fun(dog); cat.fun(cat); } }
结果为:
拆开来分析:
fun方法的参数为Animal类的实例化对象
Animal的子类对象,可以直接传入
也就是说,对于Animal类的所有子类实例化对象,均可以直接向fun方法传参,避免了重复性的写诸如 public static void fun(Dod d){}, public static void fun(Cat a){}等方法
(2)向下转型:向上转型是子类向父类转,向下转型则是将转为的父类还原为子类,这里用 还原 这个词是因为能向下转型的前提是:先发生向上转型且我们需要使用子类独有的方法时,才使用向下转型,也很好理解,父类不一定是子类,只有由子类转成的才可以向下转型还原,向下转型的形式如下:
Animal animal = new Dog("豆豆"); Dog dog = (Dog)animal;
基本类似与强制类型转换
注意:向下转型是有风险的,可能无法强制转换成功,这里可以引用instanceof类,用if语句判断,避免报错
if(dog instanceof Dog){ }
(3)方法重写的几点注意要求:
- 只能覆写成员方法,不能重写static静态方法,但是方法重载是可以重载static方法的
- 子类进行方法重写,子类方法的权限修饰符>=父类方法的权限修饰符,同时,子类并不能覆写父类的private方法,对于父类的包访问权限修饰方法,在不同包下的子类也不能覆写
- 用final修饰的方法也不能覆写哦(JDK中的String类就是一个final类)
- 返回值必须相同,或是向上转型的,即覆写的方法的返回值可以是父类方法返回类型的子类
- 注意方法覆写与方法重载的区别,方法覆写:子类与父类的方法名一样,参数、返回值类型均一样,如果只返回值类型不一样编译会报错
- 可使用@override 检验方法覆写是否一样
(4)最后是一道例题,容易掉坑:
public class A { public A(){ this.func(); } public void func(){ System.out.println("A"); } } class B extends A{ private int num; public B(int num){ this.num = num; } public void func(){ System.out.println("B的num==" + num); } public static void main(String[] args) { B b = new B(100); b.func(); } }
分析运行后会输出什么呢?
仔细想想,小心掉坑,答案在文章末尾给出
3.抽象类
对于方法的覆写,一般的继承关系下,子类是可以选择覆写也可以选择不覆写的,但在一些场景下,我们想对子类作出强制性覆写要求,这就引出了抽象类的概念
(1)抽象类用abstract修饰,抽象类是普通类的超集,它只是在普通类的基础上多了抽象方法,抽象方法是没有方法体的,形式如下:
(2)抽象类必须有子类继承
(3)抽象类无法实例化对象,仅能用子类new相应的对象
(4)普通子类继承抽象类,必须覆写所有的抽象方法,当子类仍为抽象类时,可以选择不覆写,依旧保留抽象方法
(5)abstract修饰符不能和final同时使用,也不能和private同时使用
4.接口
上面讲的抽象类虽然能实现方法的覆写,但还是有缺陷的,比如抽象类还是遵循单继承原则,一个类也只能继承一个抽象类,同时,在语义上,只要继承,就是A is B 的意思,有时候并不符合逻辑,故而又引出了接口这个概念
(1)接口的定义与使用
我们用关键字interface来定义接口,子类用关键字 implements来实现接口,同时,通常,在命名接口时,我们会用大写的字母“I”开头命名以示区别,如下面一段代码的接口名为 IMessage ,而对于实现接口的子类命名我们通常用Impl作后缀
(2)接口的特点:
接口中只有全局常量和抽象方法(JDK8之前,JDK8又扩展了default方法,了解即可),如:
public interface IMessage { public static final int a = 10; public abstract void print(); }
接口中只有public权限,且全部为全局常量和抽象方法,故而,在接口内,public、static、final、abstract可以省略不写,默认即为这些关键字,故上一段代码可以直接写成下面这段:
public interface IMessage { int a = 10; void print(); }
接口是没有单继承限制的,子类可以implements多个父接口,父接口之间用逗号隔开,如:
public class CImpl implements IB,IMessage{ public void print(){ } public void printf(){ }}
- 同时,接口之间也可以多继承,一个接口可以extends多个父接口
- 接口同抽象类一样,是不能直接实例化对象的,必须通过实现它的子类进行实例化
- 如果一个子类既有继承的父类,也有实现的接口,则先继承父类再实现父接口
(3)常用的JDK内置的两大接口
a:Comparable接口
当使用Arrays.sort()方法排序时,当排序对象为自定义的类时,sort方法不知道应该按照对象的什么属性进行排序,故而待排序的自定义类需实现该接口,并将抽象方法compareTo覆写,形式如下:
import java.util.Arrays; public class Person implements Comparable{ // 两个属性,name和age private String name; private int age; // 有参构造 public Person(String name,int age){ this.name = name; this.age = age; } // 定义输出 public String toString(){ return name + "的年龄是" + age; } // 覆写compareTo方法 public int compareTo(Person o){ return (this.age - o.age); } public static void main(String[] args) { Person p1 = new Person("言希",18); Person p2 = new Person("温衡",16); Person p3 = new Person("思莞",17); Person []p = new Person[]{p1,p2,p3}; // 用sort方法排序 Arrays.sort(p); System.out.println(Arrays.toString(p)); } }
输出结果(按年龄升序):
b: Cloneable接口
Cloneable接口位于java.lang包中,顾名思义,就是用于克隆,在代码中也就是复制新的对象,新对象的属性方法都是从原对象中拷贝过来的,在实现该接口时,只需要覆写Object类提供的clone方法,如下面示例:
//实现Cloneable接口 public class Animall implements Cloneable{ private String name; // clone方法 protected Animall clone() throws CloneNotSupportedException { return (Animall)super.clone(); } public static void main(String[] args) throws CloneNotSupportedException{ Animall a1 = new Animall(); a1.name = "豆豆"; // a2由a1克隆而来 Animall a2 = a1.clone(); // 输出a2,和a1一致 System.out.println(a2.name); // 但是a1并不是a2 System.out.println(a1 == a2); } }
结果如下:
补充:
- Cloneable接口是标记接口,即它本身并没有任何抽象方法,当一个类实现了该接口,就表示该类具备了克隆能力
- clone方法的源代码为protected native object clone() throws CloneNotSupportedException;,其中native也是一个关键字,表明是本地方法,即调用了C++的同名方法故而,我们还可以发现,native修饰的方法也是没有方法体的
- 没有方法体的一定是抽象方法 ⅹ错误,因为native方法也是没有方法体的
好了,多态的内容基本就是这么多了,java中的多态主要依赖于继承和方法覆写,而对于那些需要强制性覆写的方法,我们又引出了抽象类,再鉴于抽象类有局限,我们又学习了接口,整体上内容就是这么多了,注意的细节比较多,多敲代码理解理解更棒。
最后,将文中那道例题答案奉上:
答案解析来啦
从main方法开始,执行的第一句为 B b = new B(100);,因为B继承自A,故而执行B 的构造方法要先去执行A的构造方法,public A(){ this.func(); },这里注意,虽然是A的构造,但对象是B的,故这里的this,func()实际是B.func(),public void func(){System.out.println(“B的num==” + num);}
因为这里其实还没给num赋值成功,所以num现在还是默认值0,所以输出了答案的第一句 B的num == 0,然后接着执行B的构造方法,将100赋值给了num,最后执行b.func,也就输出了答案的第二句 B的num ==100
总结
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注脚本之家的更多内容!