java实验一 类和对象实验

实验一 类和对象实验
一、实验学时
4学时
二、实验目的
（一）掌握类和对象的关系；
（二）掌握如何定义使用一个对象的类并将其应用于程序设计中；
（三）掌握java语言的面向对象的程序设计方法。
三、预习要求
熟悉java程序的书写规则、上机调试步骤；熟悉类与对象之间的关系，面向对象编程的三大重要特性等内容。
四、实验内容
（一）分析和完善下面程序并打印输出结果，掌握类与对象的创建方法。
package sample;
public class StringTest{
private String s;
public void printString(){
System.out.println(s);
}

public void changeString(String str){
    s = str;
}

public static void main(String[] args){
   StringTest st = new StringTest()              
   st.changeString("Hello SZTU");
   st.printString();
} 

}

使用JDK的javac和java命令手动地编译和运行上面程序
使用Eclipse 编译和运行上面程序


（二）分析下面程序并打印输出结果，掌握继承关系和构造方法的调用。
package sample;
public class UseConstruct
{
public static void main(String[] args)
{ Manager m = new Manager(“李力”,6000,“学生院”);//初始化赋值
System.out.println(m.getSalary());
}
}
class Employee
{ private String name;//名字
private int salary;//薪水
//构造函数
public Employee(String _name, int _salary)
{ name = _name;
salary = _salary;
}
public String getSalary()
{
String str;
str = "名字: " + name + "\nSalary: " + salary;
return str;
}
}
class Manager extends Employee
{
private String department;

//构造函数
public Manager(String _name, int _salary, String _department)
{
super(_name,_salary);
department = _department;
}
public String getSalary()
{
return super.getSalary() + "\nDepartment: " + department;
}
}

（三）分析下面程序并打印输出结果，掌握类的封装特性。
package sample;
class EncapTest {
int a; // 默认存取控制（default access）
public int b; //公有存取控制（public access）
private int c; //私有存取控制（private access）
// 访问c的方法
void setc(int i) {//设定c的值
c = i;
}
int getc() { //获得c的值
return c;
}
}

public class AccessTest {
public static void main(String args[]) {
EncapTest ob = new EncapTest();
// 以下代码是正确的
ob.a = 10;
ob.b = 20;
// 以下代码会产生错误
// ob.c = 30;
// 我们必须通过公有的方法操作c
ob.setc(30); // 正确
System.out.println("a，b，and c: " + ob.a + " " +ob.b + " " + ob.getc());
}
}
理解public和private对访问的作用，尝试将程序// ob.c = 30;开头的注释符号去掉，看看能否编译这个程序，进一步掌握封装的含义。

将// ob.c = 30;开头的注释符号去掉后得到结果：

