java实验二：类与对象

一、学生信息处理

根据下面要求，编写一个Java应用程序：
①定义类StuCard，用到类成员变量(人数)和实例成员变量：学号、姓名、性别、专业、年级、籍贯等；
②初始化的时候用到构造方法，提供两个以上构造方法；
③多个类（业务类StuCard和测试主类），用到包的概念，且分别放到不同的包中；
④用到类成员访问权限，要求类成员变量为Public，实例成员变量为Private；
⑤编写所有数据成员的访问器和修改器（共有的get和set方法）；
⑥在主类中实现对业务类StuCard的读、写、修改属性等功能。
在完成以上功能要求的情况下，可以进一步扩展。

理解：
1.使用 import 语句调用包中的类。
2.访问器和修改器。
即get( )和set( )方法，又称为访问器和修改器。是Java中经常使用的一种机制。
为什么要使用？
以此题为例，学生姓名、学号、性别等属性是StuCard类的私有变量（private修饰），在其他类是不能访问的。但是我们又希望在其他类可以访问它们，并可以更改部分属性值，这时就用到修改器方法和访问器方法。
– 实现了对私有成员变量的保护，同时又提供了访问方法。

package package1;

public class StuCard {
    //类成员变量:学生人数
	//实例成员变量：学号、姓名、性别、专业、年级、籍贯
	public static int StuNumber;
	private String name;
	private String PersonalNnumber;
	private String sex;
	private String Grade;
	private String major;
	private String address;
   

	//构造函数1：初始化姓名学号
    public StuCard(String b,String c){
    	name=b;
    	PersonalNnumber=c;
    }
   
    //构造函数2：初始化全部信息
    public StuCard(int a,String b,String c,String g,String f,String d,String e){
    	StuNumber=a;
    	name=b;
    	PersonalNnumber=c;
    	sex=g;
    	Grade=f;
    	major=d;
    	address=e;
    }
   
    
    //访问器
    public int getStuNumber() {
		return StuNumber;
	}
    
    public String getname() {
		return name;
	}
    
    public String getsex() {
		return sex;
	}
    
    public String getPersonalNnumber() {
		return PersonalNnumber;
	}
    
    public String getGrade() {
		return Grade;
	}
    
    public String getmajor() {
  		return major;
  	}
    
    public String getaddress() {
  		return address;
  	}
	
    
    //修改器
    public void setStuNumber(int StuNumber) {
		this.StuNumber=StuNumber;
	}
    
    public void setname(String name) {
		this.name=name;
	}
    
    public void setsex(String sex) {
		this.sex=sex;
	}
    
    public void setPersonalNnumber(String PersonalNnumber) {
		this.PersonalNnumber=PersonalNnumber;
	}
    
    public void setGrade(String Grade) {
		this.Grade=Grade;
	}
    
    public void setmajor(String major) {
  		this.major=major;
  	}
    
    public void setaddress(String address) {
  		this.address=address;
  	}   
}

package package2;
import package1.StuCard;
public class Text {
	public static void main(String[] args) {

	   //创建对象stu1，赋初始值。
	   StuCard stu1=new StuCard(1,"jyn","123456","female","freshman","computer","shandong");
	   
	   //读取并输出：类StuCard的对象stu1的信息,
	   System.out.println("原始信息如下：");
	   System.out.println(stu1.getStuNumber());
	   System.out.println(stu1.getname());
	   System.out.println(stu1.getPersonalNnumber());
	   System.out.println(stu1.getsex());
	   System.out.println(stu1.getGrade());
	   System.out.println(stu1.getmajor());
	   System.out.println(stu1.getaddress());
	   
	   //修改stu1的属性
	   stu1.setname("zyz");
	   stu1.setPersonalNnumber("654321");
	   
	   //输出修改后信息
	   System.out.println("修改后信息如下：");
	   System.out.println(stu1.getname());
	   System.out.println(stu1.getPersonalNnumber());
	}
}

二、用类描述计算机中CPU的速度和硬盘的容量

用类描述计算机中CPU的速度和硬盘的容量。要求Java应用程序有4个类，名字分别是PC、CPU、HardDisk和Test，其中Test是主类。
PC类与CPU和HardDisk类关联的UML图如下：

