练习题

最新推荐文章于 2023-12-26 21:40:27 发布

摆渡D人

最新推荐文章于 2023-12-26 21:40:27 发布

阅读量2.9k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.csdn.net/qq_41131048/article/details/96016715

这是一份综合性的编程与选择题集合，涉及计算、逻辑判断、数据结构和算法等多个方面。题目包括收银台找零、个人所得税计算、控制台输入处理、数组操作、选择题（如Java数组、面向对象特性等）以及编程题（如计算数字和、阶乘、水仙花数等）。这些题目旨在考察和提高编程者的基本功和问题解决能力。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一些常见的面试题

1.指出编译错误，并改正

int balance;
balance = 218.50;

2.指出编译错误或运行结果，并解释原因

int i = 128;
i = 10000000008;
System.out.println(i);

3.打印结果

double x = 2.0;
double y = 1.9;
System.out.println(x-y);

4.收银台收款程序
编写一个收银台的收款程序，根据输入的商品大家，购买数量及
收款金额，计算出应收金额和找零；
当总价大于或等于500时，打8折；
如果收款金额小于应收金额时，输出提示信息

5.输出结果

int a,b,c;
a = b =c=100;
System.out.println(a+""+b+""+c);

6.编写个人所得税计算程序
个人所得税是国家对本国公民，居住在本国境内的个人的所得和境外个人来源于本国的所得征收的一种所得税。目前，北京地区的个人所得税的计算公式是：应纳税额 = （工资薪金所得-扣除数）*适用税率-速算扣除数。其中，扣除数为3500，使用税率以及速算扣除数如下表所示。

全月应纳税所得额税率速算扣除数（元）
全月应纳税额不超过1500元 3% 0
全月应纳税额超过1500至4500 10% 105
全月应纳税额超过4500至9000 20% 555
全月应纳税额超过9000至35000 25% 1005
全月应纳税额超过35000至55000 30% 2755
全月应纳税额超过55000至80000 35% 5505
全月应纳税额超过80000 45% 13505

上表中的全月应纳税所得额 = 工资薪金所得 - 扣除数。
本案例要求计算个人所得税的缴纳额度：用户从控制台输入税前工资的金额，
程序计算所需要缴纳的个人所得税的金额，并将计算结果输出到控制台。

7.控制台输入两个int数，输出最大值

8.控制台输入三个int数，输出最大值

9.控制台输入三个int数，升序排序

10.接收控制台输入的年和月份，输出该年该月有多少天

比如 2000年2月，共29天

11.猜数游戏：
while，do…while

12.百钱百鸡
3文钱1只公鸡，2文钱1只母鸡，1文钱3只小鸡；
100文钱如何买恰好100只鸡？
分析：先定义一个循环表示公鸡，嵌套一个循环表示母鸡，
计算小鸡的个数，根据各种鸡的个数来计算钱数是否为10012.

对于代码：
public class Test {
public static void main(String[] args){
int i = 3;
if(i < 3)
System.out.println(“haha”);
System.out.println(“hehe”);
}
}
的输出结果是：
A. haha　　B. hehe　　C. haha hehe　　D. hehe haha　　E. 编译时报错
对于代码：
public class Test {
public static void main(String[] args){
int i = 0;
while(i<10);
{
System.out.println(i);
i++;
}
}
}
的运行结果是：
A. 0　　B. 1　　C. 10　　D. 编译报错　　E. 没有输出
对于代码：
public class Test {
public static void main(String[] args){
int i = 5;
switch(i){
default:
int y = 5;
case 4:
y += 4;
case 3:
y += 3;
break;
case 2:
y += 2;
case 1:
y += 1;
}
System.out.println(y);
}
}
的运行结果是：
A.15　　B. 12　　C. 9　　D. 5　　E. 编译时报错
对于代码：
public class Test {
public static void main(String[] args){
Outer:for(int i = 1; i < 3 ; i++) {
Inner:for(int j = 1; j < 3; j++) {
if(j == 2)
continue Outer;
System.out.println(i + “,” + j);
}
}
}
}
的运行结果是：
A. 1,1　　B. 1,2　　C. 2,1　　D. 2,2　　E. 编译时报错

