实验 4——面向对象基础

木子一个Lee

已于 2023-08-02 17:47:32 修改

阅读量1.1k

点赞数 4

分类专栏： Java基础篇文章标签： java 开发语言

于 2022-10-03 23:07:12 首次发布

本文链接：https://blog.csdn.net/qq_51246603/article/details/127157628

版权

Java基础篇专栏收录该内容

21 篇文章 6 订阅

订阅专栏

一．实验目的：

（1）掌握类的定义、类的实例化方法；

（2）掌握类中的静态变量和静态方法的使用；

（3）掌握使用类的构造方法对对象的数据域进行初始化；

（4）掌握getter(访问器)和setter(修改器)的命名方式与使用；

二．实验内容

（1）现在要求设计一个表示学生的类，里面有学生的姓名、学号、年龄，还要有三项成绩：计算机成绩、数学成绩、英语成绩，要求可以求总分、平均分、最高、最低分，并且可以输出一个学生的完整信息，请设计此类。

提示：程序开发步骤

根据需求定义出所要的类；

根据题目中的要求规划出类的属性；

所有的属性必须封装：private；

所有的属性必须通过getter和setter访问；

如果需要增加构造方法，为属性赋初值，适当采用构造方法重载；

所有的信息不要类中直接输出，而是交给调用处输出，即在该类中尽量不出现System.out.println()语句。例如在调用类中输出如下结果：

总分：267.70000000000005

平均分：89.23333333333335

最高分：91.4

最低分：87.3

学生信息:

|-学号：100

|-姓名：John

|-年龄：20

|-英语：89.0

|-计算机：87.3

|-数学：91.4

package project4;
import java.lang.*;
@SuppressWarnings("unused")
public class Information {

	public static void main(String[] args) {
		Student s=new Student("John",100,20);
		s.setComputer(87.3);
		s.setEnglish(89.0);
		s.setMath(91.4);
		s.show(s);

	}

}
class Student{
	private String name;
	private int student_id,old;
	private double computer,Maths,English;
	public String getname() {
		return name;
	}
	public int getstudent_id() {
		return student_id;
	}
	public int getold() {
		return old;
	}
	public Student(String name,int student_id,int old) {
		this.name=name;
		this.student_id=student_id;
		this.old=old;
	}
	public double getComputer() {
		return computer;
	}
	public void setComputer(double computer) {
		this.computer = computer;
	}
	public double getEnglish() {
		return English;
	}
	public void setEnglish(double english) {
		English = english;
	}
	public double getMath() {
		return Maths;
	}
	public void setMath(double math) {
		Maths = math;
	}
	public double getSum() {
		return computer+Maths+English;
	}
	public double getAverage() {
		return (computer+Maths+English)/3;
	}
	public double getMax() {
		 double max=Math.max(Maths, English);
		 max=Math.max(computer, max);
		return max;
	}
	public double getMin() {
		double min=Math.min(Maths, English);
		min=Math.min(min, computer);
		return min;
	}
	public void show(Student s) {
		System.out.println("总分："+s.getSum());
		System.out.println("平均分："+s.getAverage());
		System.out.println("最高分："+s.getMax());
		System.out.println("最低分："+s.getMin());
		System.out.println("学生信息：");
		System.out.println("   |-学号："+s.getstudent_id());
		System.out.println("   |-姓名："+s.getname());
		System.out.println("   |-年龄："+s.getold());
		System.out.println("   |-英语："+s.getEnglish());
		System.out.println("   |-计算机："+s.getComputer());
		System.out.println("   |-数学："+s.getMath());
	}

}

(二)

1、设计类来描述真实客观世界中的事物，使用类的成员变量来表示事物的属性和状态，使用类的成员方法来提供对成员变量的访问或修改

程序功能：设计一个用来描述汽车的类，使用类的非静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度，使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。

程序源代码如下，补全横线上的程序代码。

