河南河南省住房和城乡建设厅网站,北京的p2p网站建设,网站建设 宜宾,徐州企业免费建站作者主页#xff1a;paper jie_的博客 本文作者#xff1a;大家好#xff0c;我是paper jie#xff0c;感谢你阅读本文#xff0c;欢迎一建三连哦。 本文录入于《JAVASE语法系列》专栏#xff0c;本专栏是针对于大学生#xff0c;编程小白精心打造的。笔者用重金(时间和… 作者主页paper jie_的博客 本文作者大家好我是paper jie感谢你阅读本文欢迎一建三连哦。 本文录入于《JAVASE语法系列》专栏本专栏是针对于大学生编程小白精心打造的。笔者用重金(时间和精力)打造将javaSE基础知识一网打尽希望可以帮到读者们哦。 其他专栏《JAVA》《算法详解》《C语言》等 内容分享本期将会对JAVA中的多态进行讲解 目录 多态的概念
多态的实现条件
重写
方法重写的规则
重写和重载的区别
重写的设计理念由来
向上转型和向下转型
向上转型
向下转型
多态的优缺点
使用多态的优点
多态的缺陷 多态的概念
简单的讲多态就是多种形态具体点就是去完成某个行为当不同的对象去完成时会产生出不同的形态。总的来说同一件事发生在不同的对象中产生的结果是不同的。 多态的实现条件
在java中要实现多态需要满足几个条件
1 必须要在继承的基础上发生向上转型
2 子类必须对父类中的方法重写
3 通过父类的引用调用重写的方法 多态的体现就在代码运行时当传递不同类的对象时会调用对应类的重写方法。
class Animal {String name;int age;public Animal(String name, int age){this.name name;this.age age;}public void eat(){System.out.println(name 吃饭);}
}
class Cat extends Animal{public Cat(String name, int age){super(name, age);} Overridepublic void eat(){System.out.println(name吃鱼~~~);}
}
class Dog extends Animal {public Dog(String name, int age){super(name, age);} Overridepublic void eat(){System.out.println(name吃骨头~~~);}
} /
//分割线//
class TestAnimal {
// 编译器在编译代码时并不知道要调用Dog 还是 Cat 中eat的方法
// 等程序运行起来后形参a引用的具体对象确定后才知道调用那个方法
// 注意此处的形参类型必须时父类类型才可以public static void eat(Animal a){a.eat();}public static void main(String[] args) {Cat cat new Cat(元宝,2);Dog dog new Dog(小七, 1);eat(cat);eat(dog);}
}
在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的. 当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态
重写
重写也叫做覆盖。重写是子类对父类非静态非private修饰非final修饰非构造方法等的实现过程进行重写的编写返回值和形参都不能变。重写的好处在于子类可以根据需要定义特定于自己的行为。也就是子类能够根据需要实现父类的方法。 方法重写的规则
子类在重写父类的方法时必须与父类方法原形一致返回值类型 方法名参数列表
被重写的方法返回值类型可以不同但是必须是具有父子关系的叫做协变类型
访问权限不能比父类中被重写的方法的权限更低。
重写的方法可以使用Override 注解来指定这个可以帮助我们进行合法性的效验
object类是所有类的父类里面的方法都可以重写 重写和重载的区别
方法重载是一个类的多态性的表现
方法重写是子类和父类的一种多态性的表现 重写的设计理念由来
对于已经投入使用的类就尽量不要进行修改。最好的方式是重新定义一个新的类来重复利用其中的共性并且添加或者改动新的内容。
例如若干年前的手机只能打电话发短信来电显示只能显示号码而今天的手机在来电显示的时候不仅仅可以显示号码还可以显示头像地区等。在这个过程当中我们不应该在原来老的类上进行修改因为原来的类可能还在有用户使用正确做法是新建一个新手机的类对来电显示这个方法重写就好了这样就达到了我们当今的需求了。 向上转型和向下转型
向上转型
向上转型就是创建一个子类对象当做父类对象来使用。
使用形式父类类型 对象名 new 子类对象类型
栗子
animal是父类类型但是可以引用子类对象它是从小范围转换为大范围。
Animal animal new Dog(耀阳);
它有三种使用方法 1直接赋值2方法传参3方法返回 class TestAnimal {// 2. 方法传参形参为父类型引用可以接收任意子类的对象public static void eatFood(Animal a){a.eat();} // 3. 作返回值返回任意子类对象public static Animal buyAnimal(String var){if(狗.equals(var) ){return new Dog(狗狗,1);}else if(猫 .equals(var)){return new Cat(猫猫, 1);}else{return null;}}public static void main(String[] args) {Animal cat new Cat(元宝,2); // 1. 直接赋值子类对象赋值给父类对象Dog dog new Dog(小七, 1);eatFood(cat);eatFood(dog);Animal animal buyAnimal(狗);animal.eat();animal buyAnimal(猫);animal.eat();}
}
向上转型就是可以让代码变的更加的简单灵活但是它有一个缺陷就是不能调用到子类自己特有的方法。
向下转型
将一个子类对象经过向上转型之后当成父类方法使用再无法调用子类的方法但有时候可能需要调用子类特有的方法此时将父类引用再还原为子类对象即可即向下转换。 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();
// 编译失败编译时编译器将animal当成Animal对象处理
// 而Animal类中没有bark方法因此编译失败
// animal.bark();
// 向上转型
// 程序可以通过编程但运行时抛出异常---因为animal实际指向的是狗
// 现在要强制还原为猫无法正常还原运行时抛出ClassCastExceptioncat (Cat)animal;cat.mew();
// animal本来指向的就是狗因此将animal还原为狗也是安全的dog (Dog)animal;dog.bark();}
}
因为向下转型不安全java为了提高向下转型的安全性引入了instanceof它的作用就是如果该表达式为true则可以安全转换。
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();}}
}
多态的优缺点
使用多态的优点
可以降低代码的圈复杂度避免大量的if else
什么叫 圈复杂度 ? 圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂. 因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 圈复杂度. 如果一个方法的圈复杂度太高, 就需要考虑重构.不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10
栗子
这里有一段代码
class Shape {//属性....public void draw() {System.out.println(画图形);}
}
class Rect extends Shape{Overridepublic void draw() {System.out.println(♦);}
}
class Cycle extends Shape{Overridepublic void draw() {System.out.println(●);}
}
class Flower extends Shape{Overridepublic void draw() {System.out.println(❀);}
}
现在我们需要打印的不是一个图形而是一堆图形不用多态的话实现的代码
public static void drawShapes() {
Rect rect new Rect();
Cycle cycle new Cycle();
Flower flower new Flower();
String[] shapes {cycle, rect, cycle, rect, flower};
for (String shape : shapes) {
if (shape.equals(cycle)) {
cycle.draw();
} else if (shape.equals(rect)) {
rect.draw();
} else if (shape.equals(flower)) {
flower.draw();
}
}
}
如果使用多态则不用使用这么过if else语句代码更简洁
public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.Shape[] shapes {new Cycle(), new Rect(), new Cycle(),new Rect(), new Flower()};for (Shape shape : shapes) {shape.draw();}}
可扩展能力强
如果要新增一种图形使用多态的方式代码改动成本也比较低。
class Triangle extends Shape {
Override
public void draw() {
System.out.println(△);}
}
对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低. 而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高
多态的缺陷
1. 属性没有多态性
当父类和子类都用同名的属性的时候通过父类的引用只能调用父类的成员属性
2. 构造方法没有多态性
避免在构造方法中调用重写的方法
代码如下
class B {public B() {
// do nothingfunc();}public void func() {System.out.println(B.func());}
}
class D extends B {private int num 1;Overridepublic void func() {System.out.println(D.func() num);}
}
public class Test {public static void main(String[] args) {D d new D();}
} 构造 D 对象的同时, 会调用 B 的构造方法. B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0. 如果具备多态性num的值应该是1.所以在构造函数内尽量避免使用实例方法除了final和private方法。结论: 用尽量简单的方式使对象进入可工作状态, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.
