Java中使用接口实现多继承和多态的方法
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 driven Car is driven Bus is driven Vehicle is braked Vehicle is braked 2.针对下面的简单的类图，从面向对象的角度，将Instrument定义成接口，应怎样实现。编写能完成如图功能的程序，并再编写一个简单的应用程序进行多态性测试。（参考例子5-9；实验4该题是要求用抽象类来实现，在此要求用接口实现，还要进行多态性测试） 说明：Instrument表示乐器、Wind表示管乐器、Percussion敲击乐器、Stringed表示弦乐器、Woodwind表示木管乐器、Brass表示铜管乐器。 要求：（1）Instrument为接口，Wind为抽象类，其他为普通类。这里测试的目的是：我们知道当一个普通类实现一个接口时，必须实现该接口的全部方法，但当这个类是抽象类时，我们还需要实现该接口全部方法吗？如果不需要实现？那么是否直接不理这个方法就一，还是要将这个方法在自己类内部再标记一次为抽象方法。（听起来有点晕，测试很简单的，有时百读不如一试） （2）请编写测试代码，对实现Instrument接口的各个类进行多态测试，具体可参考课本例子。所谓多态测试就是向上自动塑型，以及向下动态绑定，而动态绑定的基本规则是实例方法“由下往上”寻找绑定，类方法和类属性成员“由上往下”寻找绑定。（对其概念不清晰的请留意课本知识与课堂讲解） 该题代码如下： package zi; interface Instrument { void play(); String what(); void adjust(); }
JAVA继承和多态实验报告
实验项目名称：继承和多态 （所属课程：Java语言程序设计） 院系：专业班级：姓名： 学号：实验地点：指导老师： 本实验项目成绩：教师签字：日期： 1．实验目的 （1）掌握类的继承机制。 （2）熟悉类中成员变量和方法的访问控制。 （3）熟悉方法或构造方法多态性。 2.实验内容 （1）模拟编写程序，理解类的继承、多态、继承和多态规则。 （2）独立编程，实现类的继承和多态。 3.实验作业 设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2 程序代码为： Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color;
} public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){
Java 接口与类之间继承例题
1,定义一个接口Assaultable(可攻击的)，该接口有一个抽象方法attack()。 2,定义一个接口Mobile（可移动的）,该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口，但并没有给出具体的 实现方法。 4,定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。 6，写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击！！！"); } publicvoid move(){ System.out.println("坦克移动！！！"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击！！！"); } publicvoid move(){ System.out.println("战斗机移动！！！");
JAVA(面向对象【接口、多态】)v20170306
第3天面向对象 今日内容介绍 ◆接口 ◆多态 ◆笔记本案例 今日学习目标 ◆写出定义接口的格式 ◆写出实现接口的格式 ◆说出接口中成员的特点 ◆接口和抽象类的区别 ◆能够说出使用多态的前提条件 ◆理解多态的向上转型 ◆理解多态的向下转型 ◆能够完成笔记本电脑案例（方法参数为接口） 第1章接口 1.1接口概念 接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。 接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。 请记住：一切事物均有功能，即一切事物均有接口。
1.2接口的定义 与定义类的class不同，接口定义时需要使用interface关键字。 定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。 定义格式： public interface 接口名 { 抽象方法1; 抽象方法2; 抽象方法3; } 使用interface代替了原来的class，其他步骤与定义类相同： ●接口中的方法均为公共访问的抽象方法 ●接口中无法定义普通的成员变量 1.3类实现接口 类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements。 其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。 格式： class 类 implements 接口 { 重写接口中方法 } 在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。 ●接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备 该方法，是功能的声明。 ●在具体实现类中重写方法，实现功能，是方法的具体实现。 于是，通过以上两个动作将功能的声明与实现便分开了。(此时请重新思考：类是现实事物的描述，接口是功能的集合。) 1.4接口中成员的特点 1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字 2、接口中可以定义方法，方法也有固定的修饰符，public abstract 3、接口不可以创建对象。 4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。 interface Demo { ///定义一个名称为Demo的接口。
java开发接口文档模板
竭诚为您提供优质文档/双击可除java开发接口文档模板 篇一：java的接口与实例 一、定义 java接口（interface），是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 接口定义的一般形式为： [访问控制符]interface{ 类型标识符final符号常量名n=常数； 返回值类型方法名([参数列表]); … } 二、接口的特点 1、java接口中的成员变量默认都是 public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔) 2、java接口中的方法默认都是public,abstract类型
的(都可省略),没有方法体,不能被实例化 3、java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法 4、接口中没有构造方法,不能被实例化 5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口 6、java接口必须通过类来实现它的抽象方法 7、当类实现了某个java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类 8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例 9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承. 三、接口的用法 1、精简程序结构，免除重复定义 比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。举例：鸟类和昆虫类都具有飞行的功能，这个功能是相同的，但是其它功能是不同的，在程序实现的过程中，就可以定义一个接口，专门描述飞行。 下图是分别定义鸟类和昆虫类，其都有飞行的方法。
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) { https://www.360docs.net/doc/f516954242.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) { https://www.360docs.net/doc/f516954242.html, = name; } public void setType(String type) { this.type = type; } public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩 this.courses[courseNumber] = courseScore ; } }
Java继承与多态实验报告
西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13
一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate
（1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.360docs.net/doc/f516954242.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a 应用数学学院信息与计算科学专业 2 班学号3111008162 姓名许庆平教师评定_________________ 实验题目继承与接口 一、实验目的与要求 实验目的： 1、掌握类的继承关系。 2、掌握接口的定义与使用。 实验要求： 按下列要求编写Java程序： 1、定义接口Printx，其中包括一个方法printMyWay()，这个方法没有形参，返回值为空。 2、编写矩形类，矩形类要求实现Printx接口，有求面积、求周长的方法，printMyWay()方法要能显示矩形的边长、面积和周长。 3、编写正方形类作为矩形类的子类，正方形类继承了矩形类求面积和周长的方法，新增加求对角线长的方法，重写printMyWay()方法，要求该方法能显示正方形的边长、面积、周长和对角线长。 二、实验方案 先按要求定义接口Printx，再创建一个矩形类Rectangle，有成员变量length 和width，area（）求面积，circle（）求周长，用PrintMyWay()显示。 然后定义正方形类，继承Rectangle类，定义求对角线长的函数duijiaoxian()。面积和周长用父类中的area（）和circle（）实现。用PrintMyWay()显示。最后在主类中实现这两个类。 三、代码如下 interface Printx { void PrintMyWay();} class Rectangle implements Printx { int length,width; Rectangle(int x,int y){ length=x; width=y; } int area(){ return length*width; } int circle(){ return 2*(length+width); } public void PrintMyWay(){ System.out.println("矩形的长为:"+length); System.out.println("矩形的宽为:"+width); System.out.println("矩形的面积为:"+area()); System.out.println("矩形的周长为:"+circle()); } 第四章 面向对象的概念和 Java 实现-2 回顾 ?类是具有相同属性和行为的一组对象的集合 , 对象是类的实例 ?封装是隐藏对象实现细节的过程，以便不让用户看到实现的细节 ?类可用Class 来定义，类的变量和方法可被该类的实例访问, 圆点符号用于访问对象的成员，构造函数在创建对象时初始化对象 ?包可用package 来申明，可用import 来导入包 目标 ?理解继承及其特点 ?运用JAVA程序实现继承 ?理解多态及其特点设计 ?运用JAVA程序实现多态 ?掌握访问修饰符和方法修饰符 继承 继承的特点 继承的优点 继承的JAVA实现 子类构造方法 2-1 子类构造方法 2-2 ?调用父类构造方法的语法为： super() 或 super(参数列表) ; ?super () 方法始终指向调用类的父类 调用父类构造方法 演示：示例 3 多态性 2-1 ?多态性是指?°多种形式?± ?它使用不同的实例而执行不同操作 ?多态包括方法重写和方法重载 多态性 2-2 方法重载 2-1 方法重载 2-2 演示：示例 4 方法重写 2-1 方法重写 2-2 访问修饰符 3-1 ?信息隐藏是 OOP 最重要的功能之一，也是使用访问修饰符的原因 ?信息隐藏的原因包括： ?对任何实现细节所作的更改不会影响使用该类的代码 ?防止用户意外删除数据 ?此类易于使用 访问修饰符 3-2访问修饰符 3-3 ?访问修饰符可访问性 方法修饰符 static 修饰符 3-1 ?static修饰符修饰的方法叫静态方法 ?目的 ?使该方法独立于类的实例，使用类去访问，而不是类实例，所以也叫类方法 static 修饰符 3-2 ?调用静态方法的语法为： classname.methodname( ); static 修饰符 3-3 演示：示例 6 final 修饰符 abstract 修饰符 3-1 ?由abstract修饰的方法叫抽象方法；由abstract修饰的类叫抽象类 ?抽象方法必须声明在抽象类中 ?抽象方法语法： abstract type method_name(parameter_list); ?声明抽象类语法： abstract class{…… } ?使用：父类中的某些抽象不包含任何逻辑，并需要在子类中重写，子类提供这种抽象方法的实现细节 abstract 修饰符 3-2 ?抽象类可以具有指向子类对象的对象引用 abstract 修饰符 3-3 演示：示例 7 接口 ?接口就是某个事物对外提供的一些功能的申明 ?可以利用接口实现多态，同时接口也弥补了Java单一继承的弱点 ?使用interface关键字定义接口 ?一般使用接口声明方法或常量，接口中的方法只能是声明，不能是具体的实现 创建接口的步骤 2-1 // 定义方法的接口 public interface myinterface { public void add(int x, int y); public void volume(int x,int y, int z); } // 定义程序使用的常量的接口 public interface myconstants { public static final double price = 1450.00; public static final int counter = 5; } 创建接口的步骤 2-2 接口使用示例 为什么要继承、封装和多态 1,为什么要继承 继承的好处是代码重用.哲学上讲事物都是有共性和特性的.把共性函数代码放入到父类中,把特性函数代码放入到子类中,当然是否共性要以参照点的标准.OO中所谓的抽象我自己理解为哲学中的共性在同一个行业中,他们各业务流程往往有很大的相似性,但往往我们都是到一个项目中就重新写一套流程代码,或者粘贴以前的代码.可能有很多代码都是以前写过的重复代码.造成重复劳动.如果采用继承应该这样,首先在父类中做一个基本上大部分行业项目都必要的简洁的主流程.在子类中针对具体项目的特殊性做主流程充分的完善的补充.这样在每个项目中,只针对项目的特殊性编写代码,大大降低重复劳动.当然根据具体流程的复杂多可以划分多的继承层次,呈现一种继承的树结构,但一定的要保证层次一定要有实际的意义. 2,为什么要封装 高内聚低偶合的思想简单的理解同一模块内的提高内聚,不同模块降低偶合.如果说一个类代表一个模块或是一个业务流,那么A类内部要提高内聚,类的属性可以看成是内的局部变量.提高数据的重用.公共函数尽量能被其他主函数,尽量达到功能内聚.如果说是A类和B类,并且是不同模块(也许是同一个模块下的两个子模块),那么B 是不能使用A的函数和属性的,紧进行数据偶合.封装的作用就体现在这里. 再现实中就项目中经常遇到这种情况,某项业务增加或修改一种类型的业务流,自己本身调试成功了,但是缺影响了此业务下其他的业务流,不得不测试所有得其他原本正常的业务流并不得不针对此做类型判断的补丁,这种补丁很肯能导致程序结构的不合理. 3.为什么要多态 个人认为多态的好处体现在代码的可扩充性,比如一个业务有多个业务流,为了区别不同的类型就的使用判断,那么新添加一个流程就得在过程执行主流程(往往是final,必然是面向过程的)中添加一个”if then”或是重载一个函数 在目前项目中mvc得控制器就是典型的多态.想想如果我们不使用多态那么怎么办?因为对PO对象是新添加的,那么必须针对新的PO 对象在代码中做IF判断,才能用他本身的对象类型指向他.造成过程执行主流程不断的要变更自己的代码. 总结: OO中继承和多态互相依赖又互相矛盾,没有继承就不可能有多态,多态的使用往往又在面向过程的代码中.继承是使子类可以使用父类的功能,而多态使父类能使用子类的功能. OO并非只是在编码阶段来处理,实际上在概要设计,详细设计,数据库设计的时候就应该OO的思想来设计.提高软件可重用性和可扩充性.对于想对一个行业做标准化产品软件而言,很重要. 一、定义 Java接口（Interface），是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 接口定义的一般形式为： [访问控制符]interface <接口名> { 类型标识符final 符号常量名n = 常数； 返回值类型方法名([参数列表]); … } 二、接口的特点 1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔) 2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化 3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法 4、接口中没有构造方法,不能被实例化 5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口 6、Java接口必须通过类来实现它的抽象方法 7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类 8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例 9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承. 三、接口的用法 1、精简程序结构，免除重复定义 比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。 举例：鸟类和昆虫类都具有飞行的功能，这个功能是相同的，但是其它功能是不同的，在程序实现的过程中，就可以定义一个接口，专门描述飞行。 下图是分别定义鸟类和昆虫类，其都有飞行的方法。 下图定义了接口，其类图如下： 实现代码如下： [java]view plaincopyprint? 1. interface Flyanimal{ 2. void fly(); 3. } 实验9：接口、多态性 一、实验目的与要求 1、多态性的概念、技术基础 2、构造方法的调用顺序 3、总结接口的应用 二、内容概要 1、多态性概念 是指不同类型的对象可以响应相同的消息。从相同的基类派生出来的多个类型可被当作同一种类型对待，可对这些不同的类型进行同样的处理，由于多态性，这些不同派生类对象响应同一方法时的行为是有所差别的。 例如 ●Cat行为是吃鱼，Dog行为是吃骨头 ●所有的Object类的对象都响应toString()方法 2、多态性的技术基础 ●向上塑型技术：一个父类的引用变量可以指向不同的子类对象 ●动态绑定技术：运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，从 而实现多态性 3、多态性的好处 应用程序不必为每一个派生类（子类）编写功能调用，只要对基类（特别是抽象基类）或接口处理即可，“以不变应万变”，大大提高程序的可复用性。 例如：下面代码Waiter类中的callPersonEat方法参数是Person 类型，所以利用向上塑性技术可以给其传参数China和USA类型。而该方法体p.eat(); ，利用动态邦定技术运行时候根据p引用的具体对象调用创建对象时所属类的eat方法 interface Person{ public void eat(); } class China implements Person{ public void eat(){ System.out.println("chinese use chopsticks"); } } class USA implements Person{ public void eat(){ System.out.println("usa use forks"); } } class Waiter{ static void callPersonEat(Person p){ p.eat(); //实例方法调用，动态绑定 } public static void main(String a[]){ 20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态)) 上机实验三：面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础，是Java的核心和本质所在，在Java中，所有的语言元素都封装在类中。编写java 程序的过程就是从现实世界中抽象出java可实现的类，并用合适的语句定义它们的过程，本节将学习类的应用，以及如何创建类的实例，通过类的继承更有效的组织程序结构，明确类之间的关系。掌握本节所讲的内容后，读者就可以使用面向对象技术编写java程序了。 接口是特殊的抽象类，只包含常量和方法的定义，而没有方法的实现，也就是说接口是方法定义和常量值的集合。 包是Java语言中有效管理类的一个机制。通过关键字package声明包语句，package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。使用import语句可以引入包中的类。 一、实验目的 1) 2) 3) 4) 5) 6) 7) 掌握类的定义和使用掌握对象的声明和使用 了解构造函数的概念和使用掌握类的继承关系和派生方法掌握多态的概念与使用掌握接口的定义和使用掌握 Java中包的应用 二、实验内容 1) 2) 3) 4) 5) 6) 7) 类的声明 定义类成员变量以及成员方法 实例化类、创建类对象以及类方法的调用类的继承 通过实例理解接口的定义通过实例熟悉接口的应用 正确应用Java中包和import语句 三、实验步骤 1) 类和类的实例化 一个类的实现包括两部分：类声明和类体。、类声明[public][abstract][final] class className [extends superclassName] [implements interfaceNameList] {……} 期中修饰符[public][abstract][final]说明类的属性className为类名 superclassName为父类的名字 interfaceNameList为类实现的接口列表、类体类体定义如下 class className { [public|protected|private] [static] [final] [transient] [volatile] Type variableName; //成员变量 java接口作用及其好处 接口是实现构件可插入性的关键，可插入构件的关键在于存在一个公用的接口，以及每个构件实现了这个接口。 什么是接口？ Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。 接口的两种含义：一，Java接口，Java语言中存在的结构，有特定的语法和结构;二，一个类所具有的方法的特征集合，是一种逻辑上的抽象。前者叫做“Java接口”，后者叫做“接口”。 在Java语言规范中，一个方法的特征仅包括方法的名字，参数的数目和种类，而不包括方法的返回类型，参数的名字以及所抛出来的异常。在Java编译器检查方法的重载时，会根据这些条件判断两个方法是否是重载方法。但在Java编译器检查方法的置换时，则会进一步检查两个方法(分处超类型和子类型)的返还类型和抛出的异常是否相同。 接口继承和实现继承的规则不同，一个类只有一个直接父类，但可以实现多个接口。 Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java抽象类更抽象化。 Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public，静态的和final属性。 接口把方法的特征和方法的实现分割开来。这种分割体现在接口常常代表一个角色，它包装与该角色相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。一个角色由不同的演员来演，而不同的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。 为什么使用接口？ 两个类中的两个类似的功能，调用他们的类动态的决定一种实现，那他们提供一个抽象父类，子类分别实现父类所定义的方法。 问题的出现：Java是一种单继承的语言，一般情况下，哪个具体类可能已经有了一个超类，解决是给它的父类加父类，或者给它父类的父类加父类，只到移动到类等级结构的最 java中接口的定义与实现 1、定义接口 使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下： [修饰符] interface 接口名[extends 父接口名列表]{ [public] [static] [final] 常量; [public] [abstract] 方法; } 修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。 接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。 extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends 关键字时，父接口名为必选参数。 方法：接口中的方法只有定义而没有被实现。 例如，定义一个用于计算的接口，在该接口中定义了一个常量PI和两个方法，具体代码如下： [java] view plain copy public interface CalInterface { final float PI=3.14159f;//定义用于表示圆周率的常量PI float getArea(float r);//定义一个用于计算面积的方法getArea() float getCircumference(float r);//定义一个用于计算周长的方法getCircumference() } 注意： 与Java的类文件一样，接口文件的文件名必须与接口名相同。 实现接口 接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字implements，其基本格式如下： [修饰符] class <类名> [extends 父类名] [implements 接口列表]{ } 修饰符：可选参数，用于指定类的访问权限，可选值为public、abstract和final。 类名：必选参数，用于指定类的名称，类名必须是合法的Java标识符。一般情况下，要求首字母大写。 extends 父类名：可选参数，用于指定要定义的类继承于哪个父类。当使用extends关键字时，父类名为必选参数。 implements 接口列表：可选参数，用于指定该类实现的是哪些接口。当使用implements关键字时，接口列表为必选参数。当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔。 在类中实现接口时，方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有方法。例如，编写一个名称为Cire的类，该类实现5.7.1节中定义的接口Calculate，具体代码如下： 《Java程序设计》实验指导 实验四继承与多态 一、实验目的： 1．掌握类的继承方法。 2．掌握变量的继承和覆盖。 3．掌握方法的继承、重载和覆盖。 4．了解接口的实现方法。 二、实验原理 新类可从现有的类中产生，并保留现有类的成员变量和方法，并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 语法格式： 类访问限定符子类名extends 父类名｛ …… ｝ 三、实验内容及要求： 1. 定义一个接口（ShapeArea），其中包含返回面积的方法（getArea）。定义一个矩形类（Rectangle），派生出一个正方形类（Square），再定义一个圆类（Circle），三者都要求实现接口ShapeArea，自行扩充成员变量和方法。在主方法中建一数组，数组中放入一些上述类型的对象，并计算它们的面积之和。 2. 运行下面的程序，理解成员变量的继承与隐藏，方法的覆盖与重载。 class A{ int sum,num1,num2; public A(){ num1=10; num2=20; sum=0; } void sum1(){ sum=num1+num2; System.out.println("sum="+num1+"+"+num2+"="+sum); } void sum2(int n){ num1=n; sum=num1+num2; System.out.println("sum="+num1+"+"+num2+"="+sum); } 1、实验题目 体操比赛计算选手成绩的办法是去掉一个最高分和一个最低分再计算平均分，而学校考察一个班级的某科目的考试情况时，是计算全班学生的平均成绩。Gymnastics 类和School 类都实现了ComputerAverage接口，但实现方式不同。 2、程序代码 interface ComputerAverage{ public double average(double x[]); } class Gymnastics implements ComputerAverage{ public double average(double x[]){ int count=; double aver=0,temp=0; for(int i=0;ijava继承与接口 实验报告
《java面向对象程序设计-继承和多态》教案
Java为什么要继承、封装和多态
java的接口与实例
Java接口多态实验(修正版带实验答案)
20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态))
java接口作用及其好处
java中接口的定义与实现
Java实验指导4继承与多态
java第六次实验报告接口