二、编程题

1.读入一个三位数，计算其各位数字之和。例如： 123,各位数字之和为6
2. 计算1+2+3+…+100 的和
3. 计算1+3+5+…+99 的和
4. 读入一个小于10 的整数n，输出它的阶乘n!
5. 求100 以内所有能被3 整除但不能被5 整除的数字的和。
6. “百钱买百鸡”是我国古代的著名数学题。题目这样描述：3文钱可以买1只公鸡，2文钱可以买一只母鸡，1文钱可以买3只小鸡。用100 文
钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？
7. 搬砖问题：36块砖，36人搬，男搬4，女搬3，两个小孩抬1砖，要求一次全搬完，问男、女和小孩各若干？
8. 读入一个整数n，输出如下图形:
当输入 n=3时，输出:
*
***
*****
当输入n=4时，输出:
*
***
*****
*******
9. 输出99 乘法表
10. 求水仙花数。所谓水仙花数，是指一个三位数abc，如果满足a3 + b3 + c3 = abc，则abc是水仙花数。
11. 输入一个整数，计算它各位上数字的和。（注意：是任意位的整数）
12. 输入一整数A，判断它是否质数。
选择题
13. 下列关于数组的说法正确的是：
A. 在Java中数组的长度是可变的
B. 数组中存储的数据的类型是相同的
C. 数组在进行扩容操作的时候源数组的地址不发生改变
D. int[] arr = new int[3]; arr = new int[10];是将数组的大小扩容到了10且数组中的元素依然保留了下来
E. 数组是存储到栈内存中的。
14. 下列各项中关于数组的定义正确的是：
A. int[][] arr = new int[2][];　　B. int[2][] arr = new int[][3];
C. int[] arr[] = new int[2][2];　　D. int arr[][] = new int[3][];
E. int[3][3] arr = new int[][];
15. 已知数组int[] x,y[]都已经初始化，则下列各项能够正确赋值的是：
A. y = x;　　B. y[0] = x;　　C. y = x[0];　　D. y[0] = x[0];　　E. y[0][0] = x[0];
16. 下列数组的声明有哪些是对的？错的应该怎么修改？
A. int[] a;
B. int a[] = new int[3];
C. int[] a;
a = {1,2,3,4,5};
D. int[] a = new int[3]{1,2,3};
一、选择题
17. 下列各项中的各项定义正确的是：
A. public static void m(){}
B. public void static m(){}
C. public static int m(){return 1.0;}
D. public static double m(){return ‘a’;}
E. public static m(){}
18. 对于代码：
public class Test {
public static int sum(int i, int j){
return i + j;
}
// 1
}
下列各项中可以放到//1处的是：
A.
public static int sum(int j, int i){
return i + j;
}
B.
public static void sum(int i){
return i * 2;
}
C.
public static int sums(int i, int j){
return i + j;
}
D.
public static int sum(double i, double j){
return i + j;
}
E.
public static char sum(char i, char j){
return i + j;
}
19. 对于代码：
public class Ex2 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
expand(a);
changeArray(a);
printArray(a);
}
public static void expand(int[] a){
int[] newArray = new int[a.length * 2];
System.arraycopy(a, 0, newArray, 0, a.length);
a = newArray;
}
public static void changeArray(int[] a){
a[0] = 10;
}
public static void printArray(int[] a){
for(int i = 0; i<a.length; i++){
System.out.print(a[i] + “\t”);
}
System.out.println();
}
}
结果为：
A. 10 2 3 4 5
B. 1 2 3 4 5
C. 10 2 3 4 5 0 0 0 0 0
D. 1 2 3 4 5 0 0 0 0 0
E. 编译报错
二、简答题

