面向对象编程(一):类与对象 实训答案

面向对象编程(一):类与对象 实训答案
一、理解面向对象编程

1、下列关于面向对象编程的说法,正确的有:

A、只要使用Java语言解决问题,就是在使用面向对象编程思想解决问题。

B、对象是个体,从一组具有相同属性和类似行为的个体中可以抽象类,以后凡是要创建对象,只需要根据类来创建,而不需要从0开始创建,这体现了面向对象编程。

C、Java类的定义体现了封装性。

D、接口是面向对象编程的一大特性

E、要使用面向对象编程思想求解问题,首先要明确:待求解的问题涉及到的对象有哪几类,这些对象之间的相互关系如何。

F、不具备继承特性的语言,不是真正意义上的面向对象编程语言。

G、多态性就是一个对象存在多种不同的状态。
2、以下关于面向对象编程的说法,正确的有

A、面向对象编程是一种编程架构,它以类的设计为中心。

B、面向对象编程中,对象和实例通常指的是一个意思。

C、基于面向对象的思考问题的方式,是比基于面向过程的思考问题的方式更高层的抽象方式。

D、一个类是对一批对象的抽象

E、面向对象编程的主要工作是设计出可高度重用的类,由于程序中所需要的某些类往往已经由别人“造好了”,可以直接拿来用,因此,用好他人开发好的类,可以显著提高开发效率
3、关于面向对象编程的三大特性的说法,正确的有

A、类和对象体现抽象与具体的关系,是封装性的表现

B、封装性使得我们在使用类时,只需要关注它所提供的外部接口,而无需深入了解其内部实现。

C、继承性使得可以在已有的“类”的基础上,以最少的代码创建新的类。

D、一个类中可以定义多个名称相同,参数类型不同的方法,这是多态性的唯一表现。

答案:
1.BCEF
2.ABCDE
3.BC

二、类的定义与对象的创建
程序描述 输入三角形的三个边的边长,求三角形的面积。
本程序由两个源文件构成: Test.java:主类定义 Triangle.java:三角形类的定义 其中,Test.java中的代码如下:

import java.util.Scanner;
public class Test {
	public static void main(String[] args) {		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入三角形的三个边的长度:");
		double sideA = sc.nextDouble();
		double sideB = sc.nextDouble();
		double sideC = sc.nextDouble();
		
		Triangle t=new Triangle(sideA,sideB,sideC);
		System.out.printf("边长为(%.2f,%.2f,%.2f)的三角形面积为%.3f"
				,t.getSideA(),t.getSideB(),t.getSideC()
				,t.getArea());
		sc.close();
	}

}

Triangle.java

import java.lang.Math;
class Triangle{
    private double SideA;
    private double SideB;
    private double SideC;
    private double Area;
    public Triangle() {
    }

    public Triangle(double sideA, double sideB, double sideC) {
        SideA = sideA;
        SideB = sideB;
        SideC = sideC;
    }

    public double getSideA() {
        return SideA;
    }

    public void setSideA(double sideA) {
        SideA = sideA;
    }

    public double getSideB() {
        return SideB;
    }

    public void setSideB(double sideB) {
        SideB = sideB;
    }

    public double getSideC() {
        return SideC;
    }

    public void setSideC(double sideC) {
        SideC = sideC;
    }

    public double getArea() {
        Area = area(SideA,SideB,SideC);
        return Area;
    }

    public void setArea(double area) {
        Area = area;
    }

    public double area(double sideA ,double sideB,double sideC){
        double p = (sideA+sideB+sideC)/2;
        double area = Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC));
        return area;
    }
}

三、理解构造方法

1、以下关于构造方法的说法,正确的有:

A、构造方法是使用new创建对象时调用的方法,通常用于对一个类的实例的各个数据成员进行初始化。

B、在一个类的定义中,若没有包含构造方法的显式定义,则这种类是没有构造方法的。

C、一个Java类至少有一个构造方法,当开发者在定义类是没有提供构造方法,Java系统会自动提供默认的构造方法。

D、构造方法返回值为void

E、使用new创建一个类对象的前提条件是,这个类已经创建好了。

F、一个类的类体中可以定义多个构造方法,但一个类的实例在创建时,只能选择其中的一个构造方法加以调用。
对于构造方法的理解,正确的有

A、构造方法在外在表现形式上的特殊地方在于它与类名相同,由于其返回值约定为void,因此,通常定义时,省略void。

B、构造方法是对象创建时调用的方法,通常用于执行对象内部的数据成员的一些初始化操作。

C、若定义一个类时,没有提供构造方法的定义,则这个类是没有构造方法的类。

D、只要在一个类中定义了一个构造方法,Java编译器便不会提供默认构造方法。