public class Car {

private String ownerName; //车主姓名

private float curSpeed; //当前车速

private float curDirInDegree; //当前方向盘转向角度

public Car (String ownerName){

_this.ownerName______ = ___ownerName_____;

}

public Car (String ownerName, float speed, float dirInDegree){

_this(ownerName)______;//调用上面那个构造函数为ownerName赋值

_curSpeed_______ = ___speed____ ;

__curDirInDegree______ = _dirInDegree_______;

}

public String getOwnerName() { //提供对车主姓名的访问

_return ownerName______；

}

public float getCurDirInDegree() { //提供对当前方向盘转向角度的访问

_return curDirInDegree______;

}

public float getCurSpeed() { //提供对当前车速的访问

_return curSpeed______;

}

public void changeSpeed(float curSpeed) { //提供改变当前的车速

_this.curSpeed______ = __curSpeed______;

}

public void stop(){ //提供停车

___curSpeed______ = ___0_____;

}

编写一个主方法，编译并测试源程序。

2、创建类的对象，使用对象的方法（类的非静态方法）来访问或修改对象的变量（类的非静态变量）

创建类Car的对象，在调用类的构造函数时指定对象的变量的初始值，以后再使用对象的方法来访问或修改对象的变量的值。

程序代码如下（需要添加代码，要求运行结果如下图所示。

public class Car {

public static void main(String[] args){

EXP3_1 car=new Car ("成龙",200f,25f);

//在下面填写代码

}

package project4;

public class Car {
	private String ownerName; //车主姓名
	  private float curSpeed; //当前车速
	  private float curDirInDegree; //当前方向盘转向角度
	  public Car (String ownerName){
	   this.ownerName=ownerName;
	  }
	  public Car (String ownerName, float speed, float dirInDegree){
	   this(ownerName);//调用上面那个构造函数为ownerName赋值
	    curSpeed= speed;
	    curDirInDegree= dirInDegree;
	 }
	  public String getOwnerName() { //提供对车主姓名的访问
	    return ownerName;
	  }
	  public float getCurDirInDegree() { //提供对当前方向盘转向角度的访问
	    return curDirInDegree;
	  }
	  public float getCurSpeed() { //提供对当前车速的访问
	    return curSpeed;
	  }
	  public void changeSpeed(float curSpeed) { //提供改变当前的车速
	    this.curSpeed= curSpeed;
	  }
	  public void stop(){ //提供停车
	     curSpeed= 0;
	  }

	public static void main(String[] args) {
		Car car=new Car ("成龙",200f,25f);
		System.out.println("车主姓名："+car.getOwnerName());
		System.out.println("当前车速："+car.getCurSpeed());
		System.out.println("当前转向角度："+car.getCurDirInDegree());
		car.changeSpeed(80);
		System.out.println("在调用cahangeSpeed(80)后，车速变为："+car.getCurSpeed());
        car.stop();
        System.out.println("在调用stop()后，车速变为："+car.getCurSpeed());
	}

}

（三）（账户类Account）设计一个名为Account的类，它包括：

● 一个名为id的int类型私有账户数据域（默认值为0）。

● 一个名为balance的double类型私有账户数据域（默认值为0）。

● 一个名为annualInterestRate的double类型私有数据域存储当前利率（默认值为0）。假设所有的账户都有相同的利率。

● 一个名为dateCreated的Date类型私有数据域存储账户的开户日期。

● 一个能创建默认账户的无参构造方法。

● 一个能创建带特定id和初始余额的账户的构造方法。

● id、balance和annualInterestRate的访问器和修改器。

● dateCreated的访问器。

● 一个名为getMonthlyInterestRate（）的方法返回月利率。

● 一个名为withDraw的方法从账户提取特定数额。

● 一个名为deposit的方法向账户存储特定数额。

实现这个类。编写一个测试程序，创建一个账户ID为1122、余额为20000美元、年利率为4.5%的Account对象。使用withdraw方法取款2500美元，使用deposit方法存款3000美元，然后打印余额、月利息以及这个账户的开户日期。

package project4;
import java.text.SimpleDateFormat;
import java.util.*;
public class MyAccount {
    
	public static void main(String[] args) {
		Account a=new Account(1122,20000);
		a.setAnnualInterestRate(0.045);
		a.withDraw(2500);
		a.deposit(3000);
		SimpleDateFormat s=new SimpleDateFormat("yyyy 年MM 月dd 日hh 时mm 分ss 秒 a EEEE");
		System.out.println("余额："+a.getBalance()+"$");
		System.out.println("月利息："+a.getAnnualInterestRate()*a.getBalance()+"$");
		System.out.println("开户日期："+s.format(a.getDateCreated()));
		System.out.println();
		System.out.println();

	}
    
}
class Account{
	private int id=0;
	private double balance=0;
	private double annualInterestRate=0;
	private Date dateCreated;
	
	public Account() {
		dateCreated=new Date();
	}
	
	public Account( int id, double balance){
		this();
		this.id=id;
		this.balance=balance;
		}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}

	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}

	public Date getDateCreated() {
		return dateCreated;
	}
	
	public double getMonthlyInterestRate(){
		return annualInterestRate/12;
	}
	

	public void withDraw( double a){
			balance = balance - a;
	}
		
	public void deposit( double a){
			balance = balance + a;
	}

}