其中，CPU类要求getSpeed()返回speed的值，要求setSpeed(int m)方法将参数m的值赋值给speed。HardDisk类要求getAmount()返回amount的值，要求setAmount(int m)方法将参数m的值赋值给amount。PC类要求setCPU(CPU c)将参数c的值赋值给cpu，要求setHardDisk(HardDisk h)方法将参数h的值赋值给HD，要求show()方法能显示cpu的速度和硬盘的容量。

主类Test的要求：
（1） main方法中创建一个CPU对象cpu，cpu将自己的speed设置为2200；
（2） main方法中创建一个HardDisk对象disk，disk将自己的amount设置为200；
（3） main方法中创建一个PC对象pc；
（4） pc调用setCPU(CPU c)方法，调用时实参是cpu；
（5） pc调用setHardDisk(HardDisk h)方法，调用时实参是disk;
（6） pc调用show()方法。

CPU类：

public class CPU {
      int speed;
      
      int getSpeed(){
    	  return speed;
      }
      
      void setSpeed(int m){
    	  this.speed=m;
      }
      
}

HardDisk类：

public class HardDisk {
     int amount;
     
     int getAmount(){
    	 return amount;
     }
     
     void setAmount(int m){
    	 this.amount=m;
     }
}

PC类：

public class PC {
     CPU cpu;
     HardDisk HD;
     
     public void setCPU(CPU c){
    	 this.cpu=c;
     }
     
     public void setHardDisk(HardDisk h){
    	 this.HD=h; 
     }
     
     public void show(){
    	 System.out.println("cpu的速度："+cpu.getSpeed());
    	 System.out.println("硬盘的容量："+HD.getAmount());
     }
}

Test类，测试主类：

public class Test {

	public static void main(String[] args){
		CPU cpu=new CPU(); //创建一个CPU对象cpu
		cpu.setSpeed(2200);//cpu将自己的speed设置为2200
		
		HardDisk disk=new HardDisk();//创建一个HardDisk对象disk
		disk.setAmount(200);//disk将自己的amount设置为200 
		
		PC pc=new PC(); //创建一个PC对象pc
		
		pc.setCPU(cpu);
		pc.setHardDisk(disk);
		pc.show();
		
	}
}

三、共饮同井水

编写程序模拟两个村庄公用同一口井水。编写一个Village类，该类有一个静态的成员变量waterAmount，用于模拟井水的水量；实例变量peopleNumber表示村庄的人数，实例变量name表示村庄的名称。定义相应的成员方法操作成员变量。在主类Land的main()方法中创建两个村庄，设置村庄的名称、人数，通过一个村庄改变waterAmount的值，另一个村庄查看该值的结果。

提示：类变量是该类所有对象的共享数据；一般通过类方法操作类变量。

Village类：

public class Village {
    public static int waterAmount; //井水的水量
    int peopleNumber; //村庄的人数
    String name; //村庄的名称
    
    Village(int n,String s){
    	peopleNumber=n;
    	name=s;
    }
    
    static void setwaterAmount(int m){
    	waterAmount=m;
    }
}

Land类：

public class Land {
	public static void main(String[] args){
	    Village village1=new Village(10,"village1");
	    Village village2=new Village(20,"village2");
	    
	    village1.setwaterAmount(210);
	    System.out.println(village2.waterAmount);
	
	}
}

四、正n边形

在一个正n边形中，所有边的长度都相同，且所有角的度数都相同（即这个多边形是等边等角的）。设计一个名为RegularPolygon的类，该类包括：
①一个名为n的int型私有数据成员表示多边形的边数；
②一个名为side的double型私有数据成员表示多边形的长度
③一个名为x的double型私有数据成员表示多边形中点的x坐标；
④一个名为y的double型私有数据成员表示多边形中点的y坐标；
⑤一个创建带默认值（n的默认值为3，side的默认值为1，x的默认值为0，y的默认值为0）的正多边形的无参构造方法；
⑥一个能创建带指定边数和边长度，中心在（0，0）的正多边形的构造方法；
⑦一个能创建带指定边数和边长度，中心在（x，y）的正多边形的构造方法；
⑧所有数据成员的访问器和修改器（共有的get和set方法）；
⑨一个返回多边形周长的方法getPerimeter()；
⑩一个返回多边形面积的方法getArea()，计算正多边形面积的公式是：
S = (n * side *side)/(4 * tan(π/n))

编写一个测试程序，分别使用无参构造方法、RegularPolygon(6, 4)和RegularPolygon(10, 4, 5.6, 7.8)创建三个RegularPolygon对象，输出每个对象的周长和面积。

RegularPolygon类：

