【开发语言及实现平台或实验环境】
Windows2000 或XP，JDK1.5以上版本与Eclipse集成开发环境
【实验目的】
理解Java语言是如何体现面向对象编程基本思想，
了解类的封装方法，以及如何创建类和对象.
了解成员变量和成员方法的特性。
掌握OOP方式进行程序设计的方法
了解类的继承性和多态性的作用。
了解Java 中包（package）、接口（interface）的作用。
掌握包、接口的使用方法。
【实验任务】
编写一个体现面向对象思想的程序。
编写一个创建对象和使用对象的方法程序。
编写不同成员变量修饰方法的程序。
编写不同成员方法修饰的程序。
编写体现类的继承性（成员变量，成员方法，成员变量隐藏）的程序。
编写体现类多态性（成员方法重载，构造方法重载）的程序。
了解Java 系统包的结构。
掌握创建自定义包的方法。
掌握使用系统接口的技术和创建自定义接口的方法。
【实验内容或实验步骤】
1．程序功能：通过两个类StaticDemo、LX3_4 说明静态变量/方法与实例变量/方法的区别。
2．编写类文件LX3_4.java，程序源代码如下。
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;
}
}
public class LX3_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);
a.setY(2);
b.setX(3);
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．对上面的源程序进行编译，会出现如图3.4 所示的出错提示。
4．将源程序中的出错语句删除或使用解释符//隐藏起来，例如，
//System.out.println("实例变量y="+StaticDemo.getY());
5．重新编译并运行该程序，结果如图3.5 所示。
static 声明的成员变量/方法被视为类的成员变量/方法，而不把它当作实例对象的成员变量/方法。换句话说，静态变量/方法是类固有的，可以直接引用，其它成员变量/方法仅仅被声明，生成实例对象后才存在，才可以被引用。基于这样的事实，也把静态变量/方法称为类变量/方法，非静态变量称为实例变量/方法。
从实验结果可以得出以下几点结论：
·类的静态变量可以直接引用，而非静态变量则不行。类的静态变量相当于某些程序语言的全局变量。
·静态方法只能使用静态变量，不能使用实例变量。因为对象实例化之前，实例变量不可用。
·类的静态变量只有一个版本，所有实例对象引用的都是同一个版本。
·对象实例化后，每个实例变量都被制作了一个副本，它们之间互不影响。
（四） 方法中参数传递的练习
在其它语言中，函数调用或过程调用时参数有传值调用和传地址调用之分。在Java 中，方法中的参数传递可以分为传值调用或对象方法调用等方式。传值调用即传递的参数是基本数据类型，调用方法时在方法中将不能改变参数的值，这意味着只能使用它们。对象调用是指先调用对象，再调用对象的方法，这种方式可以修改允许存取的成员变量。所以，如果不想改变参数的值，可以采用传值调用的方法。如果想改变参数的值，可采用对象调用的方法，间接修改参数的值。
1.编写一个传值调用的程序文件LX3_5.java。
（1）程序功能：程序首先给整型变量x 和y 赋一个初值10，然后使用传值调用方式调用方法ff1对x 和y 做乘方及输出x 和y 的乘方值，最后再输出x 和y 的乘方值。
（2）程序源代码如下。
class LX3_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）编译LX3_5.java，其运行结果如图3.6 所示。
（4）分析其运行结果
这个程序没有实现预期的结果，原因是ff1 方法采用了传值调用。调用ff1 方法时，将产生两个参数passX 和passY，x 和y 的值被传递给这两个参数。尽管在方法中计算了参数的平方，但从ff1方法返回后，参数消失，此时x 和y 的值仍是初值。
2．编写一个调用对象方法的程序文件LX3_6.java。
（1）程序功能：通过调用对象的方法在方法调用后修改了成员变量的值。
（2）LX3_6.java 程序源代码如下。
class LX3_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);
}
}
（3）编译LX3_6.java，其运行结果如图3.7 所示。
（五） 类的继承性练习
1． 进一步理解继承的含义
新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。
2． 创建公共类LX3_7_P
（1）编写程序文件LX3_7_P.java，源代码如下。
public class LX3_7_P
{
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）编译LX3_7_P.java，产生类文件LX3_7_P.class。
3．创建继承的类
（1）程序功能：通过LX3_7_P 类产生子类LX3_8，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。
（2）编写LX3_8.java 程序，源代码如下。
class LX3_8 extends LX3_7_P{
protected String xy;
protected String xi;
public static void main(String args[])
{
LX3_7_P p1 = new LX3_7_P();
p1.setdata("帅零",12321) ;
p1.print();
LX3_8 s1 = new LX3_8() ;
s1.setdata("郭丽娜",12345); //调用父类的成员方法
s1.xy="经济管理学院"; //访问本类的成员变量
s1.xi="信息管理系"; //访问本类的成员变量
s1.print();
System.out.print(s1.xm+", "+s1.xy+", "+s1.xi);
}
}
（3）编译并运行程序，其结果如图3.8 所示。
3．了解成员变量的隐藏方式
所谓隐藏是指子类重新定义了父类中的同名变量，在子类Line 中重新定义了x 为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。
4．了解成员方法的覆盖方式
（1）方法覆盖的定义与作用
通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。例如，子类可以修改层层继承下来的Object 根类的toString 方法，让它输出一些更有用的信息。下面的程序显示了在子类Circle 中添加toString 方法，用来返回圆半径和圆面积信息。
（2）编写覆盖Object 类toString 方法的程序文件LX3_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 LX3_9{
public static void main(String args[]) {
Circle c=new Circle(10);
System.out.println(""n"+c.toString());
}
}
（3）编译并运行程序，其结果如图3.9 所示
（4）程序结构分析。
程序添加了toString 方法并修改了它的返回值。由于toString 和继承下来的Object 类的方法名相同、返回值类型相同，因此覆盖了超类Object 中的toString 方法。
方法覆盖时要特别注意：
用来覆盖的子类方法应和被覆盖的父类方法保持同名、相同的返回值类型，以及相同的参数个数和参数类型。
5．This、super 和super()的使用
（1）程序功能：说明this、super 和super()的用法。程序首先定义Point（点）类，然后创建点的子类Line（线）。最后通过LX3_10 类输出线段的长度。
程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。在子类Line 的setLine方法中，因为参数名和成员变量名相同，为给成员变量赋值，使用this 引用，告诉编译器是为当前类的成员变量赋值。在length 和toString 方法中使用父类成员变量时，使用super 引用，告诉编译器使用的是父类的成员变量。
（2）使用this、 super 和super()的程序文件LX3_10.java，源代码如下。
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 LX3_10{
public static void main(String args[]) {
Line line=new Line(50, 50);
System.out.println(""n"+line.toString());
}
}
（3）编译并运行程序，结果如图3.10 所示。
六 类的多态性练习
1． 理解类的多态性
类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。
多态使程序简洁，为程序员带来很大便利。在OOP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。
类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。
2． 方法的重载
方法的重载是指对同名方法的不同使用方式。
（1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort，
（2）编写LX3_11.java 文件，源代码如下（自己编写程序代码）。
3．构造方法的重载
构造方法的名称和类同名，没有返回类型。尽管构造方法看起来和一般的成员方法没有差别，但它不是方法，也不是类的成员。因此，构造方法不能直接调用，只能由new 操作符调用。
构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。
重载构造方法的目的是提供多种初始化对象的能力，使程序员可以根据实际需要选用合适的构造方法来初始化对象。
（1） 编写构造方法RunDemo 的重载程序文件LX3_12，源代码如下。
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 LX3_12 {
public static void main(String[] args) {
new RunDemo();
new RunDemo("刘新宇");
new RunDemo(null,"邵丽萍");
new RunDemo("张驰","12345678");
}
}
（2）编译并运行程序，结果如图3.12 所示。
（3）三个构造方法，其中
第一个无参构造方法RunDemo() 的实际作用是对成员变量赋缺省初值，由于userName和password都是String 类，所以它们的缺省初值为null。
第二个构造方法RunDemo(String) 只有一个参数，用来对成员变量userName 赋初值。
第三个构造方法RunDemo(String, String) 有两个参数，并有更多的内容，首先调用this(name)，其实际作用就是调用当前类的构造方法RunDemo(String name)；然后对成员变量password 赋值；最后调用check 方法来检查userName 和password，类似于一般程序的口令验证。重载构造方法的执行由对象根据实际参数的个数、类型和顺序确定。
【思考】
2．程序的结构。类与对象的关系。对象创建、使用、销毁的过程。
3. 方法的参数传递有哪些方式？区别时什么？
4. 说明什么是构造方法。
5. 说明程序中有多个类时如何确定源程序文件的名称。
6. 说明类的继承和多态有什么作用，在使用上应该注意什么问题。