实验九、面向对象编程实验
一、实验目的
⒈掌握接口的编写及使用 ⒉理解继承、多态
⒊掌握包的编写以及如何使用包中的类
二、实验内容
⒈接口的编写
(1) 编辑Interfaceclass.java，设保存在D:\\myjava目录下。
interface Interfaceclass {
int i=4; int k=5; void func1(); int func2(int x);
(2) }编辑UseInterface.java，设保存在D:\\myjava目录下。
class UseInterface implements Interfaceclass {
int j;
public void func1() //在使用接口的类中一定要实现接口中的所有抽象方法 {
System.out.println(\"func1=\"+1); }
public int func2(int i) {
System.out.println(\"func2=\"+1); return i; }
public static void main(String args[ ]) {
//Interfaceclass.class x=new Interfaceclass.class();不能对接口进行实例化 UseInterface x=new UseInterface(); x.func1(); x.func2(k); }
}
运行结果：
func1=1 func2=1
⒉多态
（1）编辑Test.java，设保存在D:\\myjava目录下。
//Employee超类的定义 abstract class Employee {
private String firstName; private String lastName;
public Employee(String first,String last) {
firstName=first; lastName=last; }
public String getEmployeeName() {
return firstName; }
public String getLastName() {
return lastName; }
public String toString() {
return firstName+lastName; }
public abstract double earnings(); }
//定义Boss类，为Employee的子类
final class Boss extends Employee {
private double weeklySalary;
public Boss(String frist,String last,double s) {
super(frist,last); setWeeklySalary(s); }
public void setWeeklySalary(double s) {
weeklySalary=(s>0?s:0); }
public double earnings() {
return weeklySalary; }
public String toString() {
return \"Boss\"+super.toString(); } }
//定义CommissiomWorker类，为Employee的子类 final class CommissionWorker extends Employee {
private double salary; private double commission; private int quantity;
public CommissionWorker(String first,String last,double s,double c,int q) {
super(first,last); setSalary(s); setCommission(c); setQuantity(q); }
public void setSalary(double s) { }
public void setQuantity(int q) { }
public void setCommission(double c) {
commission=(c>0?c:0); }
public double earnings() {
return salary+commission+quantity; }
public String toString() {
return \"CommissionWorker\"+super.toString();
quantity=(q>0?q:0); salary=(s>0?s:0);
} }
//定义PieceWorker类，为Employee的子类 final class PieceWorker extends Employee {
private double wagePiece; private int quantity;
public PieceWorker(String first,String last,double w,int q) {
super(first,last); setWage(w); setQuantity(q); }
public void setWage(double w) {
wagePiece=(w>0?w:0); }
public void setQuantity(int q) {
quantity=q; }
public double earnings() {
return wagePiece+quantity; }
public String toString() {
return \"PieceWorker\"+super.toString(); } }
//定义HourlyWorker类，为Employee的子类 class HourlyWorker extends Employee {
private double wage; private double hours;
public HourlyWorker(String first,String last ,double w,double h) {
super(first,last); setWage(w); setHours(h); }
public void setWage (double w)
{
wage=(w>0?w:0); }
public void setHours(double h) {
hours=(h>=0&&h<168?h:0); }
public double earnings() {
return wage+hours; }
public String toString() {
return \"HourlyWorker\"+super.toString(); } }
class Text {
public static void main(String args[ ]) {
//使用超类声明ref Employee ref; String output=\"\"; //分别定义各子类
Boss b=new Boss(\"Hohn\ CommissionWorker c=new
CommissionWorker(\"Sue\
PieceWorker p=new PieceWorker(\"Bob\ HourlyWorker h=new HourlyWorker(\"Karen\//使用子类分别实例化 ref=b;
output+=ref.toString()+\"earned
$\"+ref.earnings()+\"\\n\"+b.toString()+\"earned $\"+b.earnings()+\"\\n\"; System.out.print(output); ref=c;
output+=ref.toString()+\"earned
$\"+ref.earnings()+\"\\n\"+c.toString()+\"earned $\"+c.earnings()+\"\\n\"; System.out.print(output); ref=p;
output+=ref.toString()+\"earned
$\"+ref.earnings()+\"\\n\"+p.toString()+\"earned $\"+p.earnings()+\"\\n\"; System.out.print(output); ref=h;
output+=ref.toString()+\"earned
$\"+ref.earnings()+\"\\n\"+h.toString()+\"earned $\"+h.earnings()+\"\\n\"; System.out.print(output); } }
实验结果:
三：实验心得
面向对象编程是Java编程中的重要内容，通过本次编程，我掌握了接口的编写和使用，理解了继承、多态，掌握了包的编写以及如何使用包中的类，在Java中，不支持多继承，但支持多接口，所以熟练掌握接口的使用与编写很重要。