import java.lang.Math;

public class RegularPolygon {
     private int n; //多边形的边数
     private double side; //多边形的长度
     private double x;
     private double y;
     
     //带默认值的无参构造方法
     RegularPolygon(){
         this.n=3;
         this.side=1;
         this.x=0;
         this.y=0;
     }
     
     //带指定边数和边长度，中心在（0，0）的正多边形的构造方法
     public RegularPolygon(int n,double side){
    	 this.n=n;
    	 this.side=side;
    	 this.x=0;
    	 this.y=0;
     }
     
     //带指定边数和边长度，中心在（x，y）的正多边形的构造方法
     public RegularPolygon(int n,double side,double x,double y){
    	 this.n=n;
    	 this.side=side;
    	 this.x=x;
    	 this.y=y;
     }
     
     //构造器
     public void setN(int n){
    	 this.n=n;
     }
     
     public void setSide(double side){
    	 this.side=side;
     }
     
     public void setX(double x){
    	 this.x=x;
     }
     
     public void setY(double y){
    	 this.y=y;
     }
     
     //访问器
     public int getN(){
    	 return n;
     }
     
     public double getSide(){
    	 return side;
     }
     
     public double getX(){
    	 return x;
     }
     
     public double getY(){
    	 return y;
     }
     
     //返回多边形周长
     public double getPerimeter(){
    	 return n*side;
    	 
     }
     
     public double getArea(){
    	 return (n * side *side)/(4 * Math.tan(Math.PI/n));
     }
}

Text，测试主类：

public class Text {
	public static void main(String[] args){
		RegularPolygon R1=new RegularPolygon();
		RegularPolygon R2=new RegularPolygon(6,4);
		RegularPolygon R3=new RegularPolygon(10,4,5.6,7.8);
		
		//输出每个对象的周长和面积
		System.out.println("R1面积:"+R1.getArea());
		System.out.println("R1周长:"+R1.getPerimeter());
		System.out.println("R2面积:"+R2.getArea());
		System.out.println("R2周长:"+R2.getPerimeter());
		System.out.println("R3面积:"+R3.getArea());
		System.out.println("R3周长:"+R3.getPerimeter());

	}
}

五、分析程序，给出运行结果

1.程序一

该程序实现一个两数求和功能。运行结果：sum=-100

为什么不是-300？
b.sexX(-100)的调用结果为x=100，而不是 -100。因为class B的类方法setX( )中，没有使用this关键字。也就是说，-100这个值没有赋给当前调用类方法的对象b。

2.程序二

运行结果：777

3.程序三

运行结果：27

误区：我开始认为是21.。。。 问题出在：b2在调用getSum时，sum的初始值已经为6了。sum定义为静态变量，即类变量。对于类变量，每个对象的类变量都共享同一内存空间，因此，改变其中一个对象的类变量的值，会影响其它对象的这个类变量。本题中，b1对getSum方法的调用已经改变了sum的值。

六、程序纠错

1.程序一

看一下报错：

问题：
（1）y为静态变量（类变量），只能在定义时给其赋初值，但不能单独写一个赋值语句。可以在成员函数里操作（别人给我讲的，我也还不太明白为啥）
（2）成员函数g( )设置为static类型，所以说函数内的x与函数外的x已经不是一个东西了。需要重新定义。

public class A {
	int x=100;
    static long y=200;
    public void f(){
        y=300;
    }

    public static void g(){
    	int x=-23;
    }
}

2.程序二

问题：
（1）x的访问权限是private，所以其他类不能访问。但是又需要在其他类中使用，所以考虑加一个修改器（set方法）
（2）类Tom中方法f( )是私有的，所以A类中无法调用。这显然不合适。因为类方法就是为了能在类外调用。因此f( )应改为公有或受保护的。

public class Tom {
	    private int x=120;
	    protected int y=20;
	    int z=11;

	    public void setx(int x){
	    	this.x=x;
	    }
	    
	    public void f(){
	        x=200;
	        System.out.printf("%d\n", x);
	    }

	    void g(){
	        x=200;
	        System.out.printf("%d\n", x);
	    }
}

public class A {
	public static void main(String args[]){
        Tom tom=new Tom();
        tom.setx();
        tom.y=33;
        tom.z=55;
        tom.f();
        tom.g();
    }
}

这篇题，我感觉最重要的就是搞清：类变量和实例变量（static怎么用），this关键字，以及访问限制的具体规则。