证明私有对象不能被其他类直接改变
（四）分析下面程序并打印输出结果，掌握类的继承特性和方法重写。
package sample;
public class TestExtend extends Employee
{
public static void main(String[] args)
{
System.out.println(“覆盖的方法调用：” + getSalary(“王一”,500));
System.out.println(“继承的方法调用：” + getSalary2(“王一”,500));
System.out.println(“覆盖的方法调用：” + getSalary(“王飞”,10000));
System.out.println(“继承的方法调用：” + getSalary2(“王飞",10000));
}
public static String getSalary(String name, int salary)
{
String str;
if (salary>5000)
str = "名字: " + name + " Salary: " + salary;
else
str = “名字: " + name + " Salary: 低于5000”;
return str;
}
};
class Employee
{
public String name;//名字
public int salary;//薪水
public static String getSalary(String name, int salary)
{
String str;
str = "名字: " + name + " Salary: " + salary;
return str;
}
public static String getSalary2(String name, int salary)
{
String str;
str = "名字: " + name + " Salary: " + salary;
return str;
}
}

如果能满足以下条件，那么我们就说子类中的方法重写了超类中的方法。
方法名、参数列表和返回值完全相同；
访问控制范围（public, protected, private, default）不能被缩小；
抛出的异常不能被扩大。
方法重写允许通用类指定方法，这些方法对该类的所有派生类都是公有的，同时该方法允许子类定义这些方法中的某些或全部的特殊实现。也就是说，方法重写能够帮助Java实现它的多态性。

（五）分析和完善下面程序并打印输出结果，掌握类的多态特性。
package sample;
public class ShapeTest {

public ShapeTest() {
}

public static void main(String[] args) {
Shape[] s={new Shape(1,4),
new Rectangle(1,2,3,4),
new Circle(2,3,5)};
for(int i=0; i<s.length; i++)
{
s[i].draw();
}
}

}

class Shape{
protected int x;
protected int y;

public Shape(){ }
public Shape(int x, int y){
this.x = x;
this.y = y;
}
public void draw(){System.out.println(“This is a test in Shape.”);}

}

class Rectangle extends Shape{
private int heigth;
private int weight;

public Rectangle(int x, int y, int w, int h){
super(x,y);
this.weight = w;
this.heigth = h;

}
public void draw(){System.out.println(“This is a test in Rectangle.”);}
}

class Circle extends Shape{
private int r;

public Circle(int x, int y, int r){
super(x,y);
this.r = r;

}
public void draw(){System.out.println(“This is a test in Circle.”);}

}
多态是指一个方法只能有一个名称,但可以有许多形态,也就是程序中可以定义多个同名的方法，用“一个接口，多个方法”来描述，可以通过方法的参数和类型引用实现。
 多态性使指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

（六）编写Track类、Duration类 和Driver类。其中，Duration类包含三个属性：小时、分钟和秒，以及两个重载的构造方法；Track类包含两个属性：名称和长度（它是Duration对象类型），以及get/set方法；Driver类包含一个主方法，用来设定Track的长度和名称，然后把它们的值打印出来。
package sample;
//六）编写Track类、Duration类 和Driver类。其中，Duration类包含三个属性：小时、分钟和秒，以及两个重载的构造方法；
//Track类包含两个属性：名称和长度（它是Duration对象类型），以及get/set方法；
//Driver类包含一个主方法，用来设定Track的长度和名称，然后把它们的值打印出来。
public class Driver {
public String name;
public int Length;
public static void main(String[] args) {
String str=“track”;
Track st=new Track();
st.set(str,2);
System.out.println("The name is “+st.getName()+”, the length is "+st.getLength());
}

}
class Duration{
private int hour,minus,seconds;
public Duration(int h,int m,int s) {
hour=h;
minus=m;
seconds=s;
}
public Duration() {
hour=0;
minus=0;
seconds=0;
}
};
class Track extends Duration{
private String name;
private int length;
public void set(String n,int l) {
name=n;
length=l;
}
public String getName() {
return name;
}
public int getLength() {
return length;
}
}

五、实验注意事项
（一）在Java中，所有的类对象都必须动态分配。其中new 运算符为对象动态分配内存空间，并返回对它的一个引用。
（二）Java中的每个类都有构造方法，用来初始化该类的一个新对象。当创建对象时，由new运算符自动调用。但是特别要注意的是，如果程序中已经定义了构造方法，Java就不会再生成默认构造方法了。
（三）成员声明语句必须以访问指示符开头。
（四）Java中不支持类之间的多重继承，即不允许一个子类继承多个父类。

六、思考题
（一）面向对象编程有哪3个基本概念？简单描述每一个。
封装：代码及待处理数据绑定在一起，防止被外界干扰且不被误用。
继承：一个对象获得另一个对象属性的过程。
多态：允许一个接口被多个同类动作使用的特征。

（二）什么是类？什么是对象？类和对象有什么关系？
类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

面向对象程序设计的重点是类的设计，设计类就是设计类的成员。
二者的关系：对象，是由类new出来的，派生出来的。

（三）1．假设有以下类：
public class Test1{
public float aMethod(float a, float b){ }
}
以下哪些方法可以合理地加入在第3行之前（多选）？（A、C、E）
A．public int aMethod(int a, int b){ }
B．public float aMethod(float a, float b){ }
C．public float aMethod(float a, float b, int c) throws Exception{ }
D．public float aMethod(float c, float d){}
E．private float aMethod(int a, int b, int c) { }
（四）什么是继承?继承的特性可给面向对象编程带来什么好处?
继承：
所谓继承就是保持已有类的特性而构造新类的过程。继承是子类利用父类中定义的方法和变量，就像它们属于子类本身一样。特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。例如：如汽车与小汽车；教育工作者与教师。当一个类拥有另一个类的所有数据和操作时，就称这两个类之间存在着继承关系。

带来的好处
减少了代码的冗余，提高了代码的复用性
便于功能的扩展
为之后多态性的使用，提供了前提

（五）Java是否支持类之间的多重继承？
Java并不支持类之间的多重继承，即不允许一个子类继承多个父类。

（六）什么是多态？什么是RTTI？.

1. 多态性的理解：
   可以理解为一个事物的多种形态。比如数据库的连接方式，我们定义好了数据库的连接，也规定了连接时的步骤，但是我们并不知道用户会采用什么数据库，在没有多态以前我们只能针对不同的数据库写不同的连接方法，而有了多态以后我们只需要定义好数据库的类并书写好连接方法，让所有的数据库继承数据库类并重写数据库连接方法。
   这样我们在调用的时候只需要通过声明数据库类并指向数据库的子类的方式，**（即数据库类的引用指向继承了数据库类的具体实现类的对象）**就可以进行数据库连接。而不是需要针对不同的数据库书写不同的连接方式。
2. 何为多态性：
   对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
   编译时和运行时类型不一致，产生了多态
   3.RTTI
   即Run-Time Type Identification。通过运行时类型识别，程序能够使用基类的指针或引用来检查着这些指针或引用所指的对象的实际派生类型。