本科课程【java程序设计】实验2 - 类与对象编程练习

转x33g5p2x  于2022-05-05 转载在 Java  
字(5.1k)|赞(0)|评价(0)|浏览(696)

大家好，我是【1+1=王】， 热爱java的计算机（人工智能）渣硕研究生在读。
如果你也对java、人工智能等技术感兴趣，欢迎关注，抱团交流进大厂！！！
Good better best, never let it rest, until good is better, and better best.

近期会把自己本科阶段的一些课程设计、实验报告等分享出来，供大家参考，希望对大家有帮助。

博客更新至专栏【课程设计实验报告】：https://blog.csdn.net/weixin_43598687/category_11640051.html

一、 实验目的

1、掌握如何使用类来封装对象的属性和功能。
2、掌握使用package和import语句。

二、 实验内容

1. 实验任务

  1. 编写一个Java应用程序，该程序中有2个类：Lader和Circle，分别用来刻画“梯形”和“圆形”。具体要求如下：
    a) Lader类具有类型为double的私有属性上底、下底、高、面积，具有返回面积的功能。
    b) Circle类具有类型为double的私有属性半径、周长和面积，具有返回周长、面积的功能。
    C)在一个新的public类中创建并使用三个类的对象：
    Lader类：创建对象并初始化，然后计算面积并输出
    Circle类：创建对象并初始化，然后计算周长、面积并输出。
  2. 定义一个复数(z=x+iy)类Complex，包含：
    1）两个属性：实部x和虚部y
    2）默认构造方法 Complex()，设置x=0,y=0
    3）构造方法：Complex(double x,double y)
    4）toString()方法：将其显示为如： 5+8i或5-8i 的形式。
    5）求两个复数的和的方法： public Complex addComp(Complex C1)
    6）求两个复数的差的方法： public Complex subComp(Complex C1)
    7）求两个复数的乘积的方法： public Complex multiComp(Complex C1)
    8）比较两个复数是否相等的方法 public boolean equalComp(Complex C1)
    9）在Application中测试该类的方法，实部x和虚部y可由main方法参数提供输入。
  3. 设计一个一元二次方程的类，其中包括能够反映一元二次方程的属性与操作行为，然后再设计一个测试类，检测类的使用情况。要求：
    1)使用package语句将方程的属性即计算跟的方法封装在一个有包名的类中，包名为tom.jiafei，类的名字是SquareEquation；
    2)编写一个SunRise的主类，使用import语句引入tom.jiafei包中的SquareEquation类；
    3)一元二次方程的系数A，B，C从键盘输入。
  4. 编写一个表示二维平面上的点的类MyPoint，满足以下条件：
    1)定义private的成员变量x和y，表示点的x和y坐标，类型为double
    2)定义两个MyPoint的构造方法，一个构造方法不带参数，而且x和y的初始值为0，另一个构造方法有两个参数，参数名为x和y，类型为double，用这两个参数分别作为初始x和y坐标
    3)定义一个getD方法，有一个类型为MyPoint的对象参数，功能为返回当前对象和参数对象这两个坐标点的距离，返回值为double类型
    4)编写测试的main方法，调用getD计算两个点之间的距离
    输入：
    输入2行数据， 总共4个有理数。每2个数据一组，表示一个点的x和y坐标，每行的2个数据用空格隔开。例如：
    200.1 200.2
    200.3 200.4
    输出：
    输出两个点之间的距离。例如：
    0.28284271247464315