（三）（风扇类Fan）设计一个名为Fan的类来表示一个风扇。这个类包括：

三个名为SLOW、MEDIUM、FAST而值是1、2和3的常量表示风扇的速度。
一个名为speed的int类型私有数据域表示风扇的速度（默认值为SLOW）。
一个名为on的boolean类型的私有数据域表示风扇是否打开（默认值为false）。
一个名为radius的double类型的私有数据域表示风扇的半径（默认值为5）。
一个名为color的String类型的数据域表示风扇的颜色（默认值为blue）。
这四个数据域的访问器和修改器。

一个创建默认风扇的无参构造方法。
一个名为toString（）的方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就返回一个由“fan is off”和风扇颜色及半径组合成的字符串。

实现这个类。编写一个测试程序，创建两个fan对象。将第一个对象设置为最大速度、半径为10、颜色为yellow、状态为打开。将第二个对象设置为中等速度、半径为5、颜色为blue、状态为关闭。通过调用它们的toString方法显示这些对象。

package project4;

public class MyFan {

	public static void main(String[] args) {
		Fan f1=new Fan();
		Fan f2=new Fan();
		f1.setSpeed(f1.FAST);
		f1.setRadius(10);
		f1.setColor("yellow");
		f1.setOn(true);
		
		f2.setSpeed(f2.MEDIUM);
		f2.setRadius(5);
		f2.setColor(f2.getColor());
		f2.setOn(false);
		
		System.out.println("风扇f1:"+f1.toString());
		System.out.println("风扇f2:"+f2.toString());
    
	}

}
class Fan{
	final int SLOW=1;
	final int MEDIUM=2;
	final int FAST=3;
	private int speed=SLOW;
	private boolean on=false;
	private double radius=5;
	private String color="blue";
	
	public Fan() {
		
	}
	
	public int getSpeed() {
		return speed;
	}
	public void setSpeed(int speed) {
		this.speed = speed;
	}
	public boolean isOn() {
		return on;
	}
	public void setOn(boolean on) {
		this.on = on;
	}
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	public String toString() {
		String s;
		if(this.on) 
			s="速度："+this.speed+"   颜色："+this.color+"   半径："+this.radius;
		else 
			s="fan is off   颜色："+this.color+"   半径："+this.radius;
		    return s;
	}
	
}

（四）（几何方面：正n边形）在一个正n边形中，所有边的长度都相同，且所有角的度数都相同（即这个多边形是等边等角的）。设计一个名为RegularPolygon的类，该类包括：

一个名为n的int型私有数据域定义多边形的边数，默认值为3。

一个名为side的double型私有数据域存储边的长度，默认值为1。
一个名为x的double型私有数据域，它定义多边形中点的x坐标，默认值为0。
一个名为y的double型私有数据域，它定义多边形中点的y坐标，默认值为0。
一个创建带默认值的正多边形的无参构造方法。
一个能创建带指定边数和边长度、中心在（0,0）的正多边形的构造方法。
一个能创建带指定边数和边长度、中心在（x,y）的正多边形的构造方法。
所有数据域的访问器和修改器。
一个返回多边形周长的方法getPerimeter()。
一个返回多边形面积的方法getArea()。计算正多边形面积的公式是：

面积=

实现这个类。编写一个测试程序，分别使用无参构造方法、RegularPolygon（6,4）和RegularPolygon（10,4,5.6,7.8）创建三个RegularPolygon对象。显示每个对象的周长和面积。

package project4;

public class MyRegularPolygon {

	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.getPerimeter());
        System.out.println("r2的周长为："+r2.getPerimeter());
        System.out.println("r3的周长为："+r3.getPerimeter());
        System.out.println("r1的面积为："+r1.getArea());
        System.out.println("r2的面积为："+r2.getArea());
        System.out.println("r3的面积为："+r3.getArea());

	}

}
class RegularPolygon{
	private int n=3;
	private double side=1;
	private double x=0;
	private double y=0;
	
	public RegularPolygon() {
		
	}
    public RegularPolygon(int n,int side) {
		this.setN(n);
		this.setSide(side);
	}
    public RegularPolygon(int n,int side,double x,double y) {
		this(n,side);
		this.x=x;
		this.x=x;
	}
    
	public int getN() {
		return n;
	}
	public void setN(int n) {
		this.n = n;
	}
	public double getSide() {
		return side;
	}
	public void setSide(double side) {
		this.side = side;
	}
	public double getX() {
		return x;
	}
	public void setX(double x) {
		this.x = x;
	}
	public double getY() {
		return y;
	}
	public void setY(double y) {
		this.y = y;
	}
	
