JAVA实验二类的创建及封装

实验 二

实验名称：类的创建及封装
实验室名称：902	实验台号：901
学生姓名：	专业班级：2014级2班
指导教师：	实验日期： 2016-03-31

一、 实验目的
1．掌握类的声明和创建，掌握构造方法的定义和使用。

2．掌握成员变量和方法的定义和调用。

3．掌握对象的创建、实例或类成员变量和方法的引用。

4．掌握包的使用和导入，掌握Import语句的使用。

5．掌握访问权限的作用范围。
二、实验仪器及环境：
PC计算机；windows7操作系统、JDK1.6和Eclipse开发工具

三、实验内容及结果

1.创建一个求立方体体积的类，类中有3个成员变量，共两个功能方法，一个为setDemo(int x,int y,int z)给长宽高赋值，另一个为实现求体积的功能，编写另外一个类，类中有主方法求给定长宽高的立方体的体积，结果显示在屏幕上。将上题的方法setDemo改用构造函数实现初始化。

输入：输入数据有多组，每组3个数值，分别表示立方体的长宽高。
输出：对应输入数值所求得的体积。

源代码：

Lifangti.java
packagecn.edu.nefu.zhihu;

public classLifangti {
double length,whith,high;
void setDemo(double a,double b,double c){
length=a;
whith=b;
high=c;
}
double tiji(){
return length*whith*high;
}
}

test1.java
packagecn.edu.nefu.zhihu;

importjava.util.Scanner;

public class test{

public static void main(String[] args) {
double a,b,c;
Lifangti lifang=new Lifangti();
Scanner reader=new Scanner(System.in);
while(reader.hasNextDouble()){
a=reader.nextDouble();
b=reader.nextDouble();
c=reader.nextDouble();
lifang.setDemo(a,b,c);
System.out.println(lifang.tiji());
}
}
}

测试结果：
第一组：输入：1 2 3 输出：6
第二组：输入：2 3 5 输出：30

2．定义一个学生类(Student)及它的属性和方法；定义主类和main()，在main()方法中创建学生对象,并通过对象调用它的方法setName(),getName()，输出学生的名字name和年龄age。

输出：按照要求输出。

源代码：

Student.java
packagecn.edu.nefu.zhihu;

public classStudent {
String name;
int age;
void setName(String name){
this.name=name;
}
String getName(){
return name;
}
void setAge(int age){
this.age=age;
}
int getAge(){
return age;
}
}

test1.java
packagecn.edu.nefu.zhihu;

public class test1{

public static void main(String[] args) {
Student s=new Student();
s.setName("Pang Zhennan");
s.setAge(19);
System.out.println(s.getName());
System.out.println(s.getAge());
}
}

测试结果：输出：Pang Zhennan 19

3. 定义类Point及它的属性、方法和构造函数，定义主类和main()，在main()方法中创建两个坐标对象，,并通过对象调用getMiddle方法后得到一个新的点坐标，调用show（）显示该对象的坐标值。

源代码：

Point.java
packagecn.edu.nefu.zhihu;

public class Point{
double x,y;
Point(double x,double y){
this.x=x;
this.y=y;
}
void getMiddle(double x1,double y1,doublex2,double y2){
x=(x1+x2)/2;
y=(y1+y2)/2;
}
void show(){
System.out.println(x+" "+y);
}

}
test2.java
packagecn.edu.nefu.zhihu;

public class test2{

public static void main(String[] args) {
Point p1,p2,p3;
p1=new Point(0,0);
p2=new Point(1,1);
p3=new Point(0,0);
p3.getMiddle(p1.x,p1.y,p2.x,p2.y);
p3.show();
}
}

另一种方法：
Point.java
packagecn.edu.nefu.zhihu;

public class Point{
double x,y;
Point(double x,double y){
this.x=x;
this.y=y;
}
Point getMiddle(double x1,double y1,doublex2,double y2){
x1=(x1+x2)/2;
y1=(y1+y2)/2;
Point p=new Point(x1,y1);
return p;
}
void show(){
System.out.println(x+" "+y);
}

}

