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、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间: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)。
多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。