答案:
1.ACDEF
2.ABD

四、构造方法的运用
任务描述
本关任务:编写一个程序,使程序的输出满足测试结果的要求。
程序包含两个文件:
Test4.java:主类定义文件
MyClass.java:MyClass类的定义文件
Test4.java中的代码如下:

 public class Test4 {
    
    public static void main(String[] args) {
        
        MyClass m=new MyClass();
        m.showMemberInfo();
        m=new MyClass(24);
        m.showMemberInfo();
    }
    
}

class MyClass

  public class MyClass {
	public int m1=2;
	
	public void showMemberInfo() {
		System.out.printf("m1=%d\n",m1);
	}
	//begin
    public MyClass(){
        System.out.print("object constructing...\nconstructing finished!\n");

    }
	public MyClass(int m1){
        this.m1 = m1;
    }
	//end
}

五、根据要求完成类的定义
任务描述
本关任务:本程序可实现两个整数的值的交换。主类(Test)的代码已经给出,你只需要完成所需的类中的代码,使主类可以正常运行。以下是主类(Test.java)中的代码:

 import java.util.Scanner;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int a1=sc.nextInt();
		int b1=sc.nextInt();
		MyNumber numA=new MyNumber(a1);
		MyNumber numB=new MyNumber(b1);
		System.out.printf("a1=%d,b1=%d\n",numA.getNumber(),numB.getNumber());
		MyNumber.swap(numA,numB);
		System.out.printf("a1=%d,b1=%d", numA.getNumber(),numB.getNumber());
		sc.close();
	}

}

相关知识
为了完成本关任务,你需要掌握:1.类的方法和对象方法,2.对象变量是对内存中的对象的引用。

测试说明
平台会对你编写的代码进行测试:

测试输入:4 91
预期输出:
a1=45,b1=67
a1=67,b1=45

这里要从内存上理解,每次new生成的对象存放在不同的地址中,需要调用

 public class MyNumber {
    private int number;

    public MyNumber() {
    }

    public MyNumber(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public static void swap(MyNumber a, MyNumber b){
        int temp = a.getNumber();
        a.setNumber(b.getNumber());
        b.setNumber(temp);
    }
}

六、任务描述
本关任务:编写一个能进行矩阵乘法运算的程序。
A×B,当A的列数和B的行数相同时,能进行矩阵运算。
本程序的主类源文件(Test.java)已经创建好了,其中代码如下:

import java.util.Scanner;
public class Test {
    public static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        System.out.println("请输入矩阵A的行列数(空格间隔)");
        int rowNum=sc.nextInt();
        int colNum=sc.nextInt();
        System.out.println("请逐行输入矩阵A的元素值(每输入一行回车一次,同一行相邻元素用空格分隔)");
        
        double[][] arrA = inputArray(rowNum, colNum);
        System.out.println("请输入矩阵B的行列数(空格间隔)");
        rowNum=sc.nextInt();
        colNum=sc.nextInt();
        System.out.println("请逐行输入矩阵B的元素值(每输入一行回车一次,同一行相邻元素用空格分隔)");
        double[][] arrB = inputArray(rowNum, colNum);
        
        Matrix matA = new Matrix(arrA);
        Matrix matB = new Matrix(arrB);
        // 执行矩阵乘法,关于矩阵乘法的定义,请参考线性代数相关知识或百度查询
        Matrix matC = matA.multiply(matB);
        // 输出矩阵乘法的结果,注:这里实际上隐含着调用matC.toString(),因此,Matrix要定义toString方法,返回矩阵的字符串表示
        System.out.println(matC);
        Test.sc.close();
    }
    /**
     * 输入一个二维数组,并返回这个数组的引用
     * 
     * @param row 行数
     * @param col 列数
     * @return 数组的引用
     */
    public static double[][] inputArray(int row, int col) {
        double[][] a = new double[row][col];
        for (int r = 0; r < row; r++) {
            for (int c = 0; c < col; c++) {
                a[r][c] = sc.nextDouble();
            }
        }
        return a;
    }
}

相关知识
为了完成本关任务,你需要掌握:1.类的定义2.类的成员和对象的成员。

编程要求
在右侧编辑器补充代码。

测试说明
平台会对你编写的代码进行测试,以下是某个用例下的测试结果画面:
请输入矩阵A的行列数(空格间隔)
3 2
请逐行输入矩阵A的元素值(每输入一行回车一次,同一行相邻元素用空格分隔)
1 2
3 4
5 6
请输入矩阵B的行列数(空格间隔)
2 2
请逐行输入矩阵B的元素值(每输入一行回车一次,同一行相邻元素用空格分隔)
1.4 45
34 0
[
[69.400 45.000 ]
[140.200 135.000 ]
[211.000 225.000 ]
]
Matrix.java

