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

Posted 2022-12-06

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了本科课程java程序设计实验2 - 类与对象编程练习相关的知识，希望对你有一定的参考价值。

大家好，我是【1+1=王】，热爱java的计算机（人工智能）渣硕研究生在读。
如果你也对java、人工智能等技术感兴趣，欢迎关注，抱团交流进大厂！！！
Good better best, never let it rest, until good is better, and better best.
近期会把自己本科阶段的一些课程设计、实验报告等分享出来，供大家参考，希望对大家有帮助。

一、实验目的

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

二、实验内容

1. 实验任务

编写一个Java应用程序，该程序中有2个类：Lader和Circle，分别用来刻画“梯形”和“圆形”。具体要求如下：
a) Lader类具有类型为double的私有属性上底、下底、高、面积，具有返回面积的功能。
b) Circle类具有类型为double的私有属性半径、周长和面积，具有返回周长、面积的功能。
C)在一个新的public类中创建并使用三个类的对象：
Lader类：创建对象并初始化，然后计算面积并输出
Circle类：创建对象并初始化，然后计算周长、面积并输出。
定义一个复数(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方法参数提供输入。
设计一个一元二次方程的类，其中包括能够反映一元二次方程的属性与操作行为，然后再设计一个测试类，检测类的使用情况。要求：
1)使用package语句将方程的属性即计算跟的方法封装在一个有包名的类中，包名为tom.jiafei，类的名字是SquareEquation；
2)编写一个SunRise的主类，使用import语句引入tom.jiafei包中的SquareEquation类；
3)一元二次方程的系数A，B，C从键盘输入。
编写一个表示二维平面上的点的类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. 程序设计

class Lader
  private double up;
  private double down;
  private double height;
  private double area;
  public Lader(double up, double down, double height) 
    super();
    this.up = up;
    this.down = down;
    this.height = height;
    this.area = (up+down)*height/2;
    System.out.println("面积：" + this.area);
  



class Circle
  public double pi = 3.14;
  private double r;
  private double c;
  private double s;
  public Circle(double r) 
    super();
    this.r = r;
    this.c = 2*pi*r;
    this.s = pi*r*r;
    System.out.println("周长："+c + "面积：" + s);
  
  
  


public class one 

  public static void main(String[] args) 
    double up = 1;
    double down =2;
    double height =1;
    double r =1;
    Lader lader = new Lader(up, down, height);
    Circle circle = new Circle(r);

import java.util.Scanner;

class Complex
  private double x;
  private double y;
  
  public Complex() 
    super();
    this.x =0;
    this.y = 0;
  
  public Complex(double x, double y) 
    super();
    this.x = x;
    this.y = y;
  
  
  public void tostring() 
    if(this.y>0) 
      System.out.println(this.x + "+" + this.y + "i");
    else 
      System.out.println(this.x + "-" + this.y + "i");
    
    
  
  
  public Complex addComp(Complex C1,Complex C2) 
    Complex comp = new Complex();
    comp.x = C1.x + C2.x;
    comp.y = C1.y + C2.y;
    
    return comp;
  
  
  public Complex subComp(Complex C1,Complex C2) 
    Complex comp = new Complex();
    comp.x = C1.x - C2.x;
    comp.y = C1.y - C2.y;
    
    return comp;
  
  
  public Complex multComp(Complex C1,Complex C2) 
    Complex comp = new Complex();
    comp.x = C1.x * C2.x -C1.y*C2.y;
    comp.y = C1.x * C2.y -C1.y*C2.x;
    
    return comp;
  
  
  public boolean equalComp(Complex C1,Complex C2) 
    
    if((C1.x == C2.x)&&(C1.y == C2.y)) 
      return true;
    else 
      return false;
    
  
  

public class two 

  public static void main(String[] args) 
    Scanner sc = new Scanner(System.in);
    double x1,x2,y1,y2;
    x1 = sc.nextDouble();
    y1 = sc.nextDouble();
    x2 = sc.nextDouble();
    y2 = sc.nextDouble();
    Complex C1 = new Complex(x1,y1);
    Complex C2 = new Complex(x2,y2);
    Complex comp = new Complex();
    comp = comp.addComp(C1, C2);
    System.out.print("相加：") ;
    comp.tostring();
    System.out.print("相减：") ;
    comp = comp.subComp(C1, C2);
    comp.tostring();
    System.out.print("相乘：") ;
    comp = comp.multComp(C1, C2);
    comp.tostring();
    System.out.println("是否相等:" + comp.equalComp(C1, C2));

public class SquareEquation 

  private int A;
  private int B;
  private int C;
  
  public SquareEquation() 
    super();
  

  public SquareEquation(int a, int b, int c) 
    super();
    A = a;
    B = b;
    C = c;
  
  
  public void jisuan() 
    double dt = 0,dt2 = 0 ,gen1 = 0,gen2 =0 ;
    dt2 = this.B*this.B - 4*this.A*this.C;
    dt = Math.sqrt(dt2);
    
    if(dt<0) 
      System.out.println("方程无解");
    else if (dt==0) 
      gen1 = (-this.B)/(2*this.A);
      System.out.println("方程的根为：" + gen1);
    else if (dt>0) 
      gen1 = (-this.B+dt)/(2*this.A);
      gen2 = (-this.B-dt)/(2*this.A);
      System.out.println("方程的根为：" + gen1 + "或" + gen2);
    
  


public class SunRise 

  public static void main(String[] args) 
    int a,b,c;
    Scanner sc = new Scanner(System.in);
    a=sc.nextInt();
    b=sc.nextInt();
    c=sc.nextInt();
    
    SquareEquation square = new SquareEquation(a, b, c);
    square.jisuan();

class MyPoint
  
  private double x;
  private double y;
  
  public MyPoint() 
    super();
    this.x = 0;
    this.y = 0;
  

  public MyPoint(double x, double y) 
    super();
    this.x = x;
    this.y = y;
  
  
  public double getD(MyPoint myPoint) 
    double d = 0;
    d = Math.sqrt((this.x-myPoint.x)*(this.x-myPoint.x)+(this.y-myPoint.y)*(this.y-myPoint.y));
    
    return d;
  


public class four 
  public static void main(String[] args) 
    Scanner sc = new Scanner(System.in);
    double x1,y1,x2,y2;
    x1 = sc.nextDouble();
    y1 = sc.nextDouble();
    x2 = sc.nextDouble();
    y2 = sc.nextDouble();
    MyPoint my1 = new MyPoint(x1, y1);
    MyPoint my2 = new MyPoint(x2, y2);
    double d = my1.getD(my2);
    System.out.println("两点间的距离为：" + d);