test2.java
packagecn.edu.nefu.zhihu;

public class test2{

public static void main(String[] args) {
Point p1,p2,p3;
p1=new Point(0,0);
p2=new Point(1,1);
p3=new Point(0,0);
p3=p3.getMiddle(p1.x,p1.y,p2.x,p2.y);
p3.show();
}
}

测试结果：0.5 0.5

4.定义一个复数(z=x+iy)类Complex，及它的属性、方法和构造函数；定义主类和main()方法，在main()方法中创建两个复数类Complex对象，并通过复数类对象调用它们的属性和方法，输出方法执行结果。

输出：两个复数求和后所得到的复数。

源代码：

Complex.java
package cn.edu.nefu.zhihu;
public class Complex {
int x,y;
Complex(){
}
Complex(int x,int y){
this.x=x;
this.y=y;
}
static Complex add(int x1, int y1, int x2, int y2){
Complex c=new Complex();
c.x=x1+x2;
c.y=y1+y2;
return c;
}
void show(){
System.out.println("z="+x+"+i*"+y);
}
}

Test4.java
package cn.edu.nefu.zhihu;
public class test4 {
public static void main(String[] args) {
Complex c1,c2;
c1=new Complex(1,1);
c2=new Complex(2,3);
c1=Complex.add(c1.x, c1.y, c2.x, c2.y);
c1.show();
}
}

测试结果：z=3+i*4

5．编写一个类Add，该类在tom.jiafei包中，该类完成的功能是可以计算等差数列的和，在另外一个类中使用import引入Add类，并创建Add类的对象，求出给定等差数列的和。（此题考察的是package和import语句的使用）

输出：按照提前给定的数组首项、公比和项数n求出数列的前n项和。

源代码：

tom.jiafei.Add.java
package tom.jiafei;

public class Add {
int a1,d,n;
Add(){
}
public Add(int a1,int d,int n){
this.a1=a1;
this.d=d;
this.n=n;
}
public long getSum(){
return n*a1+(n-1)*n/2*d;
}
}
Test5.java
package cn.edu.nefu.zhihu;
import tom.jiafei.Add;
public class test5 {
public static void main(String[] args) {
Add shulie=new Add(1,1,3);
System.out.println(shulie.getSum());
}
}

测试结果：6

6．编写两个类：A和B，A创建的对象可以计算两个正整数的最大公约数，B创建的对象可以计算两个数的最小公倍数。要求：B类中有一个成员变量是用A类声明对象。
输出：预先设定好的两个数的最大公约数和最小公倍数。

源代码：

A.java
package cn.edu.nefu.zhihu;
public class A {
int a,b;
A(){
}
A(int a,int b){
this.a=a;
this.b=b;
}
int gcd(int x,int y){
if(y==0)
return x;
else return gcd(y,x%y);
}
}

B.java
package cn.edu.nefu.zhihu;
public class B {
A a=new A();
B(){
}
int lcm(int x,int y){
return x*y/a.gcd(x, y);
}
}

test6.java
package cn.edu.nefu.zhihu;
public class test6 {
public static void main(String[] args) {
A a=new A(4,6);
B b=new B();
System.out.println(a.gcd(4, 6));
System.out.println(b.lcm(4, 6));
}
}

测试结果：2 12

7.构造一个类来描述屏幕上的一个点，该类的构成包括点的x和y两个坐标，以及一些对点进行的操作，包括：取得点的坐标值，对点的坐标进行赋值，编写应用程序生成该类的对象并对其进行操作。

源代码：

Point1.java
package cn.edu.nefu.zhihu;

public class Point1 {
double x,y;
Point1(){

}
Point1(double x,double y){
this.x=x;
this.y=y;
}
void setPoint(double x,double y){
this.x=x;
this.y=y;
}
void getPoint(){
System.out.println(x+" "+y);
}
void down(){
y=y-1;
}
void up(){
y=y+1;
}
}
testt3.java
package cn.edu.nefu.zhihu;

public class testt3 {

public static void main(String[] args) {
Point1 p=new Point1(2,3);
p.setPoint(4, 5);
p.down();
p.getPoint();
p.up();
p.getPoint();
p.up();
p.getPoint();
}
}

