00007面向对象的基本特征之三 多态

一、面向对象的基本特征：

1、封装
和权限修饰符有关
2、继承
extends
3、多态
你们怎去理解多态的呢？

二、多态

多态：多种形态
变量的引用形式：
（1）本态引用：左边的变量与右边的对象是同一种类型
（2）多态引用：左边的变量是父类类型，右边的对象是子类的对象
多态的表现出来的特征：编译类型与运行时类型不一致
编译的时候，按照父类的类型进行编译的
执行的方法，按照子类进行运行，是“执行子类重写的方法”
编译看左边，运行看右边

/** 一、面向对象的基本特征：* 1、封装* 	和权限修饰符有关	* 2、继承* 	extends* 3、多态* 	* 二、多态* 多态：多种形态* * 变量的引用形式：* （1）本态引用：左边的变量与右边的对象是同一种类型* （2）多态引用：左边的变量是父类类型，右边的对象是子类的对象* * 多态的表现出来的特征：编译类型与运行时类型不一致* 	编译的时候，按照父类的类型进行编译的* 	执行的方法，按照子类进行运行，是“执行子类重写的方法”* 	* 	编译看左边，运行看右边* * 前提：（1）继承（2）重写（3）多态引用* 用途：方法的动态绑定* 强调：多态和属性无关，只说方法* * 网上也有人这么说，把重载也归为多态，我们不这么认为* */
package .atguigu.test02.polymorphism;public class testPolymorphism {public static void main(String[] args) {//1、本态引用//Person p=new Person();//p.eat();//Woman w=new Woman();//w.eat();//2、多态引用(前提，必须存在继承、重写)Person p2=new Woman();p2.eat();Person p3=new Man();p3.eat();p2.walk();//p2.shop()//错的，因为子类里面没有重写}
}
class Person{String info="atguigu";public void eat(){System.out.println("吃饭");}public void walk(){System.out.println("走路");}
}
class Woman extends Person{String info="尚硅谷";public void eat(){System.out.println("细嚼慢咽的吃饭");}public void walk(){System.out.println("婀娜多姿走路");}public void shop(){System.out.println("买买买...");}
}
class Man extends Person{public void eat(){System.out.println("狼吞虎咽的吃饭");}public void walk(){System.out.println("大摇大摆的走路");}public void smoke(){System.out.println("吞云吐雾");}
}

三、下面我们来说说多态的好处

多态的好处：
使得程序员编写代码更灵活
多态的应用：

（1）多态数组：

数组的元素是父类的类型，实际存储的是子类的对象
用这样的数组，就可以统一管理，所有子类的对象
看实例代码

package .atguigu.test02.polymorphism;public class TestUser1 {public static void main(String[] args) {// 创建一个数组，可以存储各种图形的对象，包括圆对象，矩形对象，三角形对象...//本态数组Circle[]yuan=new Circle[3];//用这个数组存圆Rectangle[] jus=new Rectangle[3];//用这个数组存矩形Graphic[]all=new Graphic[3];//用这个数组存储各种各样的图像对象//左边的元素all[0]是Graphic类型，右边是子类圆对象all[0]=new Circle(1.2);//System.out.println(all[0].getArea());//左边的g2是任意图像对象，右边是矩形对象Graphic g2=new Rectangle(2,4);all[1]=g2;all[2]=new Circle(4.2);//遍历所有图形的面积for(int i=0;i<all.length;i++){//执行哪个getArea()方法，要看all[i]中存储的是哪个子类对象System.out.println("面积："+all[i].getArea());}}
}
//Graphic图形
class Graphic{public double getArea(){return 0.0;//这句话没有什么意义，只是为了保证语法}
}
class Circle extends Graphic{private double radius;public Circle(double radius) {this.radius = radius;}//重写public double getArea(){return 3.14 * radius * radius;}
}
class Rectangle extends Graphic{private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;}//重写public double getArea(){return length * width;}
}

执行结果如下

注意多态和泛型的区别

实现多态的前提：有继承，有方法的重写，

（2）多态参数：

形参是父类的类型，实参是子类的对象
下面看代码

/** 多态的应用：* （1）多态数组：* 		 数组的元素是父类的类型，实际存储的是子类的对象* （2）多态参数：* 		形参是父类的类型，实参是子类的对象*/
package .atguigu.test02.polymorphism;public class TestUse2 {//这个方法能够1检查所有的动物吃东西是否正常//没有多态的话，需要重载很多个
/*	   public static void check(Dog dog ){dog.eat();}public static void check(Cat cat ){cat.eat();}*/public static void check(Animal a){a.eat();}public static void main(String[] args) {//匿名对象check(new Dog());//隐含了形参Animal a =实参 new Dog()check(new Cat());//隐含了形参Animal a =实参 new Cat()//Dog d=new Dog();//check(d);//有名对象}
}
class  Animal{public void eat(){System.out.println("吃东西");}
}
class Dog extends Animal{public void eat(){System.out.println("啃骨头");}
}
class Cat extends Animal{public void eat(){System.out.println("吃鱼");}
}

练习题

/*
1、练习题
（1）声明Traffic，
public void drive()方法
（2）声明子类Car,Bicycle，甚至可以声明Car的各种子类，例如BMW,Benz类等
（3）在测试类的main中创建一个数组，有各种交通工具，遍历调用drive()方法*/package .atguigu.test02.polymorphism;public class Test练习1 {public static void main(String[] args) {Traffic []all=new Traffic[5];all[0]=new Car();all[1]=new Bicycle();all[2]=new Car();all[3]=new Bicycle();all[4]=new Car();for(int i=0;i<all.length;i++){all[i].drive();}}
}
class Traffic {public void drive(){System.out.println("交通工具");}
}
class Car extends Traffic{public void drive(){System.out.println("小汽车前进");}
}
class Bicycle extends Traffic{public void drive(){System.out.println("自行车蹬不动");}
}