简述方法在定义过程中需要注意的问题
简述方法的重载
、
三、编程题
写一个函数add，接收两个整数作为参数，返回这两个整数的和。
写一个函数接收一个整数，打印这个整数的所有因子。
写一个函数，接收一个整数n，输出1+2+3+…+n的和。
写一个函数，接收一个正整数，输出这个正整数是一个几位数。
选择题
下列各项中关于面向对象及面向过程的说法错误的是：
A. 面向对象要重点关注的是流程中的每一个步骤
B. 面向对象一定是优于面向过程的
C. 如果事务相对复杂，可以考虑使用面向对象的方式来完成
D. 面向对象和面向过程都是常见的思维方式
对于代码:
class ClassA {
public void method(int value){
System.out.println(value);
}
public void method(){
System.out.println(value);
}
int value;
}
class Test {
public static void main(String[] args){
ClassA classA = new ClassA();
classA.value = 10;
classA.method();
classA.method(20);
}
}
结果为:
A. 编译不通过
B. 输出10 10
C. 输出10 20
D. 输出0 20
下列关于构造函数的说法正确的是：
A. 每个类中都有至少一个构造方法
B. 一个类中可以有多个构造方法
C. 构造方法可以有返回值
D. 构造方法可以有多个参数
E. 可以通过new关键字调用一个类的构造方法创建该类对象
对于代码：
class ClassA{
int value = 10;
}
public class Test{
public static void main(String[] args){
ClassA ca = new ClassA();
ca = getObject();
ca = getObject();
ca = getObject();
System.out.println(ca.value);
}
public static ClassA getObject(){
ClassA newObject = new ClassA();
newObject.value += 10;
return newObject;
}
}
结果为：
A. 编译出错
B. 输出10
C. 输出20
D. 输出40
D. 输出0
对于代码:
class ClassA {
public ClassA() {
System.out.println(“A”);
}
}
class ClassB {
public ClassB() {
System.out.println(“B”);
}
}
class ClassC {
ClassA a = new ClassA();
ClassB b;
public ClassC() {
System.out.println(“C”);
b = new ClassB();
}
}
public class Test {
public static void main(String[] args){
ClassC c = new ClassC();
}
}
的输出结果为:
A. 编译不通过
B. 输出A B C
C. 输出A C B
D. 输出C B A
对于代码:
class ClassA {
int value;
}
public class Test {
public static void main(String[] args){
int value = 10;
changeInt(value);
System.out.println(value);
ClassA ca = new ClassA();
ca.value = 10;
changeObject(ca);
System.out.println(ca.value);
}
public static void changeInt(int value){
value++;
}
public static void changeObject(ClassA ca){
ca.value++;
}
}
输出结果为:
A. 编译出错
B. 输出10 11
C. 输出10 10
D. 输出11 11
对于代码:
class ClassA {
int value;
}
public class Test {
public static void main(String[] args){
ClassA ca = new ClassA();
changeValue(ca);
System.out.println(ca.value);
changeRef(ca);
System.out.println(ca.value);
}
public static void changeValue(ClassA ca){
ca.value = 100;
}
public static void changeRef(ClassA ca){
ca = new ClassA();
ca.value = 200;
}
}
输出结果为:
A. 编译出错
B. 输出100 200
C. 输出100 100
D. 输出0 200
二、简答题
对应代码:
class ClassA {
void method(){
System.out.println(“method()”);
}
int method(int i){
System.out.println(“method(int)”);
}
public static void main(String[] args){
ClassA ca = new ClassA();
ca.method();
ca.method(10);
}
}
该程序能否编译通过？如果可以请写出运行结果；如果不可以请说明原因并修改。
对于代码:
class MyClass{
int value;
}
public class Test{
public static void main(String args[]){
int a = 10;
int b = a;
b ++ ;
System.out.println(a);
MyClass mc1 = new MyClass();
mc1.value = 10;
MyClass mc2 = mc1;
mc2.value ++;
System.out.println(mc1.value);
}
}
请写出运行结果。
对于代码
class MyClass{
int value;
}
public class TestMyClass{
public static void main(String args[]){
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass(10);
System.out.println(mc1.value);
System.out.println(mc2.value);
}
}
这个程序能否编译通过？如果可以，输出结果是什么？如果不可以，则应该如何修改？
程序改错
public class Student{
public void Student(){
}
void init(){
age = 10;
name = “limy”;
}
public Student(String name){
this.init();
this.name = name;
}
public Student(String name, int age){
this.init();
this(name);
this.age = age;
}
int age;
String name;
}
三、编程题
1.复数概念如下：
每个复数都有实部和虚部。例如， 3 + 5i，3为实部，5i为虚部。其中，i称为虚数单位，有ii = -1。
两个复数进行加法运算，运算时实部与实部相加，虚部与虚部相加。例如：
(1.5 – 3i) + (2.3 + 2.4i) = (1.5+2.3) + (-3 + 2.4)i = 3.8 – 0.6i
两个复数进行减法运算，与加法运算类似。
两个复数进行乘法运算，其过程如下：
(a+bi) * (c + di) = ac + adi + bci + bd(ii) = (ac-bd) + (ad+bc)i
例如：
（3+5i） （4+6i） = （34-56） +（36+4*5） i = -18 + 38i
写一个类Complex，用来表示复数。这个复数类具有两个属性： double real，表示实部； double im，表示虚部。并为Complex 类
增加add、 sub、 mul 方法，分别表示复数的加法、减法和乘法运算。其中， add 方法的声明如下：
public Complex add(Complex c) //表示当前Complex 对象与参数c对象相加
public Complex add(double real) //表示当前 Complex 对象与实数 real相加