public class Matrix {
    public double [][] arr;
    public Matrix() {
    }

    public Matrix(double[][] arr) {
        this.arr = arr;
    }

    public Matrix multiply(Matrix matB){
        Matrix matC = new Matrix();
        matC.arr = new double[this.arr.length][matB.arr[0].length];
        for(int i=0;i<this.arr.length;i++){
            for(int j=0;j<matB.arr[0].length;j++){
                matC.arr[i][j] = 0;
                for(int k=0;k<this.arr[0].length;k++){
                    matC.arr[i][j] += this.arr[i][k]*matB.arr[k][j];
                }
            }
        }
        return matC;
    }

    public String toString(){
        String result = "[\n";
        for(int i=0;i<arr.length;i++){
            result+="[";
            for(int j=0;j<arr[0].length;j++){
                result+=arr[i][j]+"00 ";
            }
            result += "]\n";
        }
        result+="]\n";
        return result;
    }
}

七、类之间的关系的UML图描述

1、有关复杂的类的实现,说法正确的有

A、复杂的类对象分解为简单的类对象的组合,这是实现复杂的类的方法之一

B、如果一些类之间存在明显的继承关系,就可以使用继承来实现类的设计,这也是一种实现复杂的类的方法。

C、分解与组合的方法,在代码上的表现往往就是:某个类的一些数据成员的数据类型为另外一些类

D、我们要使用Java类库,只需要知道库中的类的用法,没必要知道这个类和其他类的关系。
2、有关类的关系及其UML图的表示,说法正确的有

A、UML图,仅用于描述一个类和他类之间的关系

B、UML图,只针对Java语言,对其他编程语言的开发者,没有意义。

C、继承关系、实现关系从代码外部接口就可以看出来,而组合、聚合、关联这三种关系,如果没有清晰的UML图,仅从类的外部接口代码,不好相互区分。

D、类A组合于B,意味着,A类的对象创建后,其中包含着B类对象的创建,当A类对象被垃圾回收器回收时,其内部的B类对象也自动会被回收。

E、关联关系比依赖关系要强,A关联于B,则A的定义中包含了B类的数据成员。A依赖于B,仅表明A中的某个方法的定义中用到了B。

答案:
1.ABC
2.CDE

八、包的定义与使用

1、下列关于Java包的说法,不正确的有

A、Java标准库、第三方的商业类库,都是按包的方式来管理众多的类

B、Java标准库中的某些类,如Math类,在使用时,不必使用import语句导入,是因为这些类所在的包为匿名包

C、开发大型应用程序时,利用包的机制管理好大量自定义的类,是一个值得推荐的做法

D、用户声明的包可以分层次,例如“cn.guet”是一个具有2个层级的包,它要求在应用程序顶层目录下有对应的二级子目录:“cn\guet”,这个包下的类,例如cn.guet.ClassA,编译后对应的class文件,则不一定非要放到guet子目录下。

E、同一个包中的类所在的源文件没有必要存入同一个目录,只需要文件开头有相同的package声明语句就可以了。
2、下列关于Java包的用法,不正确的有

A、多个源文件中开头有声明语句”package imagan.file;”,表示这些源文件中定义的类都隶属于imagan.file这个包。

B、源文件“ClassA.java”和源文件“ClassB.java”中都有一条声明语句“package guet.myclass;”,且ClassA关联于ClassB,则在ClassA.java文件中必须有import guet.myclass.ClassB或 import guet.myclass.*语句。

C、已知类classA位于cn包中,而classB位于cn.test包中,则在classA的定义中,要引用classB,可以使用“import test;”语句(test前面的cn.可以省略)。

D、在某个源文件中要使用位于不同包中的两个类,而这两个类的类名是相同的,为了向编译器指明当前要使用的类,有必要在类名前加包名前缀。
3、程序中要用到第三方Java扩展库中的某个类DemoClass,该类位于包guet.imagan中,则在需要用到该类的源文件中可以加入的语句,正确的有:

A、
package guet.imagan.DemoClass;

B、
import guet.imagan.*;

C、
from guet.imagan import DemoClass;

D、
import guet.imagan.DemoClass;

答案:
1.BDE
2.BC
3.BD

九、类的外部访问权限的理解

1、下列关于Java类的外部访问权限的说法,正确的有

A、外部访问权限的合理设计,有利于类使用的安全性和方便性

B、外部访问权限的控制,是通过public. protected. private等几个关键字来设置的

C、某个类DemoClass的名称前没有加public关键字,则其他类都不能直接引用DemoClass

