实验2 类和对象

最新推荐文章于 2023-09-03 18:52:58 发布

东浔

最新推荐文章于 2023-09-03 18:52:58 发布

阅读量2.2k

点赞数 6

分类专栏：程序设计（Java）文章标签： python 爬虫 java

本文链接：https://blog.csdn.net/m0_51039351/article/details/121483600

版权

程序设计（Java）专栏收录该内容

8 篇文章 8 订阅

订阅专栏

实验2 类和对象

一、实验目的：

熟悉类和对象的定义及使用；熟悉static关键字、this关键字，访问权限等。

二、实验内容：

1. 编写一个Java应用程序，该程序有2个类：Vehicle(机动车)和User(主类)。Vehicle类的成员变量有：speed(速度)、power(功率)。成员方法有：speedUp(int s)—加速，speedDown(int d)—减速，setPower(int p)—设置功率，getPower()—获取功率

请按下面给出的程序模版，填写缺少的代码，完成程序。
Vehicle.java

public class Vehicle{	
    代码1 //声明double型变量speed	
    代码2 //声明int型变量power	
    void speedUp(int s)
    {
        代码3 //将s的值累加到speed	
    }	
    void speedDown(int d)	
    {	
        代码4 //从speed中减去d	
    }	
    void setPower(int p)	
    {	
        代码5 //将p赋给power	
    }	
    int getPower()	
    {	
        代码6 //返回power的值	
    }	
    double getSpeed()
    {
        return speed;
    }	
}

User.java

public class User {
    public static void main(String args[]){	
        Vehicle car1,car2;	
        代码7 //创建对象car1	
        代码8 //创建对象car2	
        car1.setPower(128);	
        car2.setPower(76);	
        System.out.printf("car1的功率是：%d\n", car1.getPower());	
        System.out.printf("car2的功率是：%d\n", car2.getPower());	
        代码9 //car1调用speedUp方法,速度增加80	
        代码10 //car2调用speedUp方法,速度增加80	
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());	
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());	
        car1.speedDown(10);	
        car2.speedDown(20);	
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());	
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());	
    }	
}

功能扩展：

在类中定义构造方法，构造具有不同初始值的对象。

改进speedUP()方法，限制speed的值不能超过200。

改进speedDown()方法，限制speed的值不能小于0。

增加一个刹车方法void brake()，调用它能将speed的值变为0。

package t1;

public class Vehicle{

    double speed; //声明double型变量speed
    int power; //声明int型变量power
    Vehicle(double x, int y){
    	speed = x;
    	power = y;
    }
    void speedUp(int s)
    {
        if(speed + s <= 200){
        	speed = speed + s; //将s的值累加到speed
        }    	
    }
    void speedDown(int d)
    {
    	if(speed - d > 0){
    		speed = speed - d; //从speed中减去d
    	}
    }
    void setPower(int p)
    {
        power = p; //将p赋给power
    }
    int getPower()
    {
        return power; //返回power的值
    }
    double getSpeed()
    {
        return speed;
    }
    void brake(){
    	speed = 0;
    }
}

package t1;

public class User {

    public static void main(String args[]){

        Vehicle car1,car2;
        car1 = new Vehicle(0,0); //创建对象car1
        car2 = new Vehicle(0,0); //创建对象car2
        car1.setPower(128);
        car2.setPower(76);
        System.out.printf("car1的功率是：%d\n", car1.getPower());
        System.out.printf("car2的功率是：%d\n", car2.getPower());
        car1.speedUp(80); //car1调用speedUp方法,速度增加80
        car2.speedUp(80); //car2调用speedUp方法,速度增加80
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());
        car1.speedDown(10);
        car2.speedDown(20);
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());
    }
}

2．根据下面要求，编写一个Java应用程序：

①定义类StuCard，用到类成员变量(人数)和实例成员变量：学号、姓名、性别、专业、年级、籍贯等；

②初始化的时候用到构造方法，提供两个以上构造方法；

③多个类（业务类StuCard和测试主类），用到包的概念，且分别放到不同的包中；