8.编写实现:有一个三角形类Triangle，成员变量有底边x和另一条边y，和两边的夹角a（0<a<180），a为静态成员，成员方法有两个：求面积s（无参数）和修改角度（参数为角度）。

源代码：

package cn.edu.nefu.zhihu;

public class Triangle {
double x,y;
static double a;
double area(){
return x*y*Math.sin(a);
}
void setA(double a){
this.a=a;
}
}

9.编写实现: 构造函数为 Triangle(int xx,int yy,int aa) 参数分别为x,y,a赋值 在main方法中构造两个对象，求出其面积，然后使用修改角度的方法，修改两边的夹角，再求出面积值。(提示：求高的方法 h=y*Math.sin(a) )

注意：构造方法用于对成员变量初始化，无参数的构造方法将成员变量初始化为0值

源代码：

Test8.java
package cn.edu.nefu.zhihu;

public class test8 {

public static void main(String[] args) {
Triangle sjx1=new Triangle(2,4,3.14*30/180); //Math.sin(a)传递的参数为以弧度表示的角
System.out.println(sjx1.area());
Triangle sjx2=new Triangle(6,4,3.14*30/180);
System.out.println(sjx2.area());
sjx1.setA(3.14*90/180);
System.out.println(sjx1.area());
//System.out.println(Math.sin(1.28));
}
}

10.

定义一个类实现银行帐户的概念，包括的变量有"帐号"和"存款余额"，包括的方法有"存款"、"取款"和"查询余额"。定义主类，创建帐户类的对象，并完成相应操作。

提示：关键代码如下：

public int getleftmoney(){

return leftmoney;

}

public void savemoney(double money){

leftmoney+=money;

}

public void getmoney(double money){

if(money<=leftmoney)

leftmoney-=money;

else

System.out.println("只能取："+leftmoney);

}

…

bankaccount ba=new bankaccount(123456,1000);

ba.savemoney(2000);

System.out.println("存入2000元后余额为："+ba.getleftmoney());

ba.getmoney(1500);

System.out.println("1500元后余额为："+ba.getleftmoney());

代码实现：

Bankaccount.java
package cn.edu.nefu.zhihu;
public class Bankaccount {
int sno;
double leftmoney;
Bankaccount(){
}
Bankaccount(int sno,double leftmoney){
this.sno=sno;
this.leftmoney=leftmoney;
}
public double getleftmoney(){
return leftmoney;
}
public void savemoney(double money){
leftmoney+=money;
}
public void getmoney(double money){
if(money<=leftmoney)
leftmoney-=money;
else
System.out.println("只能取："+leftmoney);
}
}
Test.java
package cn.edu.nefu.zhihu;
public class Test1 {
public static void main(String[] args) {
Bankaccount ba=new Bankaccount(123456,1000);
ba.savemoney(2000);
System.out.println("存入2000元后余额为："+ba.getleftmoney());
ba.getmoney(1500);
System.out.println("1500元后余额为："+ba.getleftmoney());
}
}

四、实验心得体会：

实验心得和体会：

通过做实验，我发现我对类的封装还是理解的不够透彻，有点时候会想错，或者想不到更好的方法去封装一个类，如在封装一个点的类时，要想求得两个点的中点坐标，需要用一个成员方法来实现，而在调用时，要通过对象去调用。后来又想了想，也可以把该方法定义成静态的，然后可以直接通过类名就可以去访问了。

一些总结：

构造方法没有返回参数，且名称要和类名相同，在对象被创建时执行，被对象调用。

一个方法或一个块内定义的变量不可以在方法外或块外使用，这种变量称为局部变量。如果方法中的参数的名字和成员变量的名字相同，可以用this.关键字加以区分。

同名的不同方法共存的情况称为方法的重载，可以根据方法参数个数和参数类型的不同加以区分。

类方法和实例方法的不同：类方法可以通过类名和对象名进行访问，而实例方法只能通过对象名进行访问。

五、指导教师意见及成绩