D、加了private关键字的方法成员或数据成员,是不能在该成员所在的类体以外任何地方直接访问的,连当前类的子类也不能直接访问
2、要设计一个名为“MyClass”的类,它包含数据成员“member1”和“member2”、方法成员“func1”和“func2”,希望:任何其他类(包括子类)都不能直接读写“member1”,只有同一个包中的类可以直接读写“member2”,子类不能继承“member2”;任何其他类都可以调用“func1”,而只有同一个包中的类以及MyClass的子类可以直接调用“func2”,则“MyClass”、“member1”、“member2”、“func1”、“func2”前面的权限控制关键字分别为

A、
public, 不加关键字,privatepublic, protected

B、
public, private, 不加关键字,protected, public

C、
public, protected, 不加关键字,public, private 

D、
public, private, 不加关键字,public, protected

答案:
1.ABD
2.D

十、基本数据类型的类包装

1public class Test{
public static void swap(Integer a,Integer b) {
        Integer c=a;
        a=b;
        b=c;
}
    public static void main(String[]args){
        Integer a=3;
        Integer b=4;
        swap(a,b);
        System.out.println(a+”,”+b);
    }
}
请问上述代码的执行结果怎样?(请注意,通过这个例子,要总结出基本数据类型进行类封装后,对象变量到底表示的是值,还是对象的引用)。(A)

A、
3,4

B、
3,3

C、
4,4

D、
4,3
2、以下Java代码正确的有

A、
Int a=5;

B、
Bool t=true;

C、
Byte a=123;Char b=‘A’;

D、
double a=10.34; Double b=a;

E、
Float a=3.1415f;
3、以下有关字符串与数值间的相互转换的代码,正确的有

A、
int e=Integer.valueOf(1234);

B、
Float e= Float.valueOf(1234);

C、
String s1=4;

D、
String s1=String.valueOf(4);

E、
Double a=4.6;String s1=a.toString();

答案:
1.A
2.DE
3.ABDE

十一、带可变参数的方法
任务描述
本关任务:根据程序的提示,补充完整代码。

相关知识
为了完成本关任务,你需要掌握:1.了解什么是可变参数2.如何使用可变参数。

编程要求
根据提示,在右侧编辑器补充代码,计算并输出任意多个输的均值。

public class Test {
	public static void main(String[] args) {
        //求两个数的均值
		System.out.printf("%.2f\n",Test.getAve(2,3));
        //求三个数的均值
		System.out.printf("%.2f",Test.getAve(2,3,4));
	}
    //请在1、2处补充代码,不允许在其他地方修改或添加代码
	public static double getAve(int ... x) {
        double sum = 0;
        for(int i = 0;i<x.length;i++){
            sum = sum + x[i];
        }
        return sum/x.length;
    }
}

1.这里给出我一些对new的理解,当你new之后,生成的对象是在不同的地址的,通过带参构造的new,调用同一个类的不同构造对象,数据不同。
2.构造可以理解为一个箱子,保护里面的数据,里面的参数用private进行保护,调用的时候要用get,设置时用set。
3.在idea中可以使用快捷键生成
Alt+Insert
在这里插入图片描述
第一个是构造函数的快捷生成
第四个是get和set的快捷生成
第六个是toString()方法,要改自己改

(单纯分享,希望过了的同学能在老师答疑时间去把不懂的地方问清楚,用辅导员的话来说,都是成年人了!想想自己以后工作问题,或者说,你的未来。我们客观一点,来到这里,是你曾经努力或者不努力的结果,但现在,我希望我们专业的同学能离开宿舍,离开小视频,离开峡谷,去图书馆,去四创,去那些能让你学习的地方。我们反思一下,我们为什么选到这个专业,或者说你本来就喜欢这个专业,觉得前景好,亦或许你是成绩不够,被迫选到这个,但我告诉你,学校教给你的是专业,出去人家要的是专长,其实都差不多的,你的未来,在你的手上,我们要用未来5年后的自己的眼光来看现在的自己,你努力了吗?不要跟我说什么你毕业不干这行,你以为全部考试过了你就能干这行?但至少,拿到毕业证和学位证是你现在该干的事,不是吗?)
在此声明,我不是什么厉害的人,只是一个突然后悔曾经或者说高中不努力的普通人,写这些话也只是因为希望能有更多一起努力的人罢了,或许会有些非本校的朋友或者非本专业的朋友看到这些,希望不要取笑,毕竟,我们都是在为梦想不断努力奋斗的人,难道不是吗?

  • 18
    点赞
  • 19
    收藏
  • 打赏
    打赏
  • 5
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:数字20 设计师:CSDN官方博客 返回首页
评论 5

打赏作者

有的知识不应付费

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值