④用到类成员访问权限，要求类成员变量为Public，实例成员变量为Private；

⑤编写所有数据成员的访问器和修改器（共有的get和set方法）；

⑥在主类中实现对业务类StuCard的读、写、修改属性等功能。

在完成以上功能要求的情况下，可以进一步扩展。

package t2;

public class StuCard {
	
	public static int number = 3000; //类成员变量 人数
	//学号、姓名、性别、专业、年级、籍贯
	private String id;
	private String name;
	private String sex;
	private String major;
	private String grade;
	private String address;
	
	public StuCard(String newid, String newname, String newsex, String newmajor, String newgrade, String newaddress){
		id = newid;
		name = newname;
		sex = newsex;
		major = newmajor;
		grade = newgrade;
		address = newaddress;
	}
	StuCard(String a){
		grade = a;
	}
	//get方法
	public String getid(){
		return id;
	}
	public String getname(){
		return name;
	}
	public String getsex(){
		return sex;
	}
	public String getmajor(){
		return major;
	}
	public String getgrade(){
		return grade;
	}
	public String getaddress(){
		return address;
	}
	// set方法
	public void setid(String a){
		id = a;
	}
	public void setname(String a){
		name = a;
	}
	public void setsex(String a){
		sex = a;
	}
	public void setmajor(String a){
		major = a;
	}
	public void setgrade(String a){
		grade = a;
	}
	public void setaddress(String a){
		address = a;
	}
}

package t2.ceshizhulei;

import t2.*;

public class ceshizhulei {
	public static void main(String args[]){

		StuCard stu = new StuCard("2001010101", "张三", "男", "法学", "2020", "山东省青岛市");
		//读
		stu.getid();
		stu.getname();
		stu.getsex();
		stu.getmajor();
		stu.getgrade();
		stu.getaddress();
		//写
		System.out.printf("学号：%s\n",stu.getid());
		System.out.printf("姓名：%s\n",stu.getname());
		System.out.printf("性别：%s\n",stu.getsex());
		System.out.printf("专业：%s\n",stu.getmajor());
		System.out.printf("年级：%s\n",stu.getgrade());
		System.out.printf("籍贯：%s\n",stu.getaddress());
		//修改
		stu.setid("2007010101");
		stu.setname("李四");
		stu.setsex("女");
		stu.setmajor("英语");
		stu.setgrade("2019");
		stu.setaddress("山东省济南市");
	}

}

3．用类描述计算机中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()方法。

package t3;

public class Test {
	public static void main(String args[]){
		CPU cpu = new CPU();
		cpu.speed = 2200;
		HardDisk disk = new HardDisk();
		disk.amount = 200;
		PC pc = new PC();
		pc.setCPU(cpu);
		pc.setHardDisk(disk);
		pc.show();
	}
}

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

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

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

4．共饮同井水

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

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

package t4;

public class Land{
	public static void main(String args[]){
		Village v1 = new Village("张村", 100);
		Village v2 = new Village("李村", 150);
		v1.drinkwater(300);
		System.out.printf("当前井水的水量："+v2.getwateramount());
	}
}


class Village {
	static int waterAmount = 3000;
	int peopleNumber;
	String name;
	Village(String a, int b){
		name = a;
		peopleNumber = b;
	}
	void drinkwater(int a){
		waterAmount = waterAmount - a;
	}
	int getwateramount(){
		return waterAmount;
	}
}

5．正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对象，输出每个对象的周长和面积。

package t5;

public class main5 {
	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.printf("r1的周长："+r1.getPerimeter()+"\n");
		System.out.printf("r1的面积："+r1.getArea()+"\n");
		System.out.printf("r2的周长："+r2.getPerimeter()+"\n");
		System.out.printf("r2的面积："+r2.getArea()+"\n");
		System.out.printf("r3的周长："+r3.getPerimeter()+"\n");
		System.out.printf("r3的面积："+r3.getArea());
	}

}

class RegularPolygon{
	private int n;
	private double side;//边长
	private double x;
	private double y;
	
