java多态的实际应用
java多线程实际应用案例
java多线程实际应用案例Java多线程是一种并发编程的方式,可以使程序同时执行多个任务,提高程序的执行效率和响应速度。
下面列举了十个Java多线程实际应用案例。
1. 电商网站订单处理:在一个电商网站中,订单的处理是一个非常繁琐且耗时的工作,可以使用多线程实现订单的并发处理,提高订单处理的效率。
2. 聊天软件消息发送:在聊天软件中,用户发送消息是一个频繁的操作,可以使用多线程实现消息的并发发送,提高用户体验。
3. 数据库读写操作:在数据库的读写操作中,读操作可以使用多线程并发执行,提高数据的读取速度;写操作可以使用多线程并发执行,提高数据的写入速度。
4. 图像处理:在图像处理中,可以使用多线程实现图像的并行处理,提高图像处理的速度。
5. 视频编解码:在视频编解码中,可以使用多线程实现视频的并行编解码,提高视频的处理速度。
6. 网络爬虫:在网络爬虫中,可以使用多线程实现并发的爬取网页数据,提高爬虫的效率。
7. 游戏开发:在游戏开发中,可以使用多线程实现游戏的并行处理,提高游戏的运行速度和响应速度。
8. 大数据处理:在大数据处理中,可以使用多线程实现并发的数据处理,提高大数据处理的效率。
9. 并发服务器:在服务器开发中,可以使用多线程实现并发的请求处理,提高服务器的并发能力。
10. 并发任务调度:在任务调度中,可以使用多线程实现并发的任务执行,提高任务的执行效率。
在实际应用中,多线程不仅可以提高程序的执行效率和响应速度,还可以充分利用多核处理器的优势,实现并行计算和并发处理。
然而,多线程编程也面临着诸多挑战,如线程安全、死锁、资源竞争等问题,需要设计合理的线程同步和互斥机制,确保程序的正确性和稳定性。
因此,在使用多线程编程时,需要仔细考虑线程间的依赖关系和数据共享问题,合理规划线程的数量和调度策略,确保多线程程序的正确性和性能。
java多态练习题
java多态练习题Java多态练习题Java是一种面向对象的编程语言,其中的多态性是其最重要的特性之一。
通过多态,我们可以实现代码的灵活性和可扩展性。
在这篇文章中,我们将通过一些练习题来加深对Java多态性的理解。
练习一:动物的多态假设有一个动物类Animal,它有一个方法叫做makeSound(),用于输出动物的叫声。
现在我们派生出了两个子类Dog和Cat,它们分别重写了makeSound()方法,分别输出"汪汪汪"和"喵喵喵"。
现在我们创建一个Animal类型的数组,数组中存放了不同的动物对象,包括Dog和Cat。
我们遍历数组,调用每个动物对象的makeSound()方法,观察输出结果。
代码示例:```javaclass Animal {public void makeSound() {System.out.println("动物发出叫声");}}class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("汪汪汪");}}class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("喵喵喵");}}public class PolymorphismExample {public static void main(String[] args) { Animal[] animals = new Animal[3]; animals[0] = new Dog();animals[1] = new Cat();animals[2] = new Dog();for (Animal animal : animals) {animal.makeSound();}}}```运行结果:```汪汪汪喵喵喵汪汪汪```通过这个练习题,我们可以看到多态的作用。
列举现实生活中的java应用
列举现实生活中的java应用现实生活中的Java应用Java是一种广泛使用的编程语言,具有可移植性强、安全性高、性能优越等特点,因此在现实生活中有许多应用场景。
本文将列举一些常见的现实生活中的Java应用,并对其进行简要介绍。
1. 移动应用开发随着智能手机的普及,移动应用开发成为了一个热门领域。
Java语言通过Android平台成为了移动应用开发的主要语言。
开发人员可以使用Java语言编写Android应用程序,实现各种功能,如社交媒体应用、游戏、电子商务应用等。
2. 金融系统Java语言在金融领域广泛应用。
许多银行、证券公司、保险公司等金融机构使用Java语言开发和维护其核心系统。
Java的高性能、可靠性以及安全性,使得它成为了金融系统开发的首选语言。
3. 企业级应用开发Java语言在企业级应用开发中也起到了重要作用。
很多大型企业使用Java语言开发和维护其内部系统,如人力资源管理系统、客户关系管理系统等。
Java的可扩展性和可靠性使得它成为了企业级应用开发的首选语言。
4. 云计算云计算是一种基于互联网的计算模式,通过将计算资源集中在云服务器上,提供给用户按需使用。
Java语言被广泛用于云计算平台的开发。
例如,Apache Hadoop是一个基于Java语言开发的开源分布式计算框架,它可以处理大规模数据集,并提供高性能的数据处理能力。
5. 物联网物联网是指通过互联网将各种物理设备连接起来,实现信息的互通和共享。
Java语言在物联网领域也有着广泛应用。
例如,Java语言可以用于编写智能家居系统的控制程序,实现家电设备的智能化控制。
6. 游戏开发Java语言在游戏开发领域也有一定的应用。
虽然Java语言在游戏性能方面不如C++等底层语言,但它在跨平台性和开发效率方面具有优势。
许多小型游戏和手机游戏使用Java语言进行开发。
7. 医疗保健Java语言在医疗保健领域也有一些应用。
例如,医院管理系统、电子病历系统等都可以使用Java语言进行开发。
Java基本概念:多态
Java基本概念:多态⼀、简介描述:多态性是⾯向对象编程中的⼀个重要特性,主要是⽤来实现动态联编的。
换句话说,就是程序的最终状态只有在执⾏过程中才被决定,⽽⾮在编译期间就决定了。
这对于⼤型系统来说能提⾼系统的灵活性和扩展性。
多态允许相同类域的不同对象对同⼀消息做出响应。
即同⼀消息可以根据发送对象的不同⽽采⽤多种不同的⾏为⽅式。
多态可以让我们不⽤关⼼某个对象到底是什么具体类型,就可以使⽤该对象的某些⽅法,从⽽实现更加灵活的编程,提⾼系统的可扩展性。
如果对象的编译时类型和运⾏时类型不⼀致,就会造成多态。
存在条件:1. 类之间有继承关系。
2. ⼦类重写⽗类⽅法。
3. ⽗类引⽤指向⼦类对象。
注意:多态是⽅法的多态,属性没有多态性。
⼀个对象的实际类型是确定的,但是可以指向这个对象的引⽤的类型,却是可以是这对象实际类型的任意⽗类型。
⼦类继承⽗类,调⽤⽅法,如果该⽅法在⼦类中没有重写,那么就是调⽤的是⼦类继承⽗类的⽅法,如果重写了,那么调⽤的就是重写之后的⽅法。
'protected'修饰的⽗类⽅法可以被⼦类见到,也可以被⼦类重写,但是它是⽆法被外部所引⽤的,所以没有多态性。
通过⼀个变量调⽤其引⽤的对象的⼀个⽅法,编译器是否能让其编译通过,主要是看该变量类型的类中有没有定义该⽅法,如果有则编译通过,如果没有则编译报错。
⽽不是看这个变量所引⽤的对象中有没有该⽅法。
Java中的⽅法调⽤,是运⾏时动态和对象绑定的,不到运⾏的时候,是不知道到底哪个⽅法被调⽤的。
编写程序时,如果想调⽤运⾏时类型的⽅法,只能进⾏类型转换,不然通不过编译器的检查。
但是如果两个没有关联的类进⾏强制转换,会报类型转换异常:ClassCastException。
⽰例:public class Test {public static void main(String[] args) {/* 编译看左,运⾏看右 */Student student = new Student();/* 变量person是可以指向Person类型或其⼦类型的对象,所以可以指向Student类型对象 */Person person = new Student();/* 变量student能调⽤的⽅法是Student类中有的⽅法(包括继承过来的) */student.say();//Student/* 变量person能调⽤的⽅法是Person类中有的⽅法 */person.say();//Student}}class Person {public void say() {System.out.println("Person");}}class Student extends Person {public void say() {System.out.println("Student");}}⼆、重写、重载、多态的关系1. 重载是编译时多态调⽤重载的⽅法,在编译期间就要确定调⽤的⽅法是谁,如果不能确定则编译报错。
多态编程应用实验报告
#### 实验名称:多态编程应用#### 实验日期:2023年11月15日#### 实验环境:Java Development Kit (JDK) 1.8,Eclipse IDE#### 实验目的:1. 理解多态的概念及其在面向对象编程中的重要性。
2. 通过具体实例学习多态的应用,包括方法重写和向上转型。
3. 掌握多态在处理不同类型对象时的灵活性和效率。
#### 实验内容:一、实验背景多态是面向对象编程的三大基本特性之一,它允许不同类的对象对同一消息做出响应。
在Java中,多态主要通过方法重写和向上转型来实现。
本实验旨在通过设计一个简单的动物管理系统,来演示多态在实际编程中的应用。
二、实验设计1. 定义一个抽象类`Animal`,其中包含一个抽象方法`makeSound`。
2. 创建几个继承自`Animal`的具体类,如`Dog`、`Cat`和`Bird`,并分别实现`makeSound`方法。
3. 设计一个`AnimalManager`类,用于管理不同类型的动物对象。
4. 在`AnimalManager`类中,使用多态特性展示不同动物的叫声。
三、实验步骤1. 创建抽象类`Animal`:```javapublic abstract class Animal {public abstract void makeSound();}```2. 创建具体类`Dog`、`Cat`和`Bird`:```javapublic class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Woof! Woof!"); }}public class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Meow! Meow!"); }}public class Bird extends Animal {@Overridepublic void makeSound() {System.out.println("Tweet! Tweet!"); }}```3. 创建`AnimalManager`类:```javapublic class AnimalManager {public void manageAnimals(Animal[] animals) {for (Animal animal : animals) {animal.makeSound();}}}```4. 编写主类`Main`,用于测试多态应用:```javapublic class Main {public static void main(String[] args) {Animal[] animals = new Animal[3];animals[0] = new Dog();animals[1] = new Cat();animals[2] = new Bird();AnimalManager manager = new AnimalManager(); manager.manageAnimals(animals);}}```四、实验结果与分析运行`Main`类,输出结果如下:```Woof! Woof!Meow! Meow!Tweet! Tweet!```实验结果显示,通过多态,`AnimalManager`类能够处理不同类型的动物对象,并调用它们各自特有的`makeSound`方法。
在JAVA中有两种多态指的是什么
同问 在JAVA中有两种多态指的是什么 2009-01-15 14:32 提问者: mdydyy |浏览次数:2218次
我来帮他解答
精彩回答
2009-01-15 15:11在JAVA中有两种多态是指:运行时多态和编译时多态。关于类的多态性简介如下: 多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型: 1+2 //加法运算符 “1” + “2” //字符串连接运算,操作数是字符串 多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性. 1、类多态性表现 (1)方法重载 重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个. (2)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法,当子类方法的参数列表与父类方法参数列表完全相同时,称为子类方法覆盖(override)父类方法。覆盖父类方法时,子类方法的访问权限不能小于父类方法的权限。 由于Object类的equals()方法比较两个对象的引用是否相等而不是值是否相等,因此一个类要覆盖Object类的equals()方法,提供本类两个对象比较相等方法. 覆盖表现为父类与子类之间方法的多态性.java 寻找执行方法的原则是:从对象所属的类开始,寻找匹配的方法执行,如果当前类中没有匹配的方法,则逐层向上依次在父类或祖先类中寻找匹配方法,直到Object类. 2、super 引用 在子类的成员方法中,可以使用代词super引用父类成员.super引用的语法如下: super([参数列表]) //在子类的构造方法体中,调用父类的构造方法 super.成员变量 //当子类隐藏父类成员变量时,引用父类同名成员变量 super.成员方法([参数列表]) //当子类覆盖父类成员方法时,调用父类同名成员方法 *注意:super引用没有单独使用的语法 3、多态性有两种: 1)编译时多态性 对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性. 2)运行时多态性 如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性. 方法覆盖表现出两种多态性,当对象获得本类实例时,为编译时多态性,否则为运行时多态性,例如: XXXX x1 = new XXXX(参数列表); //对象获得本类实例,对象与其引用的实例类型一致 XXX xx1 = new XXX(参数列表); x1.toString(); //编译时多态性,执行XXX类的方法. xx1.toString(); //编译时多态性,执行XXXX类覆盖的方法. XXXX为XXX的父类. 由于子类对象既是父类对象,父类对象与子类对象之间具有赋值相容性,父类对象能够被赋值为子类对象.例如, XXXX x2 = new XXX(参数列表); //父类对象获得子类实例,子类对象即是父类对象 x2.toString(); //运行时多态 x2声明为父类对象却获得子类XXX的实例,那么x2.toString()究竟执行父类方法还是执行子类覆盖的方法呢? 这分为两种情况: 取决于子类是否覆盖父类方法.如果子类覆盖父类方法,则执行子类方法; 如果没有覆盖,则执行父类方法. 在编译时,仅仅依据对象所属的类,系统无法确定到底应该执行那个类的方法,只有运行时才能确定,因此这是运行时多态. 父类对象并不能执行所有的子类方法,只能执行那些父类中声明\子类覆盖的子类方法.
Java实验报告继承、多态、接口和异常处理
Java实验报告继承、多态、接⼝和异常处理实验5 继承、多态、接⼝和异常处理⼀、实验⽬的1、掌握Java的类和对象的声明和使⽤⽅法;2、掌握Java的类的继承和实现⽅法;3、掌握多态性在类的继承中的运⽤;4、掌握接⼝的定义与使⽤;5、掌握基本异常的处理机制;6、熟悉try语句与catch语句的搭配使⽤;7、了解有异常处理与没有异常处理的差别;8、多重catch语句的使⽤;9、使⽤Throws声明异常和Throw抛出异常。
⼆、实验环境1、PC微机;2、DOS操作系统或 Windows 操作系统;3、Java sdk程序开发环境、eclipse集成环境。
三、实验内容1. 设计三个类,分别是学⽣类Student,本科⽣类UnderGraduate,研究⽣类Postjgraduate,其中Student类是⼀个抽象类,它包含学⽣的基本信息如姓名、所学课程、课程成绩等,⽽Undergraduate类和Postgraduate类都是Student类的⼦类,这两个类计算课程成绩等级的⽅法有所不同,如下表所⽰。
假设某班级⾥既有研究⽣⼜有本科⽣,编写程序统计出全班学⽣2. 和Mobilephone具体实现,并设计⼀个应⽤程序类来使⽤这些类。
3.要求设计⼀个GUI图形窗⼝程序,该程序让⽤户输⼊⼀个星期中的任意⼀天的数字1-7,然后输出该数字所对应的是星期⼏。
四、实验步骤实验内容⼀1.建⽴package experiment5_1,其最终⽬录结构如下:2.建⽴Student类:package experiment5_1;public abstract class Student {final static int CourseNo = 3;String name;String type;int[] courses;String courseGrade;public Student(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name; courses = new int[CourseNo];courseGrade = "" ;}public abstract void calculateGrade();public String getName( ) {return name;}public String getType( ) {return type ;}public String getCourseGrade( ) {return courseGrade;}public int getCourseScore(int courseNumber) {return courses[courseNumber];}public void setName(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name;}public void setType(String type) {this.type = type;}public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩this.courses[courseNumber] = courseScore ;}}3.建⽴外部类(1)研究⽣类Postjgraduatepackage experiment5_1;public class postgraduate extends Student {public postgraduate(String name) {super(name);type = "研究⽣";}public void calculateGrade() {// TODO Auto-generated method stubint total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += courses[i];};average = total / CourseNo;if (average>=90&&average<100) courseGrade = "优秀"; else if (average>=80&&average<90) courseGrade = "良好"; else if (average>=70&&average<80) courseGrade = "⼀般"; else if (average>=60&&average<70) courseGrade = "及格"; else courseGrade = "不及格";}}(2)本科⽣类UnderGraduatepackage experiment5_1;public class undergraduate extends Student {public undergraduate(String name ) {super(name);type = "本科⽣";}public void calculateGrade() {int total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += getCourseScore(i) ;};average = total / CourseNo;if (average>=80&&average<100) courseGrade = "优秀"; else if (average>=70&&average<80) courseGrade = "良好"; else if (average>=60&&average<70) courseGrade = "⼀般"; else if (average>=50&&average<60) courseGrade = "及格"; else courseGrade = "不及格";}}4.编写代码测试函数package experiment5_1;public class polymorphism {public static void main(String[] args) {Student[] students = new Student[5];students[0] = new undergraduate("陈建平");students[1] = new undergraduate("鲁向东");students[2] = new postgraduate("匡晓华");students[3] = new undergraduate("周丽娜");students[4] = new postgraduate("梁欣欣");for (int i=0; i<5 ;i++) {students[i].setCourseScore(0,87);students[i].setCourseScore(1,90);students[i].setCourseScore(2,78);}for (int i=0; i<5 ;i++) {students[i].calculateGrade();}System.out.println("姓名" + " 类型" +" 成绩");System.out.println("-----------------------");for (int i=0; i<5 ;i++) {System.out.println(students[i].getName( )+" "+students[i].getType( )+" "+students[i].getCourseGrade( ));}}}实验内容⼆1.建⽴package experiment5_2,其最终⽬录结构如下:2.写接⼝Soundable代码:package experiment5_2;public interface Soundable {public void increaseV olume( );public void decreaseV olume( );public void stopSound( );public void playSound( );}3.创建三个类Radio、Walkman和Mobilephone具体实现,分别添加代码:// Mobilephone类package experiment5_2;class Mobilephone implements Soundable{public void increaseV olume( ) {System.out.println("增⼤⼿机⾳量");}public void decreaseV olume( ) {System.out.println("减⼩⼿机⾳量");}public void stopSound( ) {System.out.println("关闭⼿机");}public void playSound( ) {System.out.println("⼿机发出来电铃声");}}// Walkman类package experiment5_2;class Walkman implements Soundable { public void increaseV olume( ) { System.out.println("增⼤随声听⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩随声听⾳量"); }public void stopSound( ) {System.out.println("关闭随声听");}public void playSound( ) {System.out.println("随声听发出⾳乐"); }}// Radio类package experiment5_2;class Radio implements Soundable{ public void increaseV olume( ) { System.out.println("增⼤收⾳机⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩收⾳机⾳量"); }public void stopSound( ) {System.out.println("关闭收⾳机");}public void playSound( ) {System.out.println("收⾳机播放⼴播"); }}4.创建people类及编写测试代码://People类package experiment5_2;class People {public void listen(Soundable s) {s.playSound( );}}//测试代码package experiment5_2;import java.util.Scanner;public class InterfaceTest {public static void main(String[] args) {int i;People sportsman = new People( );Scanner scanner = new Scanner(System.in);Soundable[] soundDevice = new Soundable[3];//往声⾳设备数组中放⼊能发声的设备soundDevice[0] = new Radio( );soundDevice[1] = new Walkman( );soundDevice[2] = new Mobilephone();System.out.println("你想听什么? 请输⼊选择:0-收⾳机1-随声听2-⼿机");i = scanner.nextInt( );//开始听声⾳sportsman.listen(soundDevice[i]);soundDevice[i].increaseV olume( );soundDevice[i].stopSound();scanner.close();}}实验内容三1.建⽴package experiment5_3,其最终⽬录结构如下package experiment5_3;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class DateTransf extends JFrame implements KeyListener{/****/private static final long serialVersionUID = 1L;private static DateTransf frm;private static JTextField txt;private static JTextField data;DateTransf() {setTitle("数字与星期转换");setLocation(700, 300);setSize(400,130);}public static void main(String[] args) {frm = new DateTransf();frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frm.setLayout(new GridLayout(2,2));txt = new JTextField(12);data = new JTextField(12);JLabel lable1 = new JLabel("输⼊数字:");JLabel lable2 = new JLabel("星期⼏:");frm.add(lable1);txt.addKeyListener(frm);frm.add(txt);frm.add(lable2);frm.add(data);frm.setVisible(true);}public void keyPressed(KeyEvent e) {if (e.getSource() == txt) {if (e.getKeyCode() == KeyEvent.VK_ENTER) // 判断按下的键是否是回车键{try {int number = Integer.parseInt(txt.getText());switch (number) {case 1:data.setText("Mon");break;case 2:data.setText("Tue");break;case 3:data.setText("Wen");break;case 4:data.setText("Thu");break;case 5:data.setText("Fri");break;case 6:data.setText("Sat");break;case 7:data.setText("Sun");break;default:JOptionPane.showMessageDialog(null, "您输⼊的数字不是1~7","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMATION_MESSAGE); break;}}catch (Exception e1) {// TODO: handle exceptionJOptionPane.showMessageDialog(null, "您输⼊的不是整数","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMA TION_MESSAGE); }}}}public void keyReleased(KeyEvent e) {}public void keyTyped(KeyEvent e) {}}2.编译运⾏五、实验结果●实验内容⼀结果:●实验内容⼆结果:●实验内容三结果:六、实验⼩结1.这次实验的内容⽐较多,需要掌握Java的类和对象的声明和使⽤⽅法、Java的类的继承和实现⽅法、多态性在类的继承中的运⽤、接⼝的定义与使⽤、基本异常的处理机制、try语句与catch语句的搭配使⽤等等;2. 在实验过程中,重点是要区分好实例和类,灵活掌握类的调⽤。
Java-多态经典例子
Java-多态经典例⼦public class A {public String show(D obj) {return ("A and D");}public String show(A obj) {return ("A and A");}}public class B extends A{public String show(B obj){return ("B and B");}public String show(A obj){return ("B and A");}}public class C extends B{}public class D extends B{}public class Test {public static void main(String[] args) {A a1 = new A();A a2 = new B();B b = new B();C c = new C();D d = new D();System.out.println("1--" + a1.show(b));System.out.println("2--" + a1.show(c));System.out.println("3--" + a1.show(d));System.out.println("4--" + a2.show(b));System.out.println("5--" + a2.show(c));System.out.println("6--" + a2.show(d));System.out.println("7--" + b.show(b));System.out.println("8--" + b.show(c));System.out.println("9--" + b.show(d));}}运⾏结果:1--A and A2--A and A3--A and D4--B and A5--B and A6--A and D7--B and B8--B and B9--A and D说明 在这⾥看结果1、2、3还好理解,从4开始就开始糊涂了,对于4来说为什么输出不是“B and B”呢?⾸先我们先看⼀句话:当超类对象引⽤变量引⽤⼦类对象时,被引⽤对象的类型⽽不是引⽤变量的类型决定了调⽤谁的成员⽅法,但是这个被调⽤的⽅法必须是在超类中定义过的,也就是说被⼦类覆盖的⽅法。
多态编程实验报告
一、实验目的1. 理解多态的概念和原理。
2. 掌握多态编程的基本方法。
3. 通过实验加深对多态编程的理解和应用。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse三、实验内容1. 多态的基本概念2. 多态的实现方法3. 多态的应用实例四、实验步骤1. 多态的基本概念多态是指同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。
在Java中,多态主要通过继承和重写方法来实现。
2. 多态的实现方法(1)继承在Java中,通过继承可以实现多态。
子类继承父类的方法和属性,可以重写父类的方法,使得子类的方法具有多态性。
(2)重写方法重写方法是指在子类中重写父类的方法,使得子类的方法具有多态性。
重写方法必须满足以下条件:- 方法名、返回类型、参数列表与父类方法相同;- 子类和父类之间必须存在继承关系。
(3)方法重载方法重载是指在同一个类中,存在多个同名方法,但参数列表不同。
方法重载可以实现多态,因为根据传入的参数列表,可以调用不同的方法。
3. 多态的应用实例下面通过一个简单的例子来展示多态的应用。
(1)创建一个动物类```javapublic class Animal {public void makeSound() {System.out.println("Animal makes a sound");}}```(2)创建两个子类,分别代表狗和猫```javapublic class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Dog barks");}}public class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Cat meows");}}```(3)创建一个方法,接受一个Animal类型的参数,并调用其makeSound方法```javapublic class Test {public static void main(String[] args) {Animal dog = new Dog();Animal cat = new Cat();makeSound(dog);makeSound(cat);}public static void makeSound(Animal animal) {animal.makeSound();}}```输出结果:```Dog barksCat meows```通过上面的例子,我们可以看到,尽管我们传递的是Animal类型的参数,但在调用makeSound方法时,会根据实际对象的类型调用相应的方法,实现了多态。
Java程序设计教程第7章7.2 多 态
master.feed(xxx); ……
public void feed( XXX xxx ) { xxx.eat();
可否使用一个feed(Pet pet) 实现对所有宠物的喂食?
}
… … 频繁修改代码,代码可扩展性、可维护性差,
}
如何优化?
课堂操作——购置新车2-2
提前做完的同学可以尝试改进系统:
1. 循环从控制台选择汽车种类 2. 从控制台输入天数 3. 累加计算总租金
20/30
多态
总结
使用多态的好处
减少类中代码量 提高代码的可扩展性和可维护性
向上转型——子类转换为父类,自动进行类型转换
向下转型——父类转换为子类,结合instanceof运算符进行强 制类型转换
编写测试方法
调用主人类给狗狗喂的方法 调用主人类给企鹅喂的方法
为什么使用多态5-2
3/30
为什么使用多态5-3
问题
如果再领养XXX宠物,并需要给XXX喂食,怎么办?
添加XXX类,继承Pet类,实现吃食方法 修改Master类,添加给XXX喂食的方法
4/30
为什么使用多态5-4
主人类
练习
需求说明
使用多态实现喂养宠物功能 增加宠物猫并喂食,其健康值增加4
9/30
使用父类作为方法返回值实现多态
使用多态实现领养宠物
使用父类作为方法返回值 实现思路
在Master类添加领养方法getPet(String typeId ) 创建测试类,根据主人选择宠物类型编号来领养宠物
public class Master { public void feed( Dog dog ) { dog.eat(); } public void feed( Penguin pgn ) { pgn.eat(); }
java多态性
Java的多态性面向对象编程有三个特征,即封装、继承和多态。
封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。
继承是为了重用父类代码,同时为实现多态性作准备。
那么什么是多态呢?方法的重写、重载与动态连接构成多态性。
Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来的非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,派生类与基类间有IS-A的关系(即“猫”is a “动物”)。
这样做虽然保证了继承关系的简单明了,但是势必在功能上有很大的限制,所以,Java引入了多态性的概念以弥补这点的不足,此外,抽象类和接口也是解决单继承规定限制的重要手段。
同时,多态也是面向对象编程的精髓所在。
要理解多态性,首先要知道什么是“向上转型”。
我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。
我可以通过Cat c = new Cat();实例化一个Cat的对象,这个不难理解。
但当我这样定义时:Animal a = new Cat();这代表什么意思呢?很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象。
由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的。
那么这样做有什么意义呢?因为子类是对父类的一个改进和扩充,所以一般子类在功能上较父类更强大,属性较父类更独特,定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能,又可以抽取父类的共性。
所以,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,它是无可奈何的;同时,父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下,才可以被父类类型的引用调用;对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。
概述多态的作用
概述多态的作用
多态的作用是在面向对象的编程中,允许不同类型的对象对同一方法进行不同的实现,从而提供灵活性和可扩展性。
具体来说,多态的作用有以下几个方面:
1. 代码复用:多态允许使用通用的接口来处理一组相关的对象。
通过将对象视为它们共同的基类或接口类型,可以在不修改现有代码的情况下扩展程序功能或实现新的功能。
2. 扩展性:多态允许在不改变现有代码的情况下添加新的类型和行为。
通过创建新的子类并实现基类或接口的方法,可以在应用程序中引入新的功能。
3. 可替换性:多态允许将子类的对象替换为父类的对象,从而增加了代码的灵活性。
这意味着可以在运行时根据需要切换不同的实现方式,使程序更具可定制性和可配置性。
4. 抽象性:多态允许通过将对象视为它们共同的基类或接口类型来隐藏对象的具体实现细节。
这样可以将注意力集中在对象的行为和功能上,而不是关注具体实现的细节。
总的来说,多态提供了一种灵活性、可扩展性和可配置性的编程方式,可以使代码更加模块化、易于维护和可重用。
同时,多态也是面向对象编程的重要特性,使代码更具可读性和可理解性。
Java多态性及其应用研究
摘
要 :在 Jv aa面 向对 象的程序 设 计 中有 效地利 用 多 态性, 以提 高程序 的可扩 充性 、 灵活 性和程 序代 码 的 重用 可
率 。 就 Jv a a语 言 支 持 的 多 态 性 作 了 全 面 的 探 讨 ,旨在 希 望 Jv aa程 序 设 计 人 员 能 更 好 地 利 用 多 态 性 , 发 高效 、 开 灵 活 、 壮 的Jv 健 a a程 序 。
2 J v 语 言 的 多态 形 式研 究 aa
21 强 制 多 态 .
强制 多态 隐式 的将参 数按 某种方 法 . 转换 成 编译 器认 为正 确的类 型 以避免错误 。例如 , “ . 在 1 0+1 ” “ . . 、1 0 0+1 及 “. ” 1 0+ ” 1’个表 达式 中 ,第 1 表 达式 将 两个 du l的操作 数 相加 ; … 3 个 o be Jv 中特 别声 明 了这种 用 法 。第2 aa 个表 达 式 将d u l型 和it o be n相
重载 ( vr a ) 态是 让类 以统一 的方 式处 理不 同类 型数 O el d 多 o 据 的一 种手 段 。Jv 的方 法 重载 , 是 在类 中可 以创建 多 个方 aa 就 法, 它们 具有 相 同的名 字 , 但具 有不 同 的参数 和不 同的定 义 。 调 用方 法 时通 过 传递 给 它们 的不 同个 数 和类 型 的参 数来 决定 具 体使 用哪个 方法 。下 面是 一个 方法 重载 的例子 : 实例22T s v r a .v . et el d a a O o j p bi casT s v r a { u l l et el d c s O o
定 的 和 通 用 的4 类 : 制 的 、 载 的 、 数 的 和 包 含 的 。 制 多 小 强 重 参 强
java多态实验报告
java多态实验报告Java多态实验报告引言:Java是一种面向对象的编程语言,多态是其核心特性之一。
本实验旨在通过编写代码并运行实验,深入理解Java中的多态概念和使用方法。
实验目的:1. 理解多态的概念和原理;2. 掌握多态的使用方法和技巧;3. 通过实验加深对多态的理解和应用。
实验步骤:1. 创建一个抽象类Animal,并定义一个抽象方法makeSound();2. 创建两个继承自Animal的子类:Dog和Cat,并分别实现makeSound()方法;3. 在主函数中创建一个Animal类型的数组,包含两个元素,分别为Dog和Cat 的实例;4. 遍历数组,调用每个元素的makeSound()方法;5. 运行程序,观察输出结果。
实验结果:通过运行实验代码,我们可以看到Dog和Cat的实例都调用了makeSound()方法,但输出的结果却不同。
这就是多态的体现。
多态性允许我们在父类Animal的引用下,调用子类Dog和Cat的方法,实现了代码的灵活性和扩展性。
实验分析:1. 多态的概念:多态是指同一种类型的对象,在不同的情况下表现出不同的行为。
在本实验中,Dog和Cat都是Animal的子类,它们都继承了makeSound()方法,但实现方式不同,因此在调用时会表现出不同的行为。
2. 多态的原理:多态的实现依赖于继承和方法重写。
通过将子类对象赋值给父类引用,实现了对子类对象的调用。
在运行时,会根据实际对象的类型来确定调用哪个方法。
3. 多态的优势:多态使代码更加灵活和可扩展。
当需要新增一种动物时,只需创建一个新的子类并实现makeSound()方法,不需要修改原有的代码,即可实现新增功能。
4. 多态的应用场景:多态常用于面向对象的设计和开发中,尤其是在需要处理多种类型对象的情况下。
通过使用多态,可以简化代码结构,提高代码的可读性和可维护性。
实验总结:通过本次实验,我深入理解了Java中的多态概念和使用方法。
Java语言中动态多态性的实现及应用
private String color;
,/实 现接 1:3 Shape2D的 抽 象方 法 getArca0 public double getAreaO
{return pi radius radius;} ,/实现接 13 Color的抽象方法 setColor0
//定 义接 口 Shape2D
public interface Shape2D
{double pi=3.14; public abstract double getArca0;
J //定义接 口 Color
public interface Color
{public abstract void sctColor(String str);} //定义接 13 Shape3D继 承 Shape2D和 Color两个接 口,拥有两个接 口的 所 有抽 象 方 法 和 属性
public void setColor(String str) {color=str;】 ) ,/定 义类 Cylinder实现 Shape3D接 口
class Cylinder implements Shape3D { pr ivate double radius=5;
private double height=10;
private String color;
1.引 言 多态性 (polymorpbism)一词来源于拉丁语 lv(表示多的意思)和 mor_ Dhos(意为形态 ),其字面的含义是多种形态。在面向对象系统中 ,多态 性是其核心内容之一 ,反映了人们在求解 问题 时,对相似性 问题 的一种 求解方法。Java语言实现 了两种多态性 :静态多态性和动态 多态性 。本 文重点论述其采用重写机制实现动态多态性 的原理 ,并结合实例讲解 动态多态性的应用 。 2.关 于 多态 的 概 念 2.1继 承 继承描述了两个类之 间的一种关系 。当一个类拥 有另外 一个类 的 所有非私有数据 和操作时 ,就称这两个类之间具有继 承关系。被继承 的 类称为父类或超类 ,由继承而得到的类称为子类。Java语言不支持 多重 继 承,一个类 只能有一个直接父类 ,父类可 以同时拥 有多个子类 。Java 中用 关 键 字 extends实现 继 承 。 2.2重 写 在类的继承的过程 叶】,子类可以根据需要对 从父类继承来的方法 进行重新定义 ,这时父类和子类中的两个 方法功能不同 ,但是要求两者 名字 、参 数 列 表 和返 回类 型 要 一 致 ,就 称 子类 重 写 了 父类 的该 方 法 对 于子类重写的父类 的方法 ,若父类的对象调用这 个方法时 ,则 调用父类 中的定 义 ;若子类的对象使用这个方法时 ,则 调用 子类中的定义 ,父类 中 的定 义 如 同 被 “屏 蔽 ”了。 2-3抽 象类 在 Jaya中 ,提供 了抽象类来表示 现实世界中的抽象概念 ,即用抽象
java 实验5 接口多态 实验报告
实验五接口、多态与内部类实验目标:1、理解接口、塑型、多态的概念并能熟练应用;2、熟练掌握接口的定义和使用;3、深刻理解构造方法的调用顺序,理解编写时需要注意的问题;4、了解并学会使用内部类实验任务:1、继承时的多态:目测给出下面代码的执行输出结果,并简单解释每一行输出的原因。
答:首先,该程序的主函数是Vehicle v=new Vehicle();即先声明并实例化一个汽车对象,而v.test();则是调用汽车的测试方法;而test方法里,Vehicle vc=new Car();是将上面的汽车指向了一个具体的小汽车对象;Bus vb=new Bus();将公共汽车指向了一个具体的公共汽车对象;drive();调用汽车的驾驶方法;vc.drive();调用小汽车的驾驶方法;vb.drive();调用公共汽车的驾驶方法;而vc.brake();vb.brake();则是直接调用汽车的刹车方法。
因而运行结果如下:A new bus.Vehicle is drivenCar is drivenBus is drivenVehicle is brakedVehicle is braked2.针对下面的简单的类图,从面向对象的角度,将Instrument定义成接口,应怎样实现。
编写能完成如图功能的程序,并再编写一个简单的应用程序进行多态性测试。
(参考例子5-9;实验4该题是要求用抽象类来实现,在此要求用接口实现,还要进行多态性测试)说明:Instrument表示乐器、Wind表示管乐器、Percussion敲击乐器、Stringed表示弦乐器、Woodwind表示木管乐器、Brass表示铜管乐器。
要求:(1)Instrument为接口,Wind为抽象类,其他为普通类。
这里测试的目的是:我们知道当一个普通类实现一个接口时,必须实现该接口的全部方法,但当这个类是抽象类时,我们还需要实现该接口全部方法吗?如果不需要实现?那么是否直接不理这个方法就一,还是要将这个方法在自己类内部再标记一次为抽象方法。
生活实例解释面向对象的多态
面向对象的多态什么是多态在面向对象编程中,多态(Polymorphism)是一个重要的概念。
它指的是同一个方法可以根据不同的对象产生不同的行为。
换句话说,多态允许我们使用统一的接口来处理不同类型的对象。
多态是面向对象编程的三大特性之一,其余两个特性是封装和继承。
封装是指将数据和方法包装在一个对象中,继承是指一个类可以继承另一个类的属性和方法。
多态使得程序更加灵活,可扩展性更强。
生活中的多态示例为了更好地理解多态,我们可以通过生活中的一些例子来解释它。
1. 动物发声想象一下,你在一座动物园里散步。
你经过了一些动物的笼子,每个动物都在发出自己独特的声音。
狗在汪汪叫,猫在喵喵叫,鸟在唧唧鸣。
尽管它们发出的声音不同,但它们都是动物,都具有发声的能力。
在这个例子中,动物园可以被看作是一个类,而每个动物则是该类的实例。
类定义了动物的共同属性和方法,而每个实例则可以根据自己的特性来表现不同的行为。
这就是多态的体现。
2. 图形的面积计算假设你正在画一些图形,包括圆形、矩形和三角形。
你需要计算每个图形的面积。
不同的图形有不同的计算公式,但它们都有一个共同的方法——计算面积。
在这个例子中,每个图形可以被看作是一个类,而计算面积的方法则是这个类的一个公共方法。
每个图形类可以根据自己的特性实现不同的计算面积的方式。
当你调用计算面积的方法时,程序会根据具体的图形类型来执行相应的计算。
多态的实现方式在面向对象编程中,实现多态有两种常见的方式:继承和接口。
1. 继承实现多态继承是面向对象编程中的一个重要概念,它允许一个类继承另一个类的属性和方法。
通过继承,子类可以重写父类的方法,从而实现多态。
以动物为例,我们可以定义一个基类 Animal,它有一个方法叫做 makeSound()。
然后我们定义几个子类,如 Dog、Cat 和 Bird,它们分别重写了 makeSound() 方法来发出不同的声音。
class Animal {public void makeSound() {System.out.println("Animal makes sound");}}class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Dog barks");}}class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Cat meows");}}class Bird extends Animal {@Overridepublic void makeSound() {System.out.println("Bird chirps");}}public class Main {public static void main(String[] args) {Animal dog = new Dog();Animal cat = new Cat();Animal bird = new Bird();dog.makeSound(); // 输出:Dog barkscat.makeSound(); // 输出:Cat meowsbird.makeSound(); // 输出:Bird chirps}}在上面的例子中,我们定义了一个 Animal 类作为基类,然后定义了三个子类 Dog、Cat 和 Bird,它们都重写了 makeSound() 方法。
列举java中多态的体现
列举java中多态的体现多态是面向对象编程中的一个重要概念,它允许不同的对象对同一消息做出不同的响应。
在Java中,多态性是通过继承和接口实现来实现的。
下面将列举Java中多态的体现。
一、方法重载方法重载是指在同一个类中定义了两个或两个以上名称相同但参数类型或个数不同的方法。
这种情况下,当调用该方法时,编译器会根据参数类型和个数来判断应该调用哪个方法。
这种方式就是Java中最基本的多态性体现。
二、方法覆盖方法覆盖是指子类重新定义了父类中已有的方法,并且子类和父类中该方法具有相同的名称、返回值类型和参数列表。
当使用父类引用变量引用子类对象时,调用该方法时会自动调用子类中定义的那个方法,而不是父类中定义的那个方法。
三、向上转型向上转型是指将子类对象赋值给父类引用变量。
这种情况下,可以通过父类引用变量来访问子类对象中继承自父类的成员变量和成员方法。
由于向上转型后只能访问到父类中定义的成员变量和成员方法,因此无法直接访问子类中定义的成员变量和成员方法。
四、动态绑定动态绑定是指在运行时根据对象的实际类型来确定调用哪个方法。
在Java中,所有的非私有方法都是动态绑定的,也就是说,当调用一个非私有方法时,编译器不会确定要调用哪个方法,而是等到运行时才根据对象的实际类型来确定要调用哪个方法。
五、抽象类和接口抽象类和接口也是Java中多态性的体现。
抽象类和接口都定义了一些规范,而具体实现则由子类来完成。
当使用父类引用变量引用子类对象时,可以通过父类引用变量来访问子类对象中实现了父类或接口中定义的规范的成员变量和成员方法。
六、多态数组多态数组是指数组中存储的元素可以是不同类型的对象。
在Java中,可以使用Object类型来定义一个多态数组,在运行时将不同类型的对象存储到该数组中。
由于Object类型是所有类型的父类,因此可以使用父类引用变量来访问存储在数组中的不同类型的对象。
七、泛型泛型也是Java中多态性的一种体现方式。
java多态练习题
Java多态练习题一、选择题A. 多态是指同一方法可以根据对象的不同而有不同的实现B. 多态只能用于类的继承关系中C. 在Java中,方法重载不属于多态D. 多态可以提高代码的可扩展性和可维护性A. extendsB. implementsC. staticD. overrideA. 可以直接调用子类的特有方法B. 必须进行类型转换才能调用子类的特有方法C. 可以调用父类的所有方法D. 无法调用任何方法二、填空题1. 在Java中,多态的三个必要条件是:________、________和________。
2. 当子类重写父类的方法后,可以使用________关键字来调用父类的方法。
3. 在Java中,________关键字用于判断两个对象的类型是否相同。
三、判断题1. 多态允许同一操作作用于不同的对象,产生不同的执行结果。
()2. 方法重载(Overload)和方法重写(Override)都是实现多态的方式。
()3. 在Java中,子类对象可以直接赋值给父类引用,而无需进行类型转换。
()四、简答题1. 请简述Java中多态的作用。
2. 请说明方法重写(Override)和方法重载(Overload)的区别。
3. 在使用多态时,如何访问子类特有的方法?五、编程题1. 定义一个动物类(Animal),包含一个吃(eat)的方法。
再定义一个狗类(Dog),继承动物类,并重写吃(eat)方法。
编写一个测试类,创建一个动物类引用,指向一个狗对象,并调用吃(eat)方法。
2. 编写一个图形类(Shape),包含一个求面积(getArea)的方法。
再定义两个子类:矩形类(Rectangle)和圆形类(Circle),分别重写求面积(getArea)方法。
编写一个测试类,创建一个图形数组,包含矩形和圆形对象,遍历数组并调用求面积(getArea)方法。
3. 定义一个员工类(Employee),包含姓名、工资等属性,以及一个计算工资(calculateSalary)的方法。
java中根据某个参数调用某个方法的优雅写法
在Java中,根据某个参数调用某个方法的优雅写法一直是程序员们在开发中所关注的一个重要问题。
在本文中,我将从简到繁地讨论这个主题,尽可能全面地评估并共享这一问题的深度和广度。
在Java编程中,根据某个参数调用某个方法的优雅写法,首先可以考虑使用多态的特性来实现。
多态是面向对象编程中的一个重要概念,它允许不同的类对象对同一个消息作出不同的响应。
举个例子,如果我们有一个动物类Animal,它有一个eat()方法,然后有子类Dog和Cat,它们分别重写了eat()方法。
当我们根据参数的不同来调用eat()方法时,就可以实现不同的行为响应。
这种方法的优雅之处在于通过面向对象的思想,将不同的行为封装在各自的类中,提高了代码的可读性和可维护性。
另外,我们还可以考虑使用反射机制来实现根据参数调用方法。
Java 的反射机制允许程序在运行时候检查自身的结构,并能够动态地操作其字段或方法,这样就可以根据参数来调用相应的方法。
但是需要注意的是,反射虽然可以实现根据参数调用方法的灵活性,但是由于其运行时的性能开销比较大,使用不当会导致性能问题。
我们还可以考虑使用设计模式中的策略模式来实现根据参数调用方法的优雅写法。
策略模式是一个行为模式,它定义了算法家族,分别封装起来,让它们之间可以互相替换。
通过使用策略模式,我们可以将不同的算法封装成不同的策略类,然后根据参数选择合适的策略类进行方法调用。
这样不仅提高了代码的灵活性,也符合面向对象设计原则中的单一职责原则和开闭原则。
根据某个参数调用某个方法的优雅写法,可以通过多态、反射机制和设计模式等方式来实现。
在开发中,我们应该根据具体的业务场景和需求,选择合适的方法来实现这一功能,以提高代码的可读性、可维护性和性能。
个人观点和理解方面,我认为在实际开发中,根据某个参数调用某个方法的优雅写法并不是一个简单的问题。
我们需要综合考虑业务需求、性能要求、代码复用等方面的因素,选择合适的方法来实现。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
多态性是面向对象编程三个重要特性之一。
Java中的多态性是通过综合应用继承、覆
盖,以及向上转型实现的。
本章首先综合阐述面向对象编程的这些重要特征,引申到代码中的多态概念、多态带来的好处,以及多态能够解决的问题。
然后通过实例详细讨论多态技术
在编程中的应用。
3:如何在程序中最有效地计算众多不同几何体的表面积comArea ()?
计算表面积的方法,如comArea,包括其
他类似方法,如comArea,print(),等等,都可应用多态来解决。
因为这
些方法都可以针对不同的几何体,进行运算和操作。
即:形态不一、方法相同、内容多样。
public abstract class shape {
public double area(){
return 0;
}
public void print(){
}
}
public class sphere extends shape{
private double r;
public sphere(double r){
this.r=r;
}
public void print(){
System.out.println("球的半径:"+r);
}
public double area(){
return Math.PI*r*r*r*4/3;
}
}
public class comArea {
public static void main(String[] args) {
shape h[];
h=new shape[2];
h[0]=new sphere(10);
h[1]=new square(10,10,10);
Operator.areaMax(h);
}
}
public class Operator {
//将长方形和圆看做Shape类型
public static void areaMax(shape h[]){ shape max;
for(int i=1;i<h.length;i++)
{ max=h[0];
if(h[i].area()>max.area())
{max=h[i];
}
max.print();
}
}
}
8.1.2 多态好处
1·可替换性(substitutability)。
多态对已存在代码具有可替换性。
例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
2·可扩充性(extensibility)。
多态对代码具有可扩充性。
增加新的子类不影响已存
在类的多态性、继承性,以及其他特性的运行和操作。
实际上新加子类更容易获得多态
功能。
例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
3·接口性(interface-ability)。
多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
例如,假设超类Shape规定了
两个实现多态的接口方法,computeArea()以及computeVolume()。
子类,如Circle和Sphere为了实现多态,可以完善或者覆盖这两个接口方法。
4·灵活性(flex ibility)。
它在应用中体现了灵活多样的操作,提高了使用效率。
5·简化性(simplicity)。
多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。