1.Java中的多态
Java的三大特性:封装,继承,多态
多态的定义:多种形态,是面向对象的三大特征,多态的基础是继承和封装
1.1方法的多态
在方法中,方法的重写和重载其实就是一种方法的多态
class Person {
public void eat () { //方法的重载
System.out.println("吃饭");
}
public void eat (String food) {
System.out.println("吃" + food);
}
}
class Man extends Person {
@Override
public void eat() { //方法的重写
System.out.println("吃枸杞");
}
@Override
public void eat(String food) {
System.out.println("吃"+ food);
}
}
1.2对象的多态
多态就是:父类的引用指向子类的对象
通俗的说:多态就是不同对象对同一物体或事件发出不同的反应或响应。比如stuendt是一个父类,那么在操场上上体育课的学生和在教室里面的学生就是它的子类。这时上课铃声响了,上体育课的学生去操场,在教室里面上课的学生则是回教室,不同的学生有着不同的反应,这就是多态。
Animal animal = new Dog();
Animal anima1 = new Cat();
实现多态的条件:
1.继承:子类继承父类。
2.重写:子类需要对父类中的一些方法进行重写
3.向上转型:在多态中需要将子类的引用赋给父类的对象,只有这样才能调用父类的方法和子类的方法
案例:
class Person {
public void feed (Animal animal) { //创建一个方法无返回值,参数为animal对象
animal.eat();
}
}
interface Animal { //定义的Animal接口
public void eat ();
}
class Dog implements Animal{
@Override //重写eat方法
public void eat () {
System.out.println("狗在吃骨头......");
}
}
class Cat implements Animal{
@Override //重写eat方法
public void eat () {
System.out.println("猫吃鱼......");
}
}
public class Demo1 {
public static void main(String[] args) {
Person person = new Person();
Animal animal = new Cat(); //多态 父类的引用指向子类对象
person.feed(animal);
Animal animal1 = new Dog(); //多态 父类的引用指向子类对象
person.feed(animal1);
}
}
编写程序实现比萨制作。需求说明编写程序,可供选择的比萨有:培根比萨和海鲜比萨。
实现思路及关键代码
1) 分析培根比萨和海鲜比萨
2) 定义比萨类
3) 属性:名称、价格、大小
4) 方法:展示
5) 定义培根比萨和海鲜比萨继承自比萨类
6) 定义比萨工厂类,根据输入信息产生具体的比萨对象
PizzaFactory {
createPizza(Pizza);//如果传的参数培根披萨就是生产培根披萨 如果传的是海鲜披萨就是生产的海鲜披萨
}
案例:
package com.qfedu.class1;
class Pizza {
private String name;
private double price;
private int size;
public void show() {
System.out.println(name+":"+price+":"+size);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
}
class Hpizza extends Pizza {
@Override
public void show() {
System.out.println(this.getName()+":"+this.getPrice()+":"+this.getSize());
}
}
class Ppizza extends Pizza {
@Override
public void show() {
System.out.println(this.getName()+":"+this.getPrice()+":"+this.getSize());
}
}
class PizzaFactory {
public void createPizza(Pizza pizza) {
pizza.show();
}
}
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Pizza pizza1 = new Hpizza();
pizza1.setName("海鲜披萨");
pizza1.setPrice(36.2);
pizza1.setSize(14);
PizzaFactory pizzaFactory = new PizzaFactory();
pizzaFactory.createPizza(pizza1);
Pizza pizza2 = new Ppizza();
pizza2.setName("培根披萨");
pizza2.setPrice(35.1);
pizza2.setSize(12);
pizzaFactory.createPizza(pizza2);
}
}
1.3多态的转型
多态的向上转型:
就是父类的引用指向子类的对象
语法格式:
父类 父类的引用 = new 子类();
将子类的对象赋值给了父类的引用。小范围(子类) 转为大范围(父类)自动转
父类的引用可以调用父类的所有成员方法,可以调用子类的重写父类的方法,但是不能调用子类独有的方法。
案例:
class Person {
public void eat () { //定义了一个没有具体操作的方法
}
}
class Student extends Person { //学生类去继承Person类
@Override
public void eat() { //重写父类的方法
System.out.println("学生要吃饭");
}
public void sleep () { //子类自己的方法
System.out.println("中午不谁下午崩溃!!!");
}
}
public class Demo1 {
public static void main(String[] args) {
Person person = new Student();//向上转型 ,多态的体现
person.eat();
//person.sleep();
}
}
多态向下转型:
语法格式:
父类类型 父类的引用 = new 子类();
子类类型 子类的引用 = (子类类型)父类的引用; //向下转型
案例:
class TestA {
//Object 是所有类的父类
public void test (Object obj ) {
//传入一个String类型的数据 就相当于 Object obj = new TestA("狗蛋");
//先进行向上转型 , 在进行向下转型
// String str = (String) obj;
// System.out.println(str);
//传入一个Int类型的数据 就相当于 Object obj = new TestA(98);
int i1 = (int)obj;
System.out.println(i1);
}
}
public class Demo4 {
public static void main(String[] args) {
TestA testA = new TestA();
testA.test(98);
}
}
1.4instanceof 关键字
比较操作符,返回值是布尔类型的数据
语法格式:
对象的引用 instanceof 运行类型
用来判断对象的运行类型,是否是谁的子类,是为了在强转的时候不出现问题
案例:
class Employee {}
class Monkey {
//这个方法的返回值是一个字符串
public String xixi(Object obj) {
// Object obj 相当于 Object obj = new String("狗蛋");
//obj instanceof String
if (obj instanceof String) { //判断是否 是平级 或者是子类 返回值为true 或 false
String string = (String)obj; //向下转型
return "传给我的 参数是字符串类型的数据";
} else if (obj instanceof Integer) {
Integer i1 = (Integer)obj;
return "传给我的 参数是int类型的数据";
} else if (obj instanceof Employee) {
Employee employee = (Employee)obj;
return "传给我的参数是一个Employee对象";
}
else {
return "参数不合法";
}
}
}
public class Demo3 {
public static void main(String[] args) {
Monkey monkey = new Monkey();
//System.out.println(monkey.xixi("狗蛋"));
//System.out.println(monkey.xixi(89));
Employee employee = new Employee();
System.out.println(monkey.xixi(employee));
String string = new String();
}
}
多态的优点
1.可替换性,多态对已存在代码具有可替换性。
2.可扩充性,多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。
3.接口性,多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
4.灵活性,它在应用中体现了灵活多样的操作,提高了使用效率。
5.简化性,多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。