【实验三/四面向对象程序设计/语言基础与面向对象】

最新推荐文章于 2023-03-30 19:54:14 发布

木哩个言

最新推荐文章于 2023-03-30 19:54:14 发布

阅读量1k

点赞数 1

文章标签：矩阵 java 线性代数

本文链接：https://blog.csdn.net/weixin_45839448/article/details/121594439

版权

一、实验目的和要求

掌握类、对象、方法、继承、接口的编程技术。

要求至少完成实验内容题的70%。（分工合作）

二、实验内容

1．求最大公约数

题目：编一程序，求两个正整数m、n的最大公约数。要求程序中有两个方法，分别使用循环和递归求最大公约数，最后在主方法中分别调用这两个方法求解56与91的最大公约数。

   提示：用辗转相除法。

方法：(1) 求m除n的余数r；

         (2) 如果r为0，则n为最大公约数，结束。否则转(3);

         (3) 用n置m，用r置n ，回到(1)。

package com.company;
import java.util.Scanner;
public class GCD
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int i=sc.nextInt();
        int j=sc.nextInt();
        int common_divisor=gcd(i,j);
        System.out.println("最大公约数为："+common_divisor);
        //最小公倍数：int least_common_multiply=i*j/common_divisor
    }

    //辗转相除法求最大公约数
    public static int gcd(int a,int b)
    {
        //递归法
        if(b==0)
            return a;
        return gcd(b,a%b);
        /*非递归，循环
        while(b!=0)
        {
            int remainder=a%b;//定义余数
            a=b;
            b=remainder;
         }
         return a;
         */
    }
    /*// n个整数的最大公约数
    // arr[0] ---arr[n-1]的最大公约数，等于arr[0]
    // 即gcd(arr[0], arr[1]...,arr[i]) = gcd((arr[i]...(gcd(arr[0], arr[1])))
    public static int gcdArray(int [] arr)
    {
        int temp = arr[0];
        for(int i=1; i<arr.length; i++)
        {
            temp = gcd(temp, arr[i]);  //循环调用gcd()方法，注意将temp放在gcd()方法中
        }
        return temp;
    }   */
}

运行截图：

2．复数

题目：编写一个完整的Java Application程序，其中设计一个复数类Complex，利用它验证两个复数 1+2i 和3+4i 相加产生一个新的复数 4+6i 。复数类Complex的设计必须满足如下要求：

1）Complex 的属性有：

realPart：int型，代表复数的实数部分；

maginPart：int型，代表复数的虚数部分。

2）Complex 的方法有：

Complex()：构造方法，将复数的实部和虚部都置0；

Complex(int r , int i )：构造方法，形参 r 为实部的初值，i为虚部的初值。

3）Complex complexAdd(Complex a)：将当前复数对象与形参复数对象相加，最后的结果仍是一个复数对象，返回给此方法的调用者。

4）String toString(): 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

package com.company;
public class Complexx {
    public static void main(String[] args)
    {
        Complex a=new Complex(1,2);
        Complex b=new Complex(3,4);
        System.out.println("a="+a.ToString());
        System.out.println("b="+b.ToString());
        Complex c=a.complexAdd(b);
        System.out.println("a+b="+c.ToString());
    }
}
class Complex{
    int RealPart;    //复数的实数部分
    int ImaginPart;    //复数的虚数部分
    Complex(){    //构造方法，将复数的实部和虚部都置为零
        RealPart=0;
        ImaginPart=0;
    }
    Complex(int r,int i){
        RealPart=r;
        ImaginPart=i;
    }
    Complex complexAdd(Complex a){    //将当前复数对象与形参复数对象相加，最后的结果仍是一个复数对象，返回给此方法的调用者。
        this.RealPart+=a.RealPart;
        this.ImaginPart+=a.ImaginPart;
        return this;
    }
    String ToString(){    //把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。
        String str=RealPart+"+"+ImaginPart+"i";
        return str;
    }
}

运行截图：

5．编写一个含有5个类的程序

题目：编写一个含有5个类的程序：

      类Person:

          属性：编号、姓名、性别；

          构造方法：确定编号和姓名；

          一般方法：修改编号、姓名，获取编号、姓名。

      类Teacher：继承类Person并增加：

          属性：系别；

          构造方法：调用父类的构造方法；

          一般方法：修改、获取系别。

      类Student：继承类Person并增加：

          属性：班级；

          构造方法：调用父类的构造方法；

          一般方法：修改、获取班级属性值。

      类Classes：

          属性：班级名称，学生名单(Student类对象的数组)；

          构造方法：确定班级名称；

          一般方法：建立学生名单，输出学生名单。

      类Main：

主类。主方法中创建一个班级，然后建立该班级的学生名单，最后输出学生名单。

package com.company;
import java.io.*;

import static java.lang.Integer.parseInt;
//import java.lang.Integer;
//import static java.lang.Integer.parseInt;

