目的和要求
一、实验目的和要求:
(一)目的:
1、通过编程和上机实验理解Java语言是如何体现面向对象编程基本思想;
2、了解类的封装方法,以及如何创建类和对象;
3、了解成员变量和成员方法的特性;
4、掌握面向对象程序设计的方法;
5、了解类的继承性和多态性的作用;
6、了解接口的作用。
(二)要求:
1、 编写一个体现面向对象思想的程序;
2、 编写一个创建对象和使用对象的方法的程序;
3、 编写一个显示当前日期和时间的程序;
4、 编写不同成员变量修饰方法的程序;
5、 编写不同成员方法修饰方法的程序;
6、 编写体现类的继承性(成员变量、成员方法、成员变量隐藏)的程序;
7、 编写体现类的多态性(成员方法重载、构造方法重载)的程序;
8、编写体现接口功能的程序。
编写一个体现面向对象思想的程序
题目
1、 实验3.1设计类来描述真实客观世界中的事物,使用类的成员变量来表示事物的属性和状态,使用类的成员方法来提供对成员变量的访问或修改
(1) 程序功能:设计一个用来描述汽车的类,使用类的非静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度,使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。
代码部分:
public class EXP3_1 {
private String ownerName; //车主姓名
private float curSpeed; //当前车速
private float curDirInDegree; //当前方向盘转向角度
public EXP3_1(String ownerName){
this.ownerName=ownerName;
}
public EXP3_1(String ownerName, float speed, float dirInDegree){
this(ownerName);
this.curSpeed=speed;
this.curDirInDegree=dirInDegree;
}
public String getOwnerName() { //提供对车主姓名的访问
return ownerName;
}
public float getCurDirInDegree() { //提供对当前方向盘转向角度的访问
return curDirInDegree;
}
public float getCurSpeed() { //提供对当前车速的访问
return curSpeed;
}
public void changeSpeed(float curSpeed) { //提供改变当前的车速
this.curSpeed = curSpeed;
}
public void stop(){ //提供停车
this.curSpeed=0;
}
主函数
public class EXP3_2 {
public static void main(String[] args){
EXP3_1 car=new EXP3_1("成龙",200f,25f);
System.out.println("车主姓名: "+car.getOwnerName());
System.out.println("当前车速: "+car.getCurSpeed());
System.out.println("当前转向角度: "+car.getCurDirInDegree());
car.changeSpeed(80);
System.out.println("在调用changeSpeed(80)后,车速变为: " + car.getCurSpeed());
car.stop();
System.out.println("在调用stop()后, 车速变为: "+car.getCurSpeed());
}
3、 编写显示当前时间和日期的程序
(3) 程序功能:该程序通过使用一个自定义类Time,实现显示当前日期和时间的功能。
import java.util.Calendar;;
class Time {
private Calendar t;
private int y, m, d, hh, mm, ss;
Time (){
t=Calendar.getInstance();
y=t.get(t.YEAR);
m=t.get(t.MONTH)+1;//这里之所以加1是因为Calendar中0表示1月,1表示二月。
d=t.get(t.DATE);
hh=t.get(t.HOUR_OF_DAY);
mm=t.get(t.MINUTE);
ss=t.get(t.SECOND);
}
public String getDate() {
return y + "年" + m + "月" + d + "日";
}
public String getTime() {
return hh+"时"+mm+"分"+ss+"秒";
}
}
public class EXP3_3{
public static void main(String[] args){
Time t=new Time();
System.out.println("当前日期:"+t.getDate());
System.out.println("当前时间:"+t.getTime());
}
4、 使用修饰符来限定类的成员变量或成员方法的属性
有时需要公开一些变量和方法,有时需要禁止其他对象使用变量和方法,这时可以使用修饰符来实现这个目的。
常用的修饰符如下:
public private protected package static final transient volatile
不同修饰符的访问控制权限如表3.1 所示。
表 3.1
(1) 程序功能:通过两个类StaticDemo、EXP3_4 说明静态变量/方法与实例变量/方法的区别。
import java.util.Calendar;
public class Time {
private Calendar t;
private int y, m, d, hh, mm, ss;
Time (){
t = Calendar.getInstance();
y = t.get(t.YEAR);
m = t.get(t.MONTH)+1;
d = t.get(t.DATE);
hh = t.get(t.HOUR_OF_DAY);
mm = t.get(t.MINUTE);
ss = t.get(t.SECOND);
}
public String getDate() {
return y + "年" + m + "月" + d + "日";
}
public String getTime() {
return hh+"时"+mm+"分"+ss+"秒";
}
}
主函数
public static void main(String[] args){
Time t=new Time();
System.out.println("当前日期:"+t.getDate());
System.out.println("当前时间:"+t.getTime());
}
4、 使用修饰符来限定类的成员变量或成员方法的属性
有时需要公开一些变量和方法,有时需要禁止其他对象使用变量和方法,这时可以使用修饰符来实现这个目的。
常用的修饰符如下:
public private protected package static final transient volatile
(1) 程序功能:通过两个类StaticDemo、EXP3_4 说明静态变量/方法与实例变量/方法的区别。
(2) 程序源代码如下。
class StaticDemo {
static int x;
int y;
public static int getX() {
return x;
}
public static void setX(int newX) {
x = newX;
}
public int getY() {
return y;
}
public void setY(int newY) {
y = newY;
}
}
注意:static属于全局变量,实例变量不可修改,且调用时直接用类名.的形式调用。
public class EXP3_4 {
public static void main(String[] args) {
System.out.println("静态变量x="+StaticDemo.getX());
// System.out.println("实例变量y="+StaticDemo.getY()); //非法,编译时将出错
StaticDemo a= new StaticDemo();
StaticDemo b= new StaticDemo();
a.setX(1);// StaticDemo.setX(1);
a.setY(2);
b.setX(3);// StaticDemo.setX(1);
b.setY(4);
System.out.println("静态变量a.x="+a.getX());
System.out.println("实例变量a.y="+a.getY());
System.out.println("静态变量b.x="+b.getX());
System.out.println("实例变量b.y="+b.getY());
}
}
(3) 对上面的源程序进行编译,会出现如图所示的出错提示。
(4) 将源程序中的出错语句删除或使用解释符//隐藏起来,例如,//System.out.println(“实例变量y=”+StaticDemo.getY());
(5) 重新编译并运行该程序,结果如图所示。
5、 调用方法时参数传递的练习
在其它语言中,函数调用或过程调用时参数有传值调用和传地址调用之分。在Java 中,方法中的参数传递可以分为传值调用或对象方法调用等方式。传值调用即传递的参数是基本数据类型,调用方法时在方法中将不能改变参数的值,这意味着只能使用它们。对象调用是指先调用对象,再调用对象的方法,这种方式可以修改允许存取的成员变量。所以,如果不想改变参数的值,可以采用传值调用的方法。如果想改变参数的值,可采用对象调用的方法,间接修改参数的值。
5.1、编写一个传值调用的程序
(1) 程序功能:程序首先给整型变量x 和y 赋一个初值10,然后使用传值调用方式调用方法ff1对x 和y 做乘方及输出x 和y 的乘方值,最后再输出x 和y 的乘方值。
(2) 程序源代码如下。
class EXP3_5 {
public static void main(String[] args) {
int x=10, y=10;
ff1(x, y);
System.out.println("x="+x+", y="+y);
}
static void ff1(int passX, int passY) {
passX=passX*passX;
passY=passY*passY;
System.out.println("passX="+passX+", passY="+passY);
}
}
(3) 编译并运行,结果如图。
5.2、编写一个调用对象方法的程序
(1) 程序功能:通过调用对象的方法在方法调用后修改了成员变量的值。
(2) 程序源代码如下。
class EXP3_6 {
public static void main(String[] args) {
Power p=new Power();
p.ff2(10,10);
System.out.println("方法调用后 x="+p.x+", y="+p.y);
}
}
class Power{
int x=10, y=10;
void ff2(int passX, int passY) {
System.out.println("初始时 x="+x+", y="+y);
x=passX*passX;
y=passY*passY;
System.out.println("方法调用中 x="+x+", y="+y);
}
}
6、类的继承性练习
新类可从现有的类中产生,并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。
当建立一个新类时,不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的,就可以引用被继承类的全部成员。被继承的类称为父类或超类(superclass),这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的,因此,很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类,如果你设计的这个类仅仅实现了继承,则和父类毫无两样。所以,通常要对子类进行扩展,即添加新的属性和方法。这使得子类要比父类大,但更具特殊性,代表着一组更具体的对象。继承的意义就在于此。
6.1、 创建将被继承的类
(1) 程序源代码如下。
public class EXP3_7
{
protected String xm; //具有保护修饰符的成员变量
protected int xh;
void setdata(String m,int h) //设置数据的方法
{
xm =m;
xh = h;
}
public void print() //输出数据的方法
{
System.out.println(xm+", "+xh);
}
}
(2) 编译源程序。
6.2、 创建将被继承的类
(1) 程序功能:通过EXP3_7类产生子类EXP3_8,其不仅具有父类的成员变量xm(姓名)、xh(学号),还定义了新成员变量xy(学院)、xi(系)。在程序中调用了父类的print 方法,同时可以看出子类也具有该方法。
(2) 程序源代码如下。
class EXP3_8 extends EXP3_7{
protected String xy;
protected String xi;
public static void main(String args[]){
EXP3_7 p1 = new EXP3_7();
p1.setdata("李四",12321) ;
p1.print();
EXP3_8 s1 = new EXP3_8() ;
s1.setdata("张三",12345); //调用父类的成员方法
s1.xy="广东海洋大学"; //访问本类的成员变量
s1.xi="计算机系"; //访问本类的成员变量
s1.print();
System.out.print(s1.xm+", "+s1.xy+", "+s1.xi);
}
}
(4) 编译并运行,结果如图所示。
图 3.7
6.3 了解成员方法的覆盖方式
通过继承子类可以继承父类中所有可以被子类访问的成员方法,但如果子类的方法与父类方法同名,则不能继承,此时称子类的方法覆盖了父类的方法,简称为方法覆盖(override)。方法覆盖为子类提供了修改父类成员方法的能力。例如,子类可以修改层层继承下来的Object 根类的toString 方法,让它输出一些更有用的信息。下面的程序显示了在子类Circle 中添加toString 方法,用来返回圆半径和圆面积信息。
(1) 编写覆盖Object 类toString方法的程序文件EXP3_9.java,源代码如下。
class Circle {
private int radius;
Circle(int r) {
setRadius(r);
}
public void setRadius(int r) {
radius=r;
}
public int getRadius() {
return radius;
}
public double area() {
return 3.14159*radius*radius;
}
public String toString() {
return "圆半径:"+getRadius()+" 圆面积:"+area();
}
}
public class EXP3_9{
public static void main(String args[]) {
Circle c=new Circle(10);
System.out.println("\n"+c.toString());
}
(2) }编译并运行,结果如图所示。
6.4 this、super和super()的使用
(1) 程序功能:程序功能:说明this、super 和super()的用法。程序首先定义Point(点)类,然后创建点的子类Line(线)。最后通过LX3_10 类输出线段的长度。程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。在子类Line 的setLine方法中,因为参数名和成员变量名相同,为给成员变量赋值,使用this 引用,告诉编译器是为当前类的成员变量赋值。在length 和toString 方法中使用父类成员变量时,使用super 引用,告诉编译器使用的是父类的成员变量。
(2) 程序源代码如下。
class Point {
protected int x, y;
Point(int a, int b) {
setPoint(a, b);
}
public void setPoint(int a, int b) {
x=a;
y=b;
}
}
class Line extends Point {
protected int x, y;
Line(int a, int b) {
super(a, b);
setLine(a, b);
}
public void setLine(int x, int y) {
this.x=x+x;
this.y=y+y;
}
public double length() {
int x1=super.x, y1=super.y, x2=this.x, y2=this.y;
return Math.sqrt((x2-x1) * (x2-x1) + (y2-y1) * (y2-y1));
}
public String toString() {
return "直线端点:[" + super.x + "," + super.y + "] [" +
x + "," + y + "] 直线长度:" + this.length();
}
}
public class EXP3_10{
public static void main(String args[]) {
Line line=new Line(50, 50);
System.out.println("\n"+line.toString());
}
}
(3) 编译并运行,结果如图。
7、 类的多态性练习
类的继承发生在多个类之间,而类的多态只发生在同一个类上。在一个类中,可以定义多个同名的方法,只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁,为程序员带来很大便利。在OOP 中,当程序要实现多个相近的功能时,就给相应的方法起一个共同的名字,用不同的参数代表不同的功能。这样,在使用方法时不论传递什么参数,只要能被程序识别就可以得到确定的结果。类的多态性体现在方法的重载(overload)上,包括成员方法和构造方法的重载。
7.1、方法的重载
(1) 程序功能:使用同名方法对两个、三个或用数组容纳的一组数进行排序
(2) 程序源代码如下。
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<b) {
swap=a;
a=b;
b=swap;
}
if (a<c) {
swap=a;
a=c;
c=swap;
}
if (b<c) {
swap=b;
b=c;
c=swap;
}
return a+" "+b+" "+c;
}
public String sort(int arr[]) {
String s=" ";
int swap;
for (int i=0; i<arr.length; i++)
for (int j=0; j<arr.length-1; j++)
if (arr[j]>arr[j+1]) {
swap=arr[j];
arr[j]=arr[j+1];
arr[j+1]=swap;
}
for (int i=0; i<arr.length; i++)
s=s+arr[i]+" ";
return s;
}
}
public class EXP3_11 {
public static void main(String[] args){
IntSort s=new IntSort();
int a=30, b=12, c=40;
int arr[]={34,8,12,67,44,98,52,23,16,16};
System.out.println("两个数的排序结果:"+s.sort(a,b));
System.out.println ("三个数的排序结果:"+s.sort(a,b,c));
System.out.println ("数组的排序结果:"+s.sort(arr));
}
}
(3) 编译并运行,结果如图所示。
7.2、构造函数的重载
构造方法的名称和类同名,没有返回类型。尽管构造方法看起来和一般的成员方法没有差别,但它不是方法,也不是类的成员。因此,构造方法不能直接调用,只能由new 操作符调用。构造方法对于类是十分重要的,对象的初始化任务要靠构造方法来完成。重载构造方法的目的是提供多种初始化对象的能力,使程序员可以根据实际需要选用合适的构造方法来初始化对象。
(1) 程序源代码如下。
class RunDemo {
private String userName, password;
RunDemo() {
System.out.println("全部为空!");
}
RunDemo(String name) {
userName=name;
}
RunDemo(String name, String pwd) {
this(name);
password=pwd;
check();
}
void check() {
String s=null;
if (userName!=null)
s="用户名:"+userName;
else
s="用户名不能为空!";
if (password!="12345678")
s=s+" 口令无效!";
else
s=s+" 口令:********";
System.out.println(s);
}
}
public class EXP3_12 {
public static void main(String[] args) {
new RunDemo();
new RunDemo("张三");
new RunDemo(null,"李四");
new RunDemo("王五","12345678");
}
(2) }编译并运行,结果如图所示。
8、 使用接口技术
(1) 程序功能:在程序中声明一个自定义接口NL,用来计算一个人年龄。
(2) 程序源代码如下。
interface NL{ //定义接口
int year = 2020;
int age();
void output();
}
public class EXP3_13 implements NL{ //实现接口
String xm; //类自己的成员变量(姓名)
int csrq; //类自己的成员变量(出生日期)
public EXP3_13(String n1,int y){ //类构造方法
xm = n1;
csrq = y;
}
public int age(){ //实现接口的方法
return year - csrq; //这里直接使用了接口中的常量year
}
public void output() { //实现接口的方法
System.out.println(this.xm +"今年的年龄是"+ this.age()+"岁");
}
public static void main (String args[]) //类自己的成员方法
{
NL a = new EXP3_13("张三",2001);
a.output();
}
}
(3) 编译并运行,结果如图。