目录
一、前言
二、多态
(一)多态的概念
(二)多态实现条件
(三)多态的优缺点
三、重写
(一)重写的概念
(二)重写的规则
(三)重写和重载的区别
四、向上转型和向下转型
(一)向上转型
(二)向下转型
五、总结
一、前言
大家好,前几天蜡笔小欣带大家了解并学习了Java中的继承,子类通过extends关键字来继承父类。通过继承,子类可以重写父类的方法,从而实现多态性。今天我们就一起去认识Java中的多态,了解多态的概念,掌握多态的用法,使我们在写程序时更加方便。
二、多态
(一)多态的概念
简单来说就是同一件事情,发生在不同对象身上,会产生不同的结果 。
(二)多态实现条件
多态实现的条件:
1. 必须在继承体系下,2. 子类必须要对父类中方法进行重写,3. 通过父类的引用调用重写的方法。
下面举个例子让大家更好地理解:
我们先定义一个父类Animal,这个类里面有两个成员变量,一个方法。
class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name + "正在吃东西");
}
}
接着我们定义两个子类,分别是Dog和Cat,都继承父类Animal,在这两个类中重写eat()方法。
class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(name + "正在吃狗粮");
}
public void bark() {
System.out.println(name + "汪汪汪");
}
}
class Cat extends Animal {
public Cat(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(name + "正在吃猫粮");
}
public void mew() {
System.out.println(name + "喵喵喵");
}
}
然后我们在Test里面定义一个静态方法func(),父类Animal作为参数引用,再调用eat()方法。
public class Test {
public static void eat(Animal animal) {
animal.eat();
}
}
最后实例化对象,进行初始化赋值。
public static void main(String[] args) {
Dog dog = new Dog("小白", 3);
Cat cat = new Cat("汤姆", 5);
eat(dog);
eat(cat);
}
(三)多态的优缺点
多态的优点:1. 能够降低代码的 " 圈复杂度 ", 避免使用大量的 if - else,2. 可扩展能力更强。多态缺陷:代码的运行效率降低 。
三、重写
(一)重写的概念
(二)重写的规则
2.被重写的方法返回值类型可以不同,但是必须是具有父子关系的。我们可以理解为将eat()方法定义为父子关系。
3.访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类方法被public修饰,则子类中重写该方法就不能声明为protected。
4.父类被static、private修饰的方法、构造方法都不能被重写。
5.重写的方法,可以使用 @Override 注解来显式指定。 有了这个注解能帮我们进行一些合法性校验。 例如不小心将方法名字拼写错了 (比如写成 aet),那么此时编译器就会发现父类中没有 aet 方法,就会编译报错,提示无法构成重写。
操作步骤:1.点击鼠标右键,点击generate。
2.选择红色箭头所指向的部分。
3.点击我们要重写的方法。
4.最后就可以对父类的方法进行重写,如果我们不小心把重写的方法名写错了,@Override就可以帮我们检测出来,使我们在重写方法时更加方便。
(三)重写和重载的区别
方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
四、向上转型和向下转型
(一)向上转型
语法格式:父类类型 对象名 = new 子类类型()Animal animal = new Cat ( " 汤姆 " , 5 );
animal是父类类型,但可以引用一个子类对象,因为是从小范围向大范围的转换。
下面我们举个例子看看:
class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name + "正在吃东西");
}
}
class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println(name +"正在吃狗粮");
}
public void bark() {
System.out.println(name + "汪汪汪");
}
}
public class Test {
public static void eat(Animal animal) {
animal.eat();
}
public static void main(String[] args) {
Dog dog = new Dog("小白", 3);
Animal animal =dog;//animal这个引用指向了Dog对象
animal.eat();
}
}
运行结果如下:
当我们把Dog类中eat()方法注释后,运行结果为:
我们会发现它执行了父类Animal中的eat()方法。那如果这时候我们在Dog类中加入一个color成员变量。
然后我们用对象animal去调用它试试看能否运行。
我们发现结果报错,这是因为color这个属性是Dog类中的,而animal无法访问到。
Tips:向上转型的优点:让代码实现更简单灵活。向上转型的缺陷:不能调用到子类特有的方法。
(二)向下转型
class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name + "正在吃东西");
}
}
class Dog extends Animal {
public String color;
public Dog(String name, int age) {
super(name, age);
this.color = color;
}
/*@Override
public void eat() {
System.out.println(name +"正在吃狗粮");
}*/
public void bark() {
System.out.println(name + "汪汪汪");
}
}
class Cat extends Animal {
public Cat(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(name + "正在吃猫粮");
}
public void mew() {
System.out.println(name + "喵喵喵");
}
}
public class Test {
public static void eat(Animal animal) {
animal.eat();
}
public static void main(String[] args) {
Dog dog = new Dog("小白", 3);
Animal animal = dog;//animal这个引用指向了Dog对象
Cat cat = new Cat("汤姆", 5);
cat = (Cat) animal;
cat.mew();
}
}
Animal向下转型为Cat,Cat本来就是猫,转换为猫,安全;Animal向下转型为Dog,Cat本来是猫,转换为狗,则不安全。
运行结果:
因为animal实际指向的是狗,但现在要强制还原为猫,无法正常还原,所以运行时抛出类型转换异常。
解决方法:
Java 中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为 true ,则可以安全转换。
public class Test {
public static void eat(Animal animal) {
animal.eat();
}
public static void main(String[] args) {
Dog dog = new Dog("小白", 3);
Animal animal = dog;//animal这个引用指向了Dog对象
Cat cat = new Cat("汤姆", 5);
if (animal instanceof Cat) {
cat = (Cat) animal;
cat.mew();
}
if (animal instanceof Dog) {
dog = (Dog) animal;
dog.bark();
}
}
}
运行结果:
文章来源:https://www.toymoban.com/news/detail-847715.html
五、总结
多态是面向对象的一个关键概念,它允许对象以不同的方式表现,具体取决于它们的类型。在 Java中,多态通过继承和方法重写来实现,让我们能够编写灵活、可扩展且可维护的代码。我们这期多态的内容就分享到这里,希望能够对大家有所帮助,感谢各位对蜡笔小欣的鼓励支持,我们下次再见!!!文章来源地址https://www.toymoban.com/news/detail-847715.html
到了这里,关于JavaSE:继承和多态(下篇)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!