public class JavaFive {           //主类
    public static void main(String args[]) throws IOException{
        byte buf[]=new byte[20];
        String str,classroom,name;
        int n,id,i;

        System.out.println("请输入班级名：");
        System.in.read(buf);
        classroom=new String(buf);
        Classes classes=new Classes(classroom);  //创建班级

        System.out.println("请输入班级人数：");
        System.in.read(buf);
        str=new String(buf);
        n= Integer.parseInt(str.trim());

        System.out.println("请输入学生的学号和姓名");    //创建该班级学生名单
        for(i=0;i<n;i++){
            System.in.read(buf);
            str=new String(buf);
            id= Integer.parseInt(str.trim());

            System.in.read(buf);
            name=new String(buf);
            Student student=new Student(id,name);
            classes.BuildStudentList(i,student);
        }
        classes.getStudentList(n);
    }
}
class Person{
    public int id;    //编号
    public String sex;    //性别
    public String name;    //姓名

    public Person(){}
    public Person(int id,String name){     //确定编号和姓名
        this.id=id;
        this.name=name;
    }
    public void change(int newid,String newname){    //修改
        id=newid;
        name=newname;
    }
    public void get(){    //获取
        System.out.println(id+" "+name.trim());
    }
}

class Teacher extends Person{    //继承Person，调用父类构造方法
    public String department;    //系别

    public Teacher(){
        super();
    }
    public Teacher(int id,String name){
        super(id,name);
    }
    public void changeDepartment(String newdepartment){    //修改
        department=newdepartment;
    }
    public void getDepartment(){    //获取
        System.out.println("Department "+department);
    }
}
class Student extends Person{    //继承Person，调用父类的构造方法
    public String classroom;    //班级

    public Student(){
        super();
    }
    public Student(int id,String name){
        super(id,name);
    }
    public void changeClassroom(String newclassroom){    //修改
        classroom=newclassroom;
    }
    public void getClassroom(){    //获取
        System.out.println("Classroom "+classroom);
    }
}
class Classes{
    public String className;    //班级名称
    public Student str[]=new Student[100];    //学生名单

    public Classes(String className){    //确定班级名称
        this.className=className;
    }
    public void BuildStudentList(int i,Student student){    //建立学生名单
        str[i]=student;
    }
    public void getStudentList(int n){
        int i;
        for(i=0;i<n;i++){
            str[i].get();
        }
    }
}

运行截图：

三、参考

编写一个含有5个类的程序

四、其他实验内容

【实验三面向对象程序设计】

3．编写一个含圆类的程序

题目：编写一个包含圆类的程序，并为圆类设计几个构造方法和一般方法，在主方法中创建一个圆类对象并输出它的周长和面积。

要求：

    属性有3个：x,y,r，分别放置圆心坐标和半径；

    构造方法有2个。一个是无参的，用于设置3个属性的值都为0；另一个有参的，用于设置3个属性的值，以确定一个具体的圆。

    计算周长的方法：double zc()；

计算面积的方法：double mj()。

4．含圆类、圆柱类和主类的程序

题目：编写一个程序，它含有一个圆类、圆柱类和主类。

要求：

    1）圆类参考上一题中的圆类；

    2）圆柱类：继承圆类，并加入一个属性h(高)；

              构造方法(给4个属性赋值)；

              计算面积的方法(double mj())；

              计算体积的方法(double tj())。

       注意，要充分利用父类的方法。

    3）主类：在主方法中创建圆和圆柱类的对象，然后计算并输出它们的面积及圆柱的体积。

引用：编写一个包含圆类的程序https://blog.csdn.net/qq_45670844/article/details/122052990?spm=1001.2014.3001.5502https://blog.csdn.net/qq_45670844/article/details/122052990?spm=1001.2014.3001.5502

6．阅读程序，验证输出结果

请仔细阅读下面的程序，分析程序的结构和输出结果。再将程序上机运行，验证输出结果。（重点理解：抽象类、抽象方法、(匿名)内部类、匿名对象）

abstract class A{abstract String getS();}

class Test

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

System.out.println(new A(){ String getS(){ return "抽象？匿名？";}}.getS());

}

}

7．请仔细阅读下面的程序，分析程序的结构和输出结果。再将程序上机运行，验证输出结果。

（重点理解：接口、接口实现方法、(匿名)内部类、匿名对象）

interface I{ String getS(); }

class Test

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

System.out.println(new I(){ public String getS()

{ return "接口和内部类！";}}.getS());

}

}

（请比较本程序与上题程序的不同之处）

引用：阅读程序并比较https://blog.csdn.net/qq_45670844/article/details/122052990?spm=1001.2014.3001.5502https://blog.csdn.net/qq_45670844/article/details/122052990?spm=1001.2014.3001.5502

【实验四语言基础与面向对象】

1．阅读程序，确定输出结果

题目：请先阅读下面的程序，确定它的输出结果。再将程序上机运行，验证自己分析的输出结果是否正确。

class Yuan

{ int r; String name; static int z= 5;

  Yuan(int r){ this.r=r; }

int a(){ return z*r*r; }

  int p(){ return 5*z*r; }

  void value (){ name="china"; }

}

class testOverride extends Yuan