一、选择题

下列各项说法中，关于内部类的说法错误的是：
A. 方法内部类可以使用当前外部类中的成员变量
B. 成员内部类可以使用当前外部类中的成员方法
C. 静态内部类可以使用当前外部类中的静态方法
D. 成员内部类中可以定义静态常量
E. java.lang.String可以声明一个匿名内部类 E.
下列关于包的说法正确的是：
A. 一个Java文件在中可以写多个package个语句
B. 可以通过import来声明一个包
C. 如果是同包类可以不用导包直接使用
D. 对于java.lang包下的类，不需要手动导包即可使用
E. import java.util.*表示导入util包下的所有类以及子包下的类
关于接口和抽象类，下列说法正确的是：
A．抽象类可以有构造方法，接口没有构造方法
B．抽象类可以有属性，接口没有属性
C．抽象类可以有非抽象方法，接口中都是抽象方法
D．抽象类和接口都不能创建对象
E．一个类最多可以继承一个抽象类，但是可以实现多个接口
Java 中的内部类包括
A. 成员内部类
B. 静态内部类
C. 局部内部类
D. 匿名内部类
E. 公开内部类
F. 抽象内部类
有下面代码
class OuterClass{
private int value1 = 100;
private static int value2 = 200;
public void method(int value3){
final int value4 = 400;
class InnerClass{
public void print(){
//1
}
}
}
}
问：下面哪些代码放在//1 处能够编译通过？
A. System.out.println(value1);
B. System.out.println(value2);
C. System.out.println(value3);
D. System.out.println(value4);
二、简答题
请简述接口和抽象类的区别
代码改错：
interface IA{
void m1();
int a = 100;
}
class MyClass implements IA{
void m1(){}
}
public class TestInterface{
public static void main(String args[]){
IA ia = new MyClass();
ia.m1();
System.out.println(IA.a);
}
}
有如下代码：
interface IA{
void ma();
}
interface IB extends IA{
void mb();
}interface IC{
void mc();
}
interface ID extends IB, IC{
void md();
}

