文昌网站建设 myvodo,浦东网站建设箱海运,铁岭做网站公司信息,安徽圣力建设集团有限公司网站一千个读者眼中有一千个哈姆雷特。 目录 7.1 多态的形式和体现
7.1.1 对象的多态性
举例#xff1a;
7.1.2 多态的理解
7.1.3 举例
1、方法内局部变量的赋值体现多态
2、方法的形参声明体现多态
3、方法返回值类型体现多态
7.2 为什么需要多态性(polymorphism)#x… 一千个读者眼中有一千个哈姆雷特。 目录 7.1 多态的形式和体现
7.1.1 对象的多态性
举例
7.1.2 多态的理解
7.1.3 举例
1、方法内局部变量的赋值体现多态
2、方法的形参声明体现多态
3、方法返回值类型体现多态
7.2 为什么需要多态性(polymorphism)
案例
7.3 多态的好处和弊端
好处
弊端
开发中
7.4 虚方法调用(Virtual Method Invocation)
举例
拓展
7.5 成员变量没有多态性
7.6 向上转型与向下转型
7.6.1 为什么要类型转换
向上转型
向下转型
7.6.2 如何向上或向下转型
向上转型自动完成
向下转型子类类型父类变量
7.6.3 instanceof关键字
说明
代码
7.7 练习
练习1笔试面试
题目1继承成员变量和继承方法的区别
题目2
题目3
题目4多态是编译时行为还是运行时行为
练习2
练习3 7.1 多态的形式和体现
7.1.1 对象的多态性
多态性是面向对象中最重要的概念在Java中的体现对象的多态性父类的引用指向子类的对象
格式父类类型指子类继承的父类类型或者实现的接口类型
父类类型 变量名 子类对象举例
Person p new Student();Object o new Person();//Object类型的变量o指向Person类型的对象o new Student(); //Object类型的变量o指向Student类型的对象对象的多态在Java中子类的对象可以替代父类的对象使用。所以一个引用类型变量可能指向(引用)多种不同类型的对象
7.1.2 多态的理解
Java引用变量有两个类型编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定运行时类型由实际赋给该变量的对象决定。简称编译时看左边运行时看右边。
若编译时类型和运行时类型不一致就出现了对象的多态性(Polymorphism)多态情况下“看左边”看的是父类的引用父类中不具备子类特有的方法 “看右边”看的是子类的对象实际运行的是子类重写父类的方法
多态的使用前提① 类的继承关系 ② 方法的重写
7.1.3 举例
package com.atguigu.polymorphism.grammar;public class Pet {private String nickname; //昵称public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname nickname;}public void eat(){System.out.println(nickname 吃东西);}
}package com.atguigu.polymorphism.grammar;public class Cat extends Pet {//子类重写父类的方法Overridepublic void eat() {System.out.println(猫咪 getNickname() 吃鱼仔);}//子类扩展的方法public void catchMouse() {System.out.println(抓老鼠);}
}package com.atguigu.polymorphism.grammar;public class Dog extends Pet {//子类重写父类的方法Overridepublic void eat() {System.out.println(狗子 getNickname() 啃骨头);}//子类扩展的方法public void watchHouse() {System.out.println(看家);}
}1、方法内局部变量的赋值体现多态
package com.atguigu.polymorphism.grammar;public class TestPet {public static void main(String[] args) {//多态引用Pet pet new Dog();pet.setNickname(小白);//多态的表现形式/*编译时看父类只能调用父类声明的方法不能调用子类扩展的方法运行时看“子类”如果子类重写了方法一定是执行子类重写的方法体*/pet.eat();//运行时执行子类Dog重写的方法
// pet.watchHouse();//不能调用Dog子类扩展的方法pet new Cat();pet.setNickname(雪球);pet.eat();//运行时执行子类Cat重写的方法}
}2、方法的形参声明体现多态
package com.atguigu.polymorphism.grammar;public class Person{private Pet pet;public void adopt(Pet pet) {//形参是父类类型实参是子类对象this.pet pet;}public void feed(){pet.eat();//pet实际引用的对象类型不同执行的eat方法也不同}
}package com.atguigu.polymorphism.grammar;public class TestPerson {public static void main(String[] args) {Person person new Person();Dog dog new Dog();dog.setNickname(小白);person.adopt(dog);//实参是dog子类对象形参是父类Pet类型person.feed();Cat cat new Cat();cat.setNickname(雪球);person.adopt(cat);//实参是cat子类对象形参是父类Pet类型person.feed();}
}3、方法返回值类型体现多态
package com.atguigu.polymorphism.grammar;public class PetShop {//返回值类型是父类类型实际返回的是子类对象public Pet sale(String type){switch (type){case Dog:return new Dog();case Cat:return new Cat();}return null;}
}package com.atguigu.polymorphism.grammar;public class TestPetShop {public static void main(String[] args) {PetShop shop new PetShop();Pet dog shop.sale(Dog);dog.setNickname(小白);dog.eat();Pet cat shop.sale(Cat);cat.setNickname(雪球);cat.eat();}
}7.2 为什么需要多态性(polymorphism)
开发中有时我们在设计一个数组、或一个成员变量、或一个方法的形参、返回值类型时无法确定它具体的类型只能确定它是某个系列的类型。
案例
1声明一个Dog类包含public void eat()方法输出“狗啃骨头”
2声明一个Cat类包含public void eat()方法输出“猫吃鱼仔”
3声明一个Person类功能如下
包含宠物属性包含领养宠物方法 public void adopt(宠物类型Pet)包含喂宠物吃东西的方法 public void feed()实现为调用宠物对象.eat()方法
public class Dog {public void eat(){System.out.println(狗啃骨头);}
}public class Cat {public void eat(){System.out.println(猫吃鱼仔);}
}public class Person {private Dog dog;//adopt领养public void adopt(Dog dog){this.dog dog;}//feed喂食public void feed(){if(dog ! null){dog.eat();}}/*问题1、从养狗切换到养猫怎么办 修改代码把Dog修改为养猫2、或者有的人养狗有的人养猫怎么办 3、要是还有更多其他宠物类型怎么办如果Java不支持多态那么上面的问题将会非常麻烦代码维护起来很难扩展性很差。*/
}7.3 多态的好处和弊端
好处
变量引用的子类对象不同执行的方法就不同实现动态绑定。代码编写更灵活、功能更强大可维护性和扩展性更好了。
弊端
一个引用类型变量如果声明为父类的类型但实际引用的是子类对象那么该变量就不能再访问子类中添加的属性和方法。
Student m new Student();
m.school pku; //合法,Student类有school成员变量
Person e new Student();
e.school pku; //非法,Person类没有school成员变量// 属性是在编译时确定的编译时e为Person类型没有school成员变量因而编译错误。开发中 使用父类做方法的形参是多态使用最多的场合。即使增加了新的子类方法也无需改变提高了扩展性符合开闭原则。 【开闭原则OCP】 对扩展开放对修改关闭通俗解释软件系统中的各种组件如模块Modules、类Classes以及功能Functions等应该在不修改现有代码的基础上引入新功能7.4 虚方法调用(Virtual Method Invocation)
在Java中虚方法是指在编译阶段不能确定方法的调用入口地址在运行阶段才能确定的方法即可能被重写的方法。
Person e new Student();
e.getInfo(); //调用Student类的getInfo()方法子类中定义了与父类同名同参数的方法在多态情况下将此时父类的方法称为虚方法父类根据赋给它的不同子类对象动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
举例 前提Person类中定义了welcome()方法各个子类重写了welcome()。 执行多态的情况下调用对象的welcome()方法实际执行的是子类重写的方法。 拓展 静态链接或早起绑定当一个字节码文件被装载进JVM内部时如果被调用的目标方法在编译期可知且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。那么调用这样的方法就称为非虚方法调用。比如调用静态方法、私有方法、final方法、父类构造器、本类重载构造器等。 动态链接或晚期绑定如果被调用的方法在编译期无法被确定下来也就是说只能够在程序运行期将调用方法的符号引用转换为直接引用由于这种引用转换过程具备动态性因此也就被称之为动态链接。调用这样的方法就称为虚方法调用。比如调用重写的方法针对父类、实现的方法针对接口。 7.5 成员变量没有多态性 若子类重写了父类方法就意味着子类里定义的方法彻底覆盖了父类里的同名方法系统将不可能把父类里的方法转移到子类中。 对于实例变量则不存在这样的现象即使子类里定义了与父类完全相同的实例变量这个实例变量依然不可能覆盖父类中定义的实例变量
package com.atguigu.polymorphism.grammar;public class TestVariable {public static void main(String[] args) {Base b new Sub();System.out.println(b.a);System.out.println(((Sub)b).a);Sub s new Sub();System.out.println(s.a);System.out.println(((Base)s).a);}
}
class Base{int a 1;
}
class Sub extends Base{int a 2;
}7.6 向上转型与向下转型
首先一个对象在new的时候创建是哪个类型的对象它从头至尾都不会变。即这个对象的运行时类型本质的类型用于不会变。但是把这个对象赋值给不同类型的变量时这些变量的编译时类型却不同。
7.6.1 为什么要类型转换
因为多态就一定会有把子类对象赋值给父类变量的时候这个时候在编译期间就会出现类型转换的现象。
但是使用父类变量接收了子类对象之后我们就不能调用子类拥有而父类没有的方法了。这也是多态给我们带来的一点小麻烦。所以想要调用子类特有的方法必须做类型转换使得编译通过。 向上转型 当左边的变量的类型父类 右边对象/变量的类型子类我们就称为向上转型 此时编译时按照左边变量的类型处理就只能调用父类中有的变量和方法不能调用子类特有的变量和方法了但是运行时仍然是对象本身的类型所以执行的方法是子类重写的方法体。此时一定是安全的而且也是自动完成的 向下转型 当左边的变量的类型子类右边对象/变量的编译时类型父类我们就称为向下转型 此时编译时按照左边变量的类型处理就可以调用子类特有的变量和方法了但是运行时仍然是对象本身的类型不是所有通过编译的向下转型都是正确的可能会发生ClassCastException为了安全可以通过isInstanceof关键字进行判断
7.6.2 如何向上或向下转型
向上转型自动完成
向下转型子类类型父类变量
package com.atguigu.polymorphism.grammar;public class ClassCastTest {public static void main(String[] args) {//没有类型转换Dog dog new Dog();//dog的编译时类型和运行时类型都是Dog//向上转型Pet pet new Dog();//pet的编译时类型是Pet运行时类型是Dogpet.setNickname(小白);pet.eat();//可以调用父类Pet有声明的方法eat但执行的是子类重写的eat方法体
// pet.watchHouse();//不能调用父类没有的方法watchHouseDog d (Dog) pet;System.out.println(d.nickname d.getNickname());d.eat();//可以调用eat方法d.watchHouse();//可以调用子类扩展的方法watchHouseCat c (Cat) pet;//编译通过因为从语法检查来说pet的编译时类型是PetCat是Pet的子类所以向下转型语法正确//这句代码运行报错ClassCastException因为pet变量的运行时类型是DogDog和Cat之间是没有继承关系的}
}7.6.3 instanceof关键字
为了避免ClassCastException的发生Java提供了 instanceof 关键字给引用变量做类型的校验。如下代码格式
//检验对象a是否是数据类型A的对象返回值为boolean型
对象a instanceof 数据类型A 说明 只要用instanceof判断返回true的那么强转为该类型就一定是安全的不会报ClassCastException异常。如果对象a属于类A的子类Ba instanceof A值也为true。要求对象a所属的类与类A必须是子类和父类的关系否则编译错误。
代码
package com.atguigu.polymorphism.grammar;public class TestInstanceof {public static void main(String[] args) {Pet[] pets new Pet[2];pets[0] new Dog();//多态引用pets[0].setNickname(小白);pets[1] new Cat();//多态引用pets[1].setNickname(雪球);for (int i 0; i pets.length; i) {pets[i].eat();if(pets[i] instanceof Dog){Dog dog (Dog) pets[i];dog.watchHouse();}else if(pets[i] instanceof Cat){Cat cat (Cat) pets[i];cat.catchMouse();}}}
}7.7 练习
练习1笔试面试
题目1继承成员变量和继承方法的区别
class Base {int count 10;public void display() {System.out.println(this.count);}
}class Sub extends Base {int count 20;public void display() {System.out.println(this.count);}
}public class FieldMethodTest {public static void main(String[] args){Sub s new Sub();System.out.println(s.count);s.display();Base b s;System.out.println(b s);System.out.println(b.count);b.display();}
}
题目2
//考查多态的笔试题目
public class InterviewTest1 {public static void main(String[] args) {Base base new Sub();base.add(1, 2, 3);// Sub s (Sub)base;
// s.add(1,2,3);}
}class Base {public void add(int a, int... arr) {System.out.println(base);}
}class Sub extends Base {public void add(int a, int[] arr) {System.out.println(sub_1);}// public void add(int a, int b, int c) {
// System.out.println(sub_2);
// }}
题目3
//getXxx()和setXxx()声明在哪个类中内部操作的属性就是哪个类里的。
public class InterviewTest2 {public static void main(String[] args) {Father f new Father();Son s new Son();System.out.println(f.getInfo());//atguiguSystem.out.println(s.getInfo());//尚硅谷s.test();//尚硅谷 atguiguSystem.out.println(-----------------);s.setInfo(大硅谷);System.out.println(f.getInfo());//atguiguSystem.out.println(s.getInfo());//大硅谷s.test();//大硅谷 atguigu}
}class Father {private String info atguigu;public void setInfo(String info) {this.info info;}public String getInfo() {return info;}
}class Son extends Father {private String info 尚硅谷;public void setInfo(String info) {this.info info;}public String getInfo() {return info;}public void test() {System.out.println(this.getInfo());System.out.println(super.getInfo());}
}题目4多态是编译时行为还是运行时行为
//证明如下
class Animal {protected void eat() {System.out.println(animal eat food);}
}class Cat extends Animal {protected void eat() {System.out.println(cat eat fish);}
}class Dog extends Animal {public void eat() {System.out.println(Dog eat bone);}
}class Sheep extends Animal {public void eat() {System.out.println(Sheep eat grass);}
}public class InterviewTest {public static Animal getInstance(int key) {switch (key) {case 0:return new Cat ();case 1:return new Dog ();default:return new Sheep ();}}public static void main(String[] args) {int key new Random().nextInt(3);System.out.println(key);Animal animal getInstance(key);animal.eat(); }
}练习2
class Person {protected String nameperson;protected int age50;public String getInfo() {return Name: name \n age: age;}
}
class Student extends Person {protected String schoolpku;public String getInfo() {return Name: name \nage: age \nschool: school;}
}
class Graduate extends Student{public String majorIT;public String getInfo(){return Name: name \nage: age \nschool: school\nmajor:major;}
}
建立InstanceTest 类在类中定义方法method(Person e); 在method中: (1)根据e的类型调用相应类的getInfo()方法。 (2)根据e的类型执行 如果e为Person类的对象输出 “a person”; 如果e为Student类的对象输出 “a student” “a person ” 如果e为Graduate类的对象输出 “a graduated student” “a student” “a person”
练习3
定义三个类父类GeometricObject代表几何形状子类Circle代表圆形MyRectangle代表矩形。定义一个测试类GeometricTest编写equalsArea方法测试两个对象的面积是否相等注意方法的参数类型利用动态绑定技术编写displayGeometricObject方法显示对象的面积注意方法的参数类型利用动态绑定技术。
