多态是继封装, 继承之后, 面向对象的第三大特性.
现实事物经常会体现出多种形态, 如学生, 学生是人的一种, 则一个具体的同学张三既是学生也是人, 即出现两种形态.
Java 作为面向对象的语言, 同样可以描述一个事物的多种形态. 如 Student 类继承了 Person 类, 一个 Student 的对象便既是 Student, 又是 Person.
Java 中多态的代码体现在一个子类对象 (实现类对象) 既可以给这个子类 (实现类对象) 引用变量赋值, 又可以给这个子类 (实现类对象) 的父类 (接口) 变量赋值.
如 Student 类可以为 Person 类的子类. 那么一个 Student 对象既可以赋值给一个 Student 类型的引用, 也可以赋值给一个 Person 类型的引用.
最终多态体现为父类引用变量可以指向子类对象.
多态的前提是必须有子父类关系或者类实现接口关系, 否则无法完成多态.
在使用多态后的父类引用变量调用方法时, 会调用子类重写后的方法.
文字再怎么讲, 都不够生动, 直接用代码来体现
老爸要喝酒, 那今天喝什么酒呢,
- public class Wine {
- public void drinkWine(){
- System.out.println("=== 今天我要喝什么酒呢 ====");
- Wine();
- }
- public void Wine(){
- System.out.println("=== 看看俺今天能喝啥子哟 ====");
- }
- }
- public class JNC extends Wine {
- /**
- * @desc 子类重载父类方法
- * 父类中不存在该方法, 向上转型后, 父类是不能引用该方法的
- * @param a
- * @return void
- */
- public void drinkWine(String a){
- System.out.println("====== 今天我要喝剑南春 ====");
- Wine();
- }
- /**
- * 子类重写父类方法
- * 指向子类的父类引用调用 Wine 时, 必定是调用该方法
- */
- public void Wine(){
- System.out.println("===== 剑南春喝上啦, 好开森 =====");
- }
- }
- public class Test {
- public static void main(String[] args) {
- Wine a = new JNC();
- a.drinkWine();
- a.Wine();
- Wine b = new Wine();
- b.drinkWine();
- b.Wine();
- JNC c= new JNC();
- c.drinkWine("qq");
- }
- }
先来看看这一段,
- Wine a = new JNC();
- a.drinkWine();
- a.Wine();
子类剑南春中的 drinkWine 带有参数, 而父类中的 drinkWine 不带有参数, 即父类不存在这个方法
运行的时候, 调用的是父类的 drinkWine, 先输出了
=== 今天我要喝什么酒呢 ====
之后继续调用 Wine 方法, 这个时候是去了子类中, 指向子类的父类引用调用 Wine 时, 必定是调用子类中的方法, 于是输出了
===== 剑南春喝上啦, 好开森 =====
上面的 Wine 和 JNC 中的方法, 都没有带 Static, 如果加上 Static 呢, 看一下代码和运行的结果
- class Wine {
- public static void drinkWine() {
- System.out.println("=== 今天我要喝什么酒呢 ====");
- Wine();
- }
- public static void Wine() {
- System.out.println("=== 看看俺今天能喝啥子哟 ====");
- }
- }
- class JNC extends Wine {
- public static void drinkWine(String a) {
- System.out.println("====== 今天我要喝剑南春 ====");
- Wine();
- }
- public static void Wine() {
- System.out.println("===== 剑南春喝上啦, 好开森 =====");
- }
- }
- class Test {
- public static void main(String[] args) {
- Wine a = new JNC();
- a.drinkWine();
- a.Wine();
- }
- }
可以看到, 静态方法, 即使向上转型, 也只能调用自己的方法啦
上面比较的是子类和父类的方法, 在非静态方法和静态方法, 父类引用子类的方法, 非静态方法下可以调用子类同名的构造函数方法, 不能调用不一样的构造方法
静态方法中, 子类向上转型后, 父类引用都不能进行调用子类的方法
下面来给父类和子类一些变量, 以及一些方法, 方法都是非静态的
父类, 定义了一些姓名, 年龄, 兴趣爱好等的变量
和一些 say 和 hobby 的方法
- public class Father {
- private String fathername;
- private int fatherage;
- private String fahterhobby;
- public void say() {
- System.out.println("== 我是你爸爸真伟大, 养你这么大 ==");
- myhobby();
- }
- public void myhobby() {
- System.out.println("== 我是你爸爸真伟大, 只要你妈妈 ==");
- }
- public Father() {
- super();
- }
- public Father(String fathername, int fatherage, String fahterhobby) {
- this.fathername = fathername;
- this.fatherage = fatherage;
- this.fahterhobby = fahterhobby;
- }
- // 省略 getters and setters
- @Override
- public String toString() {
- return "Father{" +
- "fathername='" + fathername + '\'' +
- ", fatherage=" + fatherage +
- ", fahterhobby='" + fahterhobby + '\'' +
- '}';
- }
- public String toString(String fathername, int fatherage, String fahterhobby) {
- return "Father{" +
- "fathername='" + fathername + '\'' +
- ", fatherage=" + fatherage +
- ", fahterhobby='" + fahterhobby + '\'' +
- '}';
- }
- }
子类和父类差不多, 其实不应该定义一样的变量, 虽然名称改了一下
- public class Son extends Father {
- public void say(){
- System.out.println("== 爸爸我要出去玩 ===");
- }
- public void say(String s){
- System.out.println("== 爸爸我要出去玩 ===" +s);
- }
- public void myhobby(String aaa){
- System.out.println("== 爸爸给我买这个玩具:" + aaa);
- }
- private String sonname;
- private int sonage;
- private String sonhobby;
- public Son(String sonname, int sonage, String sonhobby) {
- this.sonname = sonname;
- this.sonage = sonage;
- this.sonhobby = sonhobby;
- }
- public Son(String fathername, int fatherage, String fahterhobby, String sonname, int sonage, String sonhobby) {
- super(fathername, fatherage, fahterhobby);
- this.sonname = sonname;
- this.sonage = sonage;
- this.sonhobby = sonhobby;
- }
- // 省略 getters and setters
- @Override
- public String toString(String sonname, int sonage, String sonhobby) {
- return "Son{" +
- "sonname='" + sonname + '\'' +
- ", sonage=" + sonage +
- ", sonhobby='" + sonhobby + '\'' +
- '}';
- }
- }
测试:
主要测试如下:
子类中, 对 say()无参数的方法进行了改写, 输出内容不一致了, 且有自己新创建的 say(String s)带有入参的方法
子类对 myhobby 也新增了, 有了入参
子类中对 toString 方法也带有入参的
实例化子类对象, 父类引用, 即向上转型了, 调用 say(), 这个方法子类中有; 调用 myhobby(), 子类中没有 myhobby(), 只有 myhobby(String aaa) 然后还要调用 toString(), 有参数和无参数的
- public class test {
- public static void main(String[] args) {
- Father father = new Son("张三",35,"LOL","张四",5,"Learn");
- System.out.println("实例化一个 Son 对象, 用父亲接收");
- father.say();
- father.myhobby();
- // 代码报错
- // father.myhobby("LOL 惊奇娃娃");
- System.out.println(father.toString());
- System.out.println(father.toString("张三",35,"LOL"));
- System.out.println("\n");
- Son son = new Son("张四",5,"Learn");
- System.out.println("实例化一个 Son 对象, 用 Son 接收");
- son.say();
- son.say("上海迪士尼");
- son.myhobby();
- son.myhobby("LOL 惊奇娃娃");
- System.out.println(son.toString("张四",5,"Learn"));
- }
- }
运行结果如下:
1. 父类引用调用 say(), 由于子类中有这个方法, 调用的是子类的这个方法;
调用 myhobby();, 由于子类中没有这个方法, 调用的是父类的这个方法;
调用子类中带有参数的方法, father.myhobby("LOL 惊奇娃娃"); 代码直接报错了
调用 toString(), 分别是无参数和有参数, 因为子类中只有三个有参数的, 没有无参数的, 就无参数返回的是父类的, 有参数返回的是子类的
2. 子类引用指向子类对象, 调用 say()无参数的和有参数的, 由于子类中都有, 都是子类自己的方法进行返回
调用 myobby()无参数的和有参数的, 由于子类中没有无参数的, 就去爸爸那儿找了找, 返回了爸爸的爱好, 子类中有带参数的, 就返回了子类自己的
调用 toString(3 个参数略), 就返回了自己的方法, 如果调用不带参数的 toString(), 就是返回一个父亲中的方法了...
总结: 父类引用指向子类, 调用返回的时候, 看看自己家有没有啊, 有啊, 哦, 不管了, 先去儿子家找找, 儿子有啊, 儿子用你家的, 儿子没有啊, 回家用自己的方法吧
子类引用指向子类, 调用返回的时候, 先去自己 (即儿子) 方法中看看, 我自己没有呀, 去父亲方法中看看吧
上面看的继承中的父子关系是, 爸爸有, 儿子有, 儿子有新的
下面继续看继承, 论父子之间的关系之, 爸爸没有, 儿子有;
员工对象, 只有一个 mailCheck()方法, 定义了一些变量
- public class Employee {
- private String name;
- private String address;
- private int number;
- public Employee(String name, String address, int number) {
- //System.out.println("Employee 构造函数");
- this.name = name;
- this.address = address;
- this.number = number;
- }
- public void mailCheck() {
- System.out.println("邮寄支票给:" + this.name + " " + this.address);
- }
- @Override
- public String toString() {
- return "Employee{" +
- "name='" + name + '\'' +
- ", address='" + address + '\'' +
- ", number=" + number +
- '}';
- }
- // 省略 getters and setters
Salary 对象继承了父类
- public class Salary extends Employee{
- private double yearsalary; // 全年工资
- public double getSalary() {
- return yearsalary;
- }
- public void setSalary(double salary) {
- if(salary>= 0.0)
- this.yearsalary = salary;
- }
- public double computePay() {
- System.out.println("计算工资, 付给:" + getName());
- return yearsalary/12;
- }
- public Salary(String name, String address, int number, double yearsalary) {
- super(name, address, number);
- setSalary(yearsalary);
- }
- public void mailCheck() {
- System.out.println("Salary 类的 mailCheck 方法");
- System.out.println("邮寄支票给:" + getName()+ ", 工资为:" + yearsalary);
- }
- }
测试如下
- public class Demo {
- public static void main(String [] args) {
- Salary s = new Salary("员工 A", "北京", 3, 360000.00);
- s.mailCheck();
- double sa = s.computePay();
- System.out.println(sa);
- System.out.println("\n");
- Employee e = new Salary("员工 B", "上海", 2, 240000.00);
- e.mailCheck();
- double salary = ((Salary) e).computePay();
- System.out.println(salary);
- }
- }
必要要强转 ((Salary) e).computePay(); 即必须向下转型, 父亲引用转化为子类的, 再去调用子类的方法
即回答: 论父子之间的关系之, 爸爸没有, 儿子有;
本来是爸爸类型的引用, 将爸爸类型的引用向下转型, 然后调用
问题来啦, 我是父亲, 我有两个儿子或者多个儿子呢, 闹啥啊, 爸爸没有这个方法, 儿子们都有呢, 咋办咧
- public class Animal {
- void eat() {
- System.out.println("Animal");
- }
- }
- public class Cat extends Animal {
- public void eat() {
- System.out.println("=== 我是猫咪我要吃鱼");
- }
- public void work() {
- System.out.println("=== 我是猫咪我负责抓老鼠");
- }
- }
- public class Dog extends Animal {
- public void eat() {
- System.out.println("==== 我是小狗我要吃骨头");
- }
- public void work() {
- System.out.println("==== 我是小狗我负责看家");
- }
- }
- public class Test {
- public static void main(String[] args) {
- show(new Cat()); // 以 Cat 对象调用 show 方法
- System.out.println("\n");
- show(new Dog()); // 以 Dog 对象调用 show 方法
- System.out.println("\n");
- Animal a = new Cat(); // 向上转型
- a.eat(); // 调用的是 Cat 的 eat
- Cat c = (Cat)a; // 向下转型
- c.work(); // 调用的是 Cat 的 work
- }
- public static void show(Animal animal) {
- animal.eat();
- // 类型判断
- if (animal instanceof Cat) { // 猫做的事情
- Cat c = (Cat)animal;
- c.work();
- } else if (animal instanceof Dog) { // 狗做的事情
- Dog c = (Dog)animal;
- c.work();
- }
- }
- }
不如咱直接将动物类改成抽象类吧,
- public abstract class Animal {
- abstract void eat() ;
- }
- public class Cat extends Animal {
- public void eat() {
- System.out.println("=== 我是猫咪我要吃鱼");
- }
- public void work() {
- System.out.println("=== 我是猫咪我负责抓老鼠");
- }
- }
- public class Dog extends Animal {
- public void eat() {
- System.out.println("==== 我是小狗我要吃骨头");
- }
- public void work() {
- System.out.println("==== 我是小狗我负责看家");
- }
- }
欢迎继续关注下一篇, 在接口实现中的实现多态
来源: https://www.cnblogs.com/qianjinyan/p/10824576.html