如果有一个类 ClassE 实现 ID 接口，如果不希望 ClassE 是抽象的，则需要实现哪些方法？
把下面的代码补充完整
public class TestClassE{
public static void main(String args[]){
IC ic = new ClassE();
______________ //调用 ma 方法
______________ //调用 mb 方法
______________ //调用 mc 方法
______________ //调用 md 方法
}
}
写出下面代码的输出结果
public class TestClassE{
public static void main(String args[]){
IC ic = new ClassE();
System.out.println(ic instanceof IA);
System.out.println(ic instanceof IB);
System.out.println(ic instanceof IC);
System.out.println(ic instanceof ID);
System.out.println(ic instanceof ClassE);
}
}

写出下面代码的运行结果
interface IA{
void ma(IB ib);
}
interface IB{
void mb();
}
class IAImpl implements IA{
public void ma(IB ib){
System.out.println(“ma in IAImpl” );
ib.mb();
}
}
class IBImpl implements IB{
private IA ia;
public void setIa(IA ia){
this.ia = ia;
}
public void mb(){
System.out.println(“mb in IBImpl” );
}
public void method(){
ia.ma(this);
}
}
public class TestMain{
public static void main(String args[]){
IA ia = new IAImpl();
IBImpl ib = new IBImpl();
ib.setIa(ia);
ib.method();
}
}
写出下面代码执行的结果
interface IA{
void ma();
}
class MyClass {
public static void method(IA ia){
System.out.println(“in method” );
ia.ma();
}
}
public class TestInnerClass{
public static void main(String args[]){
MyClass.method(new IA(){
public void ma(){
System.out.println(“ma in anonymous inner class” );
}
});
class MyMaClass implements IA{
public void ma(){
System.out.println(“ma in local inner class” );
}
}
MyClass.method(new MyMaClass());
}
}
三、编程题
定义一个接口 MediaPlayer，表示家庭影院的一个设备。 MediaPlayer 中包含 play()， stop()， open()三个方法，分别表示
播放、停止和开仓功能。MediaPlayer 有三个实现类，分别为： DVDPlayer，表示 DVD 播放器； CDPlayer，表示 CD 播放器；
TapePlayer，表示录音机（播放磁带）。类图如下：

创建一个遥控器 Controller 类。该遥控器有三个控制通道，可以分别控制三个设备。部分代码如下：
class Controller{
private MediaPlayer[] players;
public Controller(){
//构造函数中初始化 players 数组
}
//对相应的设备调用 play 方法
public void play(int i){
players[i].play();
}
}
要求：

完成 MediaPlayer 接口及其子类的代码。
把 Controller 补充完整，完善其构造函数，并为其增加 stop(int i)和open(int i)方法

习题：

输出字符串“helloworld”的字符串长度
输出o的位置
输出从下标5开始第一次出现o的位置
截取hello并输出
截取world并输出
将字符串“ hello ”两边的空白去掉
输出第六个字符
输出字符串是否以h开头，以ld结尾
将字符串分别转换为大写小写输出
截取子串:
Str=”www.oracle,com”//oracle
Str=”www.cedu.com.cn”//tedu
判断回文（回文，从中间开始两边对称）
Str=”上海自来水来自海上”；
输入一个字符串，统计字符串中字母、数字和其他符号的个数
输入一个字符串，将其中的数字提取出来并求和
dsho353sdhiha89dnso4 -> 3+5+3+8+9+4 = 32
输入一个字符串，将其中的数字提取出来并进行升序排序
dsho353sdhiha89dnso4 -> 353894 -> 334589
输入一个字符串，统计其中每一个字符出现的次数
sdhaofnaadsg -> s:2 d:2 h:1 a:3 o:1 f:1 n:1 g:1
16.输入2个字符串，打印第二个字符串在第一个字符串中出现的所有的位置
vagaophgao a -> 1 3 8