2. 程序设计

  1. class Lader{
  2. 	private double up;
  3. 	private double down;
  4. 	private double height;
  5. 	private double area;
  6. 	public Lader(double up, double down, double height) {
  7. 		super();
  8. 		this.up = up;
  9. 		this.down = down;
  10. 		this.height = height;
  11. 		this.area = (up+down)*height/2;
  12. 		System.out.println("面积：" + this.area);
  13. 	}
  15. }
  17. class Circle{
  18. 	public double pi = 3.14;
  19. 	private double r;
  20. 	private double c;
  21. 	private double s;
  22. 	public Circle(double r) {
  23. 		super();
  24. 		this.r = r;
  25. 		this.c = 2*pi*r;
  26. 		this.s = pi*r*r;
  27. 		System.out.println("周长："+c + "面积：" + s);
  28. 	}
  29. 	
  30. 	
  31. }
  33. public class one {
  35. 	public static void main(String[] args) {
  36. 		double up = 1;
  37. 		double down =2;
  38. 		double height =1;
  39. 		double r =1;
  40. 		Lader lader = new Lader(up, down, height);
  41. 		Circle circle = new Circle(r);
  42. 	}
  1. import java.util.Scanner;
  3. class Complex{
  4. 	private double x;
  5. 	private double y;
  6. 	
  7. 	public Complex() {
  8. 		super();
  9. 		this.x =0;
  10. 		this.y = 0;
  11. 	}
  12. 	public Complex(double x, double y) {
  13. 		super();
  14. 		this.x = x;
  15. 		this.y = y;
  16. 	}
  17. 	
  18. 	public void tostring() {
  19. 		if(this.y>0) {
  20. 			System.out.println(this.x + "+" + this.y + "i");
  21. 		}else {
  22. 			System.out.println(this.x + "-" + this.y + "i");
  23. 		}
  24. 		
  25. 	}
  26. 	
  27. 	public Complex addComp(Complex C1,Complex C2) {
  28. 		Complex comp = new Complex();
  29. 		comp.x = C1.x + C2.x;
  30. 		comp.y = C1.y + C2.y;
  31. 		
  32. 		return comp;
  33. 	}
  34. 	
  35. 	public Complex subComp(Complex C1,Complex C2) {
  36. 		Complex comp = new Complex();
  37. 		comp.x = C1.x - C2.x;
  38. 		comp.y = C1.y - C2.y;
  39. 		
  40. 		return comp;
  41. 	}
  42. 	
  43. 	public Complex multComp(Complex C1,Complex C2) {
  44. 		Complex comp = new Complex();
  45. 		comp.x = C1.x * C2.x -C1.y*C2.y;
  46. 		comp.y = C1.x * C2.y -C1.y*C2.x;
  47. 		
  48. 		return comp;
  49. 	}
  50. 	
  51. 	public boolean equalComp(Complex C1,Complex C2) {
  52. 		
  53. 		if((C1.x == C2.x)&&(C1.y == C2.y)) {
  54. 			return true;
  55. 		}else {
  56. 			return false;
  57. 		}
  58. 	}
  59. 	
  60. }
  61. public class two {
  63. 	public static void main(String[] args) {
  64. 		Scanner sc = new Scanner(System.in);
  65. 		double x1,x2,y1,y2;
  66. 		x1 = sc.nextDouble();
  67. 		y1 = sc.nextDouble();
  68. 		x2 = sc.nextDouble();
  69. 		y2 = sc.nextDouble();
  70. 		Complex C1 = new Complex(x1,y1);
  71. 		Complex C2 = new Complex(x2,y2);
  72. 		Complex comp = new Complex();
  73. 		comp = comp.addComp(C1, C2);
  74. 		System.out.print("相加：") ;
  75. 		comp.tostring();
  76. 		System.out.print("相减：") ;
  77. 		comp = comp.subComp(C1, C2);
  78. 		comp.tostring();
  79. 		System.out.print("相乘：") ;
  80. 		comp = comp.multComp(C1, C2);
  81. 		comp.tostring();
  82. 		System.out.println("是否相等:" + comp.equalComp(C1, C2));
  83. 	}
  84. }
  1. public class SquareEquation {
  3. 	private int A;
  4. 	private int B;
  5. 	private int C;
  6. 	
  7. 	public SquareEquation() {
  8. 		super();
  9. 	}
  11. 	public SquareEquation(int a, int b, int c) {
  12. 		super();
  13. 		A = a;
  14. 		B = b;
  15. 		C = c;
  16. 	}
  17. 	
  18. 	public void jisuan() {
  19. 		double dt = 0,dt2 = 0 ,gen1 = 0,gen2 =0 ;
  20. 		dt2 = this.B*this.B - 4*this.A*this.C;
  21. 		dt = Math.sqrt(dt2);
  22. 		
  23. 		if(dt<0) {
  24. 			System.out.println("方程无解");
  25. 		}else if (dt==0) {
  26. 			gen1 = (-this.B)/(2*this.A);
  27. 			System.out.println("方程的根为：" + gen1);
  28. 		}else if (dt>0) {
  29. 			gen1 = (-this.B+dt)/(2*this.A);
  30. 			gen2 = (-this.B-dt)/(2*this.A);
  31. 			System.out.println("方程的根为：" + gen1 + "或" + gen2);
  32. 		}
  33. 	}
  34. }
  36. public class SunRise {
  38. 	public static void main(String[] args) {
  39. 		int a,b,c;
  40. 		Scanner sc = new Scanner(System.in);
  41. 		a=sc.nextInt();
  42. 		b=sc.nextInt();
  43. 		c=sc.nextInt();
  44. 		
  45. 		SquareEquation square = new SquareEquation(a, b, c);
  46. 		square.jisuan();
  47. 	}
  48. }
  1. class MyPoint{
  2. 	
  3. 	private double x;
  4. 	private double y;
  5. 	
  6. 	public MyPoint() {
  7. 		super();
  8. 		this.x = 0;
  9. 		this.y = 0;
  10. 	}
  12. 	public MyPoint(double x, double y) {
  13. 		super();
  14. 		this.x = x;
  15. 		this.y = y;
  16. 	}
  17. 	
  18. 	public double getD(MyPoint myPoint) {
  19. 		double d = 0;
  20. 		d = Math.sqrt((this.x-myPoint.x)*(this.x-myPoint.x)+(this.y-myPoint.y)*(this.y-myPoint.y));
  21. 		
  22. 		return d;
  23. 	}
  24. }
  26. public class four {
  27. 	public static void main(String[] args) {
  28. 		Scanner sc = new Scanner(System.in);
  29. 		double x1,y1,x2,y2;
  30. 		x1 = sc.nextDouble();
  31. 		y1 = sc.nextDouble();
  32. 		x2 = sc.nextDouble();
  33. 		y2 = sc.nextDouble();
  34. 		MyPoint my1 = new MyPoint(x1, y1);
  35. 		MyPoint my2 = new MyPoint(x2, y2);
  36. 		double d = my1.getD(my2);
  37. 		System.out.println("两点间的距离为：" + d);
  38. 	}
  39. }

3. 实验结果

三、 实验环境

  1. 操作系统：WINDOWSP10
  2. 开发工具：JDK 1.8 或 Eclipse
  3. 实验设备：PC

总结

对象是用来描述客观事物的一个实体，类定义了对象将会拥有的特征（属性）和行为（方法）
类是对象的类型。对象是类的实例。
上面几种类的实现方法都比较类似，先是创建类的对象，在对类的对象赋值并调用一些方法。
下面是本次实验学习及用到的一些知识：
创建对象：
类名 对象名 = new 类名（）;

引用类的属性：
对象名.属性

引用类的方法:
对象名.方法名

定义方法：
Public 返回值类型 方法名（）{
}

调用方法：
对象名.方法名（）；
博客更新至专栏【课程设计实验报告】：https://blog.csdn.net/weixin_43598687/category_11640051.html

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_43598687/article/details/124487936

内容来源于网络，如有侵权，请联系作者删除！

Java课程设计实验报告实验报告类与对象

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com