	RegularPolygon(){
		n = 3;
		side = 1;
		x = 0;
		y = 0;
	}
	RegularPolygon(int a, double b){
		n = a;
		side = b;
		x = 0;
		y = 0;
	}
	RegularPolygon(int a, double b, double c, double d){
		n = a;
		side = b;
		x = c;
		y = d;
	}
	// get
	public int getn(){
		return n;
	}
	public double getside(){
		return side;
	}
	public double getx(){
		return x;
	}
	public double gety(){
		return y;
	}
	// set
	public void setn(int a){
		n = a;
	}
	public void setside(double a){
		side = a;
	}
	public void setx(double a){
		side = x;
	}
	public void sety(double a){
		side = y;
	}
	// 返回周长
	public double getPerimeter(){
		return n*side;
	}
	// 返回面积
	public double getArea(){
		return (n*side*side)/(4*Math.tan(Math.PI/n));
	}
}

6．分析程序，给出运行结果

class B {
    int x=100,y=200;	
    public void setX(int x){	
        x=x;	
    }	
    public void setY(int y){	
        this.y=y;	
    }	
    public int getXYSum(){	
        return x+y;	
    }	
}

public class A{	
    public static void main(String args[]){	
        B b=new B();	
        b.setX(-100);	
        b.setY(-200);
        System.out.printf("sum=%d\n", b.getXYSum());	
    }	
}

sum=-100

7．分析程序，给出输出结果

public class A{
    public static void main(String args[]){
        B b=new B(20);
        add(b);
        System.out.printf("%d\n", b.intValue());
    }
    public static void add(B m){
        int t=777;
        m.setIntValue(t);
    }
}

class B{
    int n;
    B(int n){
        this.n=n;
    }
    public void setIntValue(int n){
        this.n=n;
    }
    int intValue(){
        return n;
    }
}

8．分析程序，给出输出结果

class B{
    int n;
    static int sum=0;
    void setN(int n){
        this.n=n;
    }
    int getSum(){
        for(int i=1;i<=n;i++)
            sum=sum+i;
        return sum;
    }
}

public class A{
    public static void main(String args[]){
        B b1=new B(),b2=new B();
        b1.setN(3);
        b2.setN(5);
        int s1=b1.getSum();
        int s2=b2.getSum();
        System.out.printf("%d\n", s1+s2);
    }
}

9．程序改错：将下面给出的程序修改成正确的代码

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

class A{

    static int x=100;
    static long y=200;
    public void f(){
        y=300;
    }
    public static void g(){
        x=-23;//类方法只能调用类变量
    }
    
}

10．程序改错：将下面给出的程序修改成正确的代码

class Tom{
    private int x=120;
    protected int y=20;
    int z=11;
    private 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.x=22;
        tom.y=33;
        tom.z=55;
        tom.f();
        tom.g();
    }
}

class Tom{
    private int x=120;
    protected int y=20;
    int z=11;
    //不能在类外调用私有方法f()，将其改为友好的
    void f(){
        x=200;
        System.out.printf("%d\n", x);
    }
    void g(){
        x=200;
        System.out.printf("%d\n", x);
    }
    //x是私有变量，可以设置能够在类外访问的共有方法来读写私有变量
    void setx(int a){
     x = a;
    }
}

public class A{
    public static void main(String args[]){
        Tom tom=new Tom();
        //tom.x=22;成员变量是private的，受到访问限制，但方法是public的，不受限制
        tom.setx(22);
        tom.y=33;
        tom.z=55;
        tom.f();
        tom.g();
    }
}

东浔

关注

6
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
实验2 类和对象

实验二类和对象一、实验目的：熟悉类和对象的定义及使用；熟悉static关键字、this关键字，访问权限等。二、实验内容：1. 编写一个Java应用程序，该程序有2个类：Vehicle(机动车)和User(主类)。Vehicle类的成员变量有：speed(速度)、power(功率)。成员方法有：speedUp(int s)—加速，speedDown(int d)—减速，setPower(int p)—设置功率，getPower()—获取功率请按下面给出的程序模版，填写缺少的代码，完成程序。V
复制链接

扫一扫