{ int h; String name;

testOverride(int r,int h1) { super(r); h=h1; }

int a(){ value(); return 2*super.a()+p()*h; }

void value()

{ super.value();

name="America";

System.out.println("\""+this.name+"\"");

System.out.println(super.name);

}

public static void main(String args[])

{ Yuan y= new Yuan(4);

Yuan yz= new testOverride(5,2);

    System.out.println(y.a());

  System.out.println(yz.p());

   System.out.println(yz.a());

}

}

2．请先阅读下面的程序，确定它的输出结果。再将程序上机运行，验证自己分析的输出结果是否正确。

public class TestTransOfValue

{public static void main(String args[])

{ double val;

StringBuffer sb1, sb2;

String sb3;

char s[]={'a','p','p','l','e'};

val = 5.8;

sb1 = new StringBuffer("apples");

sb2=new StringBuffer("pears");

sb3 = new String("pear");

modify(val, sb1, sb2,sb3,s);

System.out.println(val);

System.out.println(sb1);

System.out.println(sb2);

System.out.println(sb3);

System.out.println(s);

}

public static void modify(double a, StringBuffer r1,

             StringBuffer r2,String r3,char s[] )

  { a = 6.8;

    r1.append(" taste good");

    r2=null;

    r3="banana";

    s[2]='R';       }

}

3．设计矩阵类并计算

题目：编写一个程序，其中设计一个矩阵类Matrix，

最后计算：

要求Matrix类满足：

1）Matrix的属性有：

m,n：int型，矩阵的行、列数；

ma：int型两维数组，放置矩阵的数据。

2）Matrix的方法有：

Matrix (int m , int n )：构造方法，设置矩阵的行数和列数；

cheng(Matrix a)：将当前矩阵与形参矩阵相乘，最后返回乘的结果(Matrix对象)； void print()：输出矩阵。

4．请仔细阅读下面的程序，分析程序的结构和输出结果。再将程序上机运行，验证输出结果。（注意重点理解：内部类、对象内部类、静态内部类）

public class Outer

{ public Outer(){System.out.println("OuterClass Object!");}

  private class Inner1

   { private Inner1(String s){ System.out.println(s);} }

  static class Inner2

{ Inner2(String s){ System.out.println(s);} }

  public static void main(String[] args)

   { Outer ob= new T();

     Outer.Inner1 ib1 = ob.new Inner1("InnerClass1 Object!");

     Inner2 ib2=new Inner2("InnerClass2 Object!");

    }

  }

请再尝试将:

Outer.Inner1 ib1 = ob.new Inner1("InnerClass1 Object!");

改为:

    ob.Inner1 ib1 = ob.new Inner1("InnerClass1 Object!");

看有什么变化。

引用：实验四1~4https://blog.csdn.net/d1ngaa/article/details/122051059?utm_source=app&app_version=4.21.0&code=app_1562916241&uLinkId=usr1mkqgl919blenhttps://blog.csdn.net/d1ngaa/article/details/122051059?utm_source=app&app_version=4.21.0&code=app_1562916241&uLinkId=usr1mkqgl919blen

5．接口、抽象类、继承、多态

题目：请仔细阅读下面的程序，分析程序的结构和输出结果。由此理解接口、抽象类、继承、实现接口，进一步理解多态。

interface Food

{ public void doEat();}     // doEat()是吃食物的方法

abstract class Fruit{}      //水果抽象类

abstract class Meat{ }      //肉抽象类

class Apple extends Fruit implements Food//苹果类

{ public void doEat()

  { System.out.println("我是苹果，属于水果类，你不必烹饪我就可吃！"); }

}

class Beef extends Meat implements Food        //牛肉类

{ public void doEat()

  {System.out.println("我是牛肉，属于肉类，必须烹饪后才可吃！"); }

}

public class Use

{ public static void main(String args[])

  { Food f=new Apple();

    f.doEat();

    f=new Beef();

    f.doEat();        // 两个“f.doEat()”体现了多态

}

}

试一试将主方法改为：

public static void main(String args[])

{  Food f=new Apple(); f.doEat();  }

观察系统有何反应？

再在Fruit类中加入方法“abstract void doEat();” ，看结果怎样，你能得出什么结论？

6．设计一个程序，其中含有一个接口Shape(形状)，其中有求形状的面积的方法area()。再定义三个实现接口的类：三角型类、矩形类和圆类。在主方法中创建Shape类型的一维数组，它有三个元素，放置三个对象，分别表示三角形、矩形和圆，然后利用循环输出三个图形的面积。

( 注：三角形面积s=Math.sqrt(p*(p-a)*(p-b)*(p-c))，a,b,c为三条边，p=(a+b+c)/2 )

引用：实验四5~6https://blog.csdn.net/qq_45959399/article/details/122053506https://blog.csdn.net/qq_45959399/article/details/122053506

木哩个言

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
【实验三/四面向对象程序设计/语言基础与面向对象】

package com.company;import java.util.Scanner;import java.io.IOException;public class Divisor { public static void fac(int m, int n, int r){ r=m%n; if(r==0) System.out.println(n+"是正整数56和91的最大公约数."); else ...
复制链接

扫一扫