	public  double getPerimeter() {
		return this.n*this.side;
	}
	public  double getArea() {
		return (this.n*this.side*this.side)/(4*Math.tan(Math.PI/this.n));
	}
    

}

（五）(代数方面：二次方程)为二次方程式设计一个名为QuadraticEquation的类。

这个类包括：

代表参数为a、b和c。
一个参数为a、b和c的构造方法。
A、b、c的三个get方法。
一个名为getDiscriminant（）的方法返回判别式，。
一个名为getRoot1()和getRoot2()的返回等式的两个根：

这些方法只有在判别式为非负数时才有用。如果判别式为负，这些方法返回0。

实现这个类。编写一个测试程序，提供用户输入a、b和c的值，然后显示判别式的结果。如果判别式为正数，显示两个根；如果判别式为0，显示一个根；否则显示“The equation has no roots.”（这个方程无根）。

package project4;
import java.util.*;
public class MyQuadraticEquation {

	public static void main(String[] args) {
		@SuppressWarnings("resource")
		Scanner input=new Scanner(System.in);
		System.out.println("Enter a b c:");
        double a=input.nextDouble();
        double b=input.nextDouble();
        double c=input.nextDouble();
        QuadraticEquation q=new QuadraticEquation(a,b,c);
        if(q.getDiscriminant()>0) {
        	System.out.println("r1="+q.getRoot1());
        	System.out.println("r2="+q.getRoot2());
        }
        else if(q.getDiscriminant()==0) {
        	System.out.println("r="+q.getRoot1());
        }
        else 
        	System.out.println("The equation has no roots.");
	}

}
class QuadraticEquation{
	private double a;
	private double b;
	private double c;

	public QuadraticEquation(double a,double b,double c) {
		this.a=a;
		this.b=b;
		this.c=c;
	}

	public double getA() {
		return a;
	}

	public double getB() {
		return b;
	}

	public double getC() {
		return c;
	}
	
	public double getDiscriminant() {
		return b*b-4*a*c;
	}
	
	public double getRoot1() {
		if(getDiscriminant()>=0) 
		return (-b+Math.sqrt(b*b-4*a*c))/2*a;
		else
			return 0;
	}
	public double getRoot2() {
		if(getDiscriminant()>=0)
		return (-b-Math.sqrt(b*b-4*a*c))/2*a;
		else
			return 0;
	}
}

（五）设计一个名为StopWatch的类，该类包含：

具有访问器方法的私有数据域startTime和endTime。

一个无参的构造方法，使用当前时间来初始化stratTime。

一个名为start（）的方法，将startTime重设为当前时间。

一个名为stop（）的方法，将endTime设置为当前时间。

一个名为getElapsedTime（）方法，以毫秒为单位返回秒表记录的流逝shi间。

package project4;
import java.text.SimpleDateFormat;
import java.util.*;
public class MyStopWatch {

	@SuppressWarnings("static-access")
	public static void main(String[] args) throws InterruptedException {
		StopWatch w=new StopWatch();
		SimpleDateFormat s=new SimpleDateFormat("yyyy 年MM 月dd 日hh 时mm 分ss 秒 ");
		System.out.println("计时开始时间："+s.format(w.start())+"\n程序sleep 1000毫秒");
        Thread.currentThread().sleep(1000);//让程序等待1000毫秒
        System.out.println("计时结束时间："+s.format(w.stop()));
        System.out.println("流逝时间为："+w.getElapsedTime()+"ms");
    }

}
class StopWatch{
	private Date startTime;
	private Date endTime;
	
	public StopWatch() {
		this.startTime=new Date();
	}
	
	public Date getStartTime() {
		return startTime;
	}
	public Date getEndTime() {
		return endTime;
	}
	public Date start() {
		return this.startTime=new Date();
	}
	public Date stop() {
		return this.endTime=new Date();
	}
	public double getElapsedTime() {
		return endTime.getTime()-startTime.getTime();
	} 
}

木子一个Lee

关注

4
点赞
踩
15

收藏

觉得还不错? 一键收藏
1
评论
实验 4——面向对象基础

（1）现在要求设计一个表示学生的类，里面有学生的姓名、学号、年龄，还要有三项成绩：计算机成绩、数学成绩、英语成绩，要求可以求总分、平均分、最高、最低分，并且可以输出一个学生的完整信息，请设计此类。程序功能：设计一个用来描述汽车的类，使用类的非静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度，使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。假设所有的账户都有相同的利率。创建类Car的对象，在调用类的构造函数时指定对象的变量的初始值，以后再使用对象的方法来访问或修改对象的变量的值。
复制链接

扫一扫

专栏目录