目录
想学习架构师构建流程请跳转：Java架构师系统架构设计
第一章：java基础语法测试题
1 选择题
题目1(单选):
下面有关Java语言跨平台性说法正确的是( D )
选项 :
解析：JDK JRE都是个软件，不能说跨平台，源代码只有在jvm实现跨平台才可以到处使用。
A.Java的源代码是跨平台的。
B.JDK是跨平台的。
C.JVM是跨平台的。
D.跨平台中的平台指的是操作系统,Java语言的跨平台性是指Java程序可以在不同的操作系统上运行,前提是相应的操作系统安装了对应的JVM。
题目2(单选):
以下选项中,关于常量说法正确的是( A )
选项 :
解析：空格也是一个字符，单引号括住的一个字符为字符常量，双引号括住的0个或多个字符为字符串常量。
A.‘ ’(里面是一个空格),这是一个字符常量。 “ ”(里面是一个空格),这是一个字符串常量。
B.‘’(里面没有空格),这是一个字符常量。 “”(里面没有空格),这是一个字符串常量。
C.'ab',这是一个字符常量。 “ab”,这是一个字符串常量。
D.1,2,3,3.0这4个都是整数常量。 1.0,2.1,3.1这3个都是小数常量。
题目3(单选):
下列选项中关于Java中的注释描述错误的是( B )
解析：多行注释不可以嵌套
选项 :
A.单行注释的格式是,例子如下://被注释的内容
B.多行注释可以嵌套多行注释,例子如下:/*hello/*java*/world*/
C.单行注释可以嵌套单行注释,例子如下://hello//world//java
D.多行注释的格式,例子如下:/*被注释的内容*/
题目4(单选):
以下选项中,哪一项符合标识符的命名规则( A )
解析：命名规则由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字也不能有空格除前面以外的字符。不能使用java中的关键字作为标识符。
标识符对大小写敏感（区分大小写）。
选项 :
A.HelloWorld
B.123
C.class
D.$1 2 3 4
题目5(单选):
有一个HelloWorld.java文件代码如下,下列说法正确的是( B )
public class HelloWorld {
public static void main(String[] args) {
System.out.println("helloworld");
}
}
选项 :
解析：java源代码.java文件通过javac HelloWorld.java生成.class文件之后java直接运行类名即可不需要加后缀.class。java虚拟机正真执行的是.class文件。
A.Java源代码不用编译,可以直接运行。
B.编译使用命令javac HelloWorld.java
C.运行使用命令 java HelloWorld.class
D.Java虚拟机真正执行的是.java文件。
题目6(单选):
HelloWorld.java文件代码如下,使用javac HelloWorld.java编译时报错,下面说法错误的是( A )
public class HelloWorld { //第1行
public static viod main(String[] args) { //第2行
system.out.println(helloworld); //第3行
}
}
选项 :
解析：类名必须和文件名相同，默认的类名首字母大写
A.第1行有错误,HelloWorld应该都小写,写成public class helloworld {
B.第2行有错误,viod应写成void.
C.第3行有错误,system应该是System.
D.第3行有错误,helloworld应该用""引起来.
题目7(单选):
关于JDK、JRE、JVM下列哪些选项的描述是错误的( D )
解析：只需安装JDK即可，它包含了java的运行环境和虚拟机。
选项 :
A.JRE全称Java Runtime Environment是Java的运行环境。
B.JDK全称Java Development Kit是Java的开发工具包。
C.JVM全称Java Virtual Machine是Java程序运行的载体,可以安装在不同的操作系统上,来运行Java程序。
D.一台计算机要能够执行java程序,必须同时安装JDK、JRE、JVM。
题目8(单选):
关于Java环境变量的配置说法错误的是( A )
解析：JAVA_HOME是自己写的知识为了配置JDK方便修改，如果路径变动只需改JAVA_HOME路径即可
选项 :
A.JAVA_HOME环境变量是Windows系统规定要配置的,不然Windows运行会不正常。
B.JAVA_HOME写的应该是JDK安装的目录。
C.安装了JDK后,通常会配置JAVA_HOME环境变量,它的作用是让操作系统上的程序能够知道JDK安装的目录。
D.配置了JAVA_HOME后,需要把%JAVA_HOME%\bin配置到path路径下,并用"分号"和其他配置隔开。
2 代码题
题目9
解析：较为简单基本不考，但是这是测试你环境是否搭建成功的必经之路！
请编写程序,将如下语句输出到屏幕上:
Java是一门跨平台的计算机语言,被称为一次编写,处处运行。
思路分析:
1.创建java文件。
2.编写类,用于完成该程序。
3.程序的运行需要主方法,编写主方法。
4.该使用什么语句将题目中的文本输出?
5.该怎样编译和运行java文件?
参考步骤:
1.新建文本文件,将名称修改为Test01.java。注意显示文件的后缀名,防止出现Test01.java.txt的文件名。
2.打开文件,编写代码,先定义一个类Test01,类名需要与文件名一致。注意大小写。
3.在类中定义主方法,在主方法中编写输出语句,将题目中的文本用双引号包裹。
4.保存文件内容。打开cmd窗口,将命令目录切换至文件所在目录。使用javac命令编译java文件,使用java命令运行class文件,查看结果。注意:编译java文件,需要带后缀名;运行class文件,不需后缀名。
参考答案:
作业：
1.创建类和main方法
2.使用打印语句输出
public class Test01{
public static void main(String[] args) {
System.out.println("Java是一门跨平台的计算机语言,被称为一次编写,处处运行。");
}
}
3.运行效果
题目10
解析：较为简单基本不考，但是需要记忆。
常量是指在程序运行过程中,其值不可以发生改变的量,请编写Java程序,分别将下列常量数据打印到屏幕上。
字符串常量:用双引号括起来的内容。"HelloWorld","你好程序员"
整数常量:不带小数的数字。666, -88
小数常量:带小数的数字。13.14, -5.21
字符常量:用单引号括起来的内容。'A','0','我'
布尔常量:布尔值,表示真假。只有两个值：true,false
空常量:一个特殊的值,空值,null(null值可以直接在输出语句打印吗)
思路分析:
1.创建java文件。
2.编写类,用于完成该程序。
3.程序的运行需要主方法,编写主方法。
4.该使用什么语句将题目中的常量输出?
5.程序编写完成,该怎样编译和运行java文件?
参考步骤:
1.新建文本文件,将名称修改为ConstantDemo.java。
2.打开文件,编写代码,先定义一个类ConstantDemo,类名需要与文件名一致。注意大小写。
3.在类中定义主方法,在主方法中编写多个输出语句,在输出语句中直接输出常量即可。
4.保存文件内容。打开cmd窗口,将命令目录切换至文件所在目录。使用javac命令编译java文件,使用java命令运行class文件,查看结果。注意:编译java文件,需要带后缀名;运行class文件,不需后缀名。
参考答案:
作业：
1.创建java类和main方法
2.使用变量存储数据类型
3.使用输出语句打印输出
/*
字符串常量:用双引号括起来的内容。"HelloWorld","程序员"
整数常量:不带小数的数字。666, -88
小数常量:带小数的数字。13.14, -5.21
字符常量:用单引号括起来的内容。'A','0','我'
布尔常量:布尔值,表示真假。只有两个值：true,false
空常量:一个特殊的值,空值,null(null值可以直接在输出语句打印吗)
*/
public class Test02 {
public static void main(String[] args) {
int a = 666, b = -88;
double c = 13.14, d = -5.21;
char ch1 = 'A', ch2 = '0', ch3 = '我';
//1.打印字符串常量"HelloWorld","程序员"
System.out.print("hello,");
System.out.println("你好程序员");
System.out.println(""); // 字符串中内容可以为空, 空字符串
//2.打印整数常量666, -88
System.out.println(a);
System.out.println(b);
//3.打印小数常量13.14, -5.21
System.out.println(c); // CTRL + d 复制一行
System.out.println(d);
//4.打印字符
System.out.println(ch1);
System.out.println(ch2);
System.out.println(ch3);
//5.打印布尔常量
System.out.println(true);
System.out.println(false);
/*线程“main”java.lang中的异常。
错误:未解决的编译问题:println(char[])方法对于类型PrintStream是不明确的*/
// System.out.println(null);
}
}
4.运行效果
第二章：java运算符测试题
1 选择题
题目1(单选):
下列选项中定义变量哪一项是正确的( D )
解析：byte的长度为-128~127，long长整型，float后要加f，浮点数默认是double型不能直接赋值到float上！
选项:
A.byte b=128;
B.long c=3.14L;
C.float f=3.14;
D.double e=4.88;
题目2(单选):
关于变量的定义,下列写法正确的是( A )
解析：布尔类型只有false和true两种结果，不能将引用类型字符串赋值给它
选项:
A.byte b = 10;
B.int i = 10.0;
C.boolean b = "true";
D.float f = 10.2
题目3(单选):
请观察以下代码,为横线处选取正确答案( B )
public static void main(String[] args){
byte b1 = 10;
byte b2 = 20;
byte result = __________;
System.out.println("求和的结果是:"+result);
}
选项:
解析：ACD选项加起来有默认的数据提升变为int类型不能再往低精确度类型存储
A.(byte)b1 + b2
B.(byte)(b1 + b2)
C.b1 + b2
D.b1 + (byte)b2
题目4(单选):
下面关于++运算得到的结果正确的是( B )
public class Test {
public static void main(String[] args) {
int x = 10;
int result = x++;
++x;
System.out.println("x的值为："+x);
System.out.println("result的结果为："+result);
}
}选项:
解析：因为不论++在前在后值都是加的，但是如果单独用的话不管你加不加直接就是原数值
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。简单的说：先用后加
参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。简单的说：先加后用
A.x的值为:11 result的结果为:10
B.x的值为:12 result的结果为:10
C.x的值为:11 result的结果为:11
D.x的值为:12 result的结果为:12
题目5(单选):
下列代码的运行结果是(B)
public static void main(String[] args) {
int i = 5;
int j = 2;
System.out.println(i/j);
System.out.println(i%j);
}
选项:
解析：int类型做除法有小数直接取整2.9和2.1一样没有四舍五入都是2，%为取余数，就是除法除不尽的余数
A.2.5 1.0
B.2 1
C.2 2
D.1 1
题目6(单选):
下列代码的运行结果是( B )
public static void main(String[] args){
int x = 3;
float y = x;
System.out.println(y);
}选项:
A.3
B.3.0
C.3.0F
D.3F
题目7(单选):
以下选项中,+符号在字符串中的使用描述正确的是( D )
选项:
解析：字符串粘性最强可以将任何类型粘过来变为字符串
A.使用+符号可以连接两个字符串,并且获取两个字符串中字符的个数。
B.使用+符号可以让两个字符串进行求和运算。
C.使用+符号可以让一个字符串和一个整数进行求和运算。
D.使用+符号可以连接两个字符串,得到一个新的字符串。
题目8(单选):
以下代码运行之后的结果输出到控制台是 5+5=10,则横线处应该填写的正确代码是(C )
public static void main(String[] args) {
int a = 5;
int b = 5;
System.out.println(_________);
}选项:
解析：a放入就是a变量的值，如果粘到了字符串也就变成字符串类型
A.a+"+"+b+"="+a+b
B.a+b"="(a+b)
C.a+"+"+b+"="+(a+b)
D.a+b+"="+(a+b)
2 代码题
题目9:
练习字符串的“+”操作,请分别输出下列表达式的运算结果:
"it" + "oldlu"
"itoldlu" + 666
666 + "itoldlu"
"程序员" + 6 + 66
1 + 99 + "程序员"
思路分析
课堂案例 - 使用输出语句直接输出题目中的表达式
参考步骤
1.新建OperatorDemo.java文件,定义OperatorDemo类,定义main方法。
2.使用输出语句分别输出题目中的表达式
3.编译运行查看结果
参考答案:
作业：
1.测试字符串和基本数据类型连接结果
2.测试算符优先级
/*"it" + "hellow"
"ithellow" + 666
666 + "ithellow"
"程序员" + 6 + 66
1 + 99 + "年程序员"*/
//基本数据类型都能拼接到字符串里，所以基本数据类型与字符串相加结果还是字符串。
public class Test03 {
public static void main(String[] args) {
//"it" + "hello"
System.out.println("it" + "hello");
//"itoldlu" + 666
System.out.println("ithello" + 666);
//666 + "itoldlu"
System.out.println(666 + "ithello");
//"" + 6 + 66 从左到右过程为 1."程序员6"+6 2."程序员666"
System.out.println("程序员" + 6 + 66);
//1 + 99 + "年程序员" 从左到右运算先加再放入字符串
System.out.println(1 + 99 + "年程序员");
}
}
3.运行效果
题目10:
练习赋值运算符,请依次完成如下操作:
(1)定义int类型的变量,为其赋值为10,并打印输出。
(2)将该变量的值增加10,再次打印输出。
(3)定义short类型的变量,为其赋值为10,将变量的值增加20,并输出结果。
思路分析:
课堂案例 - 赋值运算符
参考步骤:
新建java文件,定义类和主方法。
定义int类型的变量I,初始化值10
使用扩展的赋值运算符+= 往变量i上进行累加变量20, 输出变量变量i
定义short类型变量s,使用扩展的赋值运算符+= 往变量s上累加20,打印变量s
参考答案:
作业：
1.自动类型转换和强制类型转换的使用
public class Test04 {
public static void main(String[] args) {
int a = 10;
System.out.println("a的值为：" + a);
int b = a + 10;
System.out.println("b的值为：" + b);
short s1 = 10;
//因为变量会强转成int所以高精度不会向低精度再转换故报错
//short s2=s1+10;
//解决方法1 接收结果为int
//int s2=s1+10;
//解决方法2 通过自增解决
//s1+=10;
//解决方法3 强制转换为short
short s2 = (short) (s1 + 10);
System.out.println("s2的结果为：" + s2);
}
}2.运行效果
第三章：java数据输入测试题
1 选择题
题目1(单选):
下面关于逻辑运算符的代码执行结果是( B )
解析：短路与&&全都要真，短路或||一个即可，短路就是判断一边即可，谐音记法，与想象为美与，"美女"房车钱帅全都要一样都不能少！
public class Test {
public static void main(String[] args) {
boolean flag1 = (3 < 5) && (5 > 7);
boolean flag2 = (3 < 5) || (5 > 7);
boolean flag3 = !(7 != 7);
System.out.println("flag1的值是：" + flag1);
System.out.println("flag2的值是：" + flag2);
System.out.println("flag3的值是：" + flag3);
}
}选项:
A.flag1的值是：true flag2的值是：false flag3的值是：false
B.flag1的值是：false flag2的值是：true flag3的值是：true
C.flag1的值是：false flag2的值是：false flag3的值是：true
D.flag1的值是：true flag2的值是：true flag3的值是：false
题目2(单选):
以下选项中,三元运算符的使用正确的是( D )
选项:
解析：三元？判断真假 前真:后假，然后匹配
A.
public static void main(String[] args){
int a = 10;
int b = 20;
(a > b) ? a : b;
}
B.
public static void main(String[] args){
int a = 10;
int b = 20;
int c = (a > b) ? "正确" : b;
}
C.
public static void main(String[] args){
int a = 10;
int b = 20;
int c = (a > b) : a ? b;
}
D.
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println((a > b) ? a : b);
}
题目3(单选):
请观察以下代码,在横线处填写的正确代码是( B )
public static void main(String[] args) {
int a = 10;
int b = 20;
int min = _________; // 第五行
System.out.println("最小值："+ min); // 第六行
}
选项:
A. a < b ? 20 : 10
B. a < b ? a : b
C. a > b ? a : b
D. a < b ? "a是最小值" : "b是最小值"
题目4(单选):
代码如下,执行后描述正确的是( C )
解析：next就是啥也可以接收，nextInt就是接受整型，输入的格式要记住！
Scanner sc = new Scanner(System.in);
String s = sc.next();
int i = sc.nextInt();
System.out.println(s + i);
选项:
A.语法错误,键盘录入的数据不能直接参与运算。
B.如果第一次键盘录入a,第二次键盘录入1。那么通过+进行计算,结果输出98。
C.如果第一次键盘录入10,第二次键盘录入10。那么通过+进行计算,结果输出1010。
D.如果第一次键盘录入10,第二次键盘录入10。那么通过+进行计算,结果输出20。
题目5(单选):
以下代码片段执行后,控制台的输出结果为( D )
public static void main(String[] args) {
int a = 30;
int b = 50;
System.out.println( a>b && a<b );
System.out.println( a==b || a<b );
System.out.println( !(a==b) );
}
选项:
A.true false true
B.false false true
C. false true false
D. false true true
题目6(单选):
下面关于比较运算符的代码的运行结果是( C )
public class Test {
public static void main(String[] args) {
int num1 = 5;
int num2 = 6;
System.out.println(num1 <= num1);
System.out.println(num1 == num2);
System.out.println(num2 != num2);
}
}
选项 :
A.true false true
B.false false false
C.true false false
D.false false true
项目7(单选):
下列Scanner类所提供的方法中,用于通过键盘录入整数的方法是( B )
选项:
A.nextLine()
B.nextInt()
C.nextDouble()
D.next()
题目8(单选):
关于java.util.Scanner类,下列哪些选项的描述是错误的( D )
选项:
A.如果在自己的测试类中要使用Scanner类,需要导包。
B.nextInt()方法用来从键盘获取一个整数。
C.nextLine()方法用来从键盘获取一个字符串。
D.Scanner对象的创建方式为:Scanner sc = new Scanner();。
2 代码题
题目9:
某小伙想定一份外卖,商家的优惠方式如下:鱼香肉丝单点24元,油炸花生米单点8元,米饭单点3元。
订单满30元8折优惠。鱼香肉丝优惠价16元,但是优惠价和折扣不能同时使用,那么这个小伙要点这三样东西,最 少要花多少钱?请编写程序计算。
思路分析:
有两种购买方式,一种是不使用优惠价,另一种是使用优惠价。分别计算花费后,对两种方式的花费作对比。
参考步骤:
使用算术运算符求出不使用优惠时的总价.
使用三元运算符判断总价是否满足打折条件,并求出折后总价.
使用算术运算符求出使用优惠价时的总价.
使用三元运算符判断最终更合算的购买方式和花费.
参考答案:
作业：
1.三元运算符的使用
public class Test07 {
public static void main(String[] args) {
//求不使用优惠时的总价35元
double sum = 24 + 8 + 3;
//折后总价28元
sum = (sum >= 30 ? sum : sum * 0.8);
//使用优惠时的总价27元
double money2 = 16 + 8 + 3;
//判断两种花费哪个更少
double money = sum < money2 ? sum : money2;
//打印最终花费
System.out.println("最优惠的方案为：" + money + "元");
}
}
2.运行效果：
题目10:
小李同学在学习了Scanner之后想要使用Java完成一个简易的加法计算器,在控制台输出两个整数之后输出两个整数的和,应该如何实现呢?
思路分析
如何保存小李录入的两个整数?
参考步骤
1.创建Scanner对象.
2.提示输入数字并且使用变量保存.
3.打印出两个变量相加的结果.
参考答案
作业：
1.输入输出的简单应用
import java.util.Scanner;
public class Test08 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个加数：");
int nextInt1 = sc.nextInt();
System.out.println("请输入另一个加数：");
int nextInt2 = sc.nextInt();
System.out.println("请输入另一个加数：");
int sum = nextInt1 + nextInt2;
System.out.println("结果为：" + sum);
}
}
2.运行效果：
第四章：java选择结构测试题
1 选择题
题目1(单选):
下列代码的运行结果是( B )
public class Test {
public static void main(String[] args){
int age = 18;
System.out.println("程序员");
if(age >= 18){
System.out.println("咨询Java课程");
System.out.println("开始学习Java课程");
}
System.out.println("学业有成,拿高薪!");
}
}
选项:
A.程序员 学业有成,拿高薪!
B.程序员 咨询Java课程 开始学习Java课程 学业有成,拿高薪!
C.咨询Java课程 开始学习Java课程
D.代码编译报错
题目2(单选):
代码如下,运行完成之后的结果是:10是偶数,则横线处填写的正确代码是( B )
public class Test{
public static void main(String[] args){
int a=10;
if(____________){
System.out.println(a+"是偶数");
}
}
}
选项:
A. a/2==0
B. a%2==0
C. a%=2
D. a/=2
题目3(单选):
下列代码的运行结果是( D )
public static void main(String[] args) {
boolean flag = false;
int num = 10;
if (flag){
num++;
}
num++;
if(num < 11){
System.out.println("天生我材必有用");
if (num > 5){
System.out.println("千金散尽还复来");
}
}
System.out.println("饿了么？");
}
选项:
A.没有任何输出
B.天生我材必有用
C.天生我材必有用 千金散尽还复来 饿了么？
D.饿了么?
题目4(单选):
下列代码的运行结果是( C )
public class Test {
public static void main(String[] args) {
int age = 8;
if(age > 15){
System.out.println("高中欢迎你");
}else if(age > 12){
System.out.println("初中班欢迎你");
}else if(age > 7){
System.out.println("小学欢迎你");
}else{
System.out.println("幼儿园欢迎你");
}
}
}
选项:
A. 高中欢迎你
B. 初中班欢迎你
C. 小学欢迎你
D. 幼儿园欢迎你
题目5(单选):
以下代码片段执行后,控制台的输出结果为 ( C )
public static void main(String[] args) {
int num = 12;
if (num == 12) {
System.out.print("白日依山尽 ");
if (num >= 11) {
System.out.print("黄河入海流 ");
}
} else {
System.out.print("欲穷千里目 ");
}
System.out.print("更上一层楼 ");
}
选项:
A. 更上一层楼
B. 白日依山尽 欲穷千里目 更上一层楼
C. 白日依山尽 黄河入海流 更上一层楼
D. 白日依山尽 黄河入海流 欲穷千里目 更上一层楼
题目6:
下列代码的运行结果是( C )
public static void main(String[] args) {
int a = 3;
int b = 5;
int c = 8;
if (a > b ) {
if (a > c) {
System.out.println(a);
}else {
System.out.println(c);
}
}else {
if (b > c) {
System.out.println(b);
} else {
System.out.println(c);
}
}
}
选项:
A.3
B.5
C.8
D.没有任何输出
题目7(单选):
下列代码的运行结果是( B )
public static void main(String[] args){
int number = 1;
if(number==0){
System.out.println("石头");
}else if(number==1){
System.out.println("剪刀");
} else if(number==2){
System.out.println("布");
}else{
System.out.println("错误");
}
}
选项:
A.石头
B.剪刀
C.布
D.错误
题目8(单选):
下列代码的运行结果是 ( B )
public static void main(String[] args) {
public class Test {
public static void main(String[] args) {
char c = 'c';
switch (c){
case 'a':
System.out.println("张三");
case 'b':
System.out.println("李四");
break;
case 'c':
System.out.println("王五");
case 'd':
System.out.println("程序员");
break;
default:
System.out.println("程序结束！");
break;
}
}
}选项:
A.张三 李四
B.王五 程序员
C.程序结束！
D.李四 王五
2 代码题
题目9:
李雷想买一个价值7988元的新手机,她的旧手机在二手市场能卖1500元,而手机专卖店推出以旧换新的优惠,把 她的旧手机交给店家,新手机就能够打8折优惠。
为了更省钱,李雷要不要以旧换新?请在控制台输出。
思路分析:
怎样计算不同方式的花费?
用什么语句能够对不同购买方式的价格做出判断?
参考步骤:
计算不使用以旧换新时的花费。
计算使用以旧换新时的花费。
使用if..else语句判断哪种方式更省钱,并输出结果。
参考答案:
作业：
1.if..else语句判断
class Test09 {
public static void main(String[] args) {
//计算不使用以旧换新的花费
int secondHand = 7988 - 1500;
//计算以旧换新的花费
double discount = 7988 * 0.8;
//判断两种方式
if(secondHand > discount){
System.out.println("使用以旧换新更省钱");
}else{
System.out.println("不使用以旧换新更省钱");
}
}
}
运行效果：
题目10:
键盘录入一个月份数字,使用switch输出这个月份对应的季节.
参考步骤:
键盘录入月份并使用switch进行判断,可以使用case穿透来完成.
实现步骤:
创建键盘录入对象
录入数据
switch语句进行判断实现(最好使用case穿透)
参考答案:
1.switch语句进行判断(使用穿透)
import java.util.Scanner;
public class Test10 {
public static void main(String[] args) {
System.out.println("请输入你想查询的月份：(之后将给出你季节)");
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
switch (month) {
case 1:
case 2:
case 3:
System.out.println("你输入的月份为:" + month + "月此刻为春季！");
break;
case 4:
case 5:
case 6:
System.out.println("你输入的月份为:" + month + "月此刻为夏季！");
break;
case 7:
case 8:
case 9:
System.out.println("你输入的月份为:" + month + "月此刻为秋季！");
case 10:
case 11:
case 12:
System.out.println("你输入的月份为:" + month + "月此刻为冬季！");
break;
default:
System.out.println("你输入的月份为:" + month + "月，你输入有误请重新输入！");
break;
}
}
}
运行效果：
第五章：java循环结构测试题
1 选择题
题目1(单选):
下列代码的运行结果是( A )
public class test {
public static void main(String[] args) {
int sum = 0;
int i=0;
while (i<=5){
if(i % 2 != 0){ 第一次：i=0，0除任何数都是无余数 i++;i=1
第二次：i=1 不等于0 sum=0+1=1; i=2
sum += i; 第三次：i=2 取余等于0 i=3
} 第四次：i=3 取余不等于0 sum=1+3=4 i=4
i++; 第四次 i=4 取余为0 i=5
} 第五次 i=5 取余不为0 sum=4+5=9 i=6 运行结束
System.out.println("sum = " + sum);
}
}
选项:
A. sum = 9
B. sum = 6
C. sum = 15
D. sum = 0
题目2(单选):
以下代码片段执行后,控制台的输出结果为( A )
public static void main(String[] args) {
int sum=0;
int i=1;
while(i<3){
sum+=i;
i++;
}
System.out.print("sum="+sum);
}
选项:
A. sum=3
B. sum=0
C. sum=6
D. sum=1
题目3(单选):
下列代码的运行结果是( B )
public class Test {
public static void main(String[] args) {
int sum = 0;
for(int i = 0; i < 10; i++){
if (i % 3 != 0){
sum += i;
}
}
System.out.println("sum = " + sum);
}
}
选项:
A. sum = 45
B. sum = 27
C. sum = 18
D. sum = 55
题目4(单选):
阅读代码,下面那些代码片段能够求1~10(包含1也包含10)之间偶数的和( A )
选项:
A.
int sum=0;
for(int i=1;i<=10;i++){
if(i%2==0){
sum+=i;
}
}
B.
int sum=0;
for(int i=1;i<10;i+=2){
sum+=i;
}
C.
int sum=0;
for(int i=1;i<10;i++){
if(i%2!=0){
sum+=i;
}
}
D.
int sum=0;
for(int i=0;i<=10;i+=2){
sum+=i;
}
题目5(单选):
关于for循环语句说法错误的是( A )
for (初始化语句; 循环判断表达式; 步进语句) {
①int a = 10;
②循环体;
}
选项:
A. 因为初始化语句在循环中只执行一次,所以循环过程中, 无法使用初始化语句中定义的变量.
B. 循环判断表达式的执行次数,会比循环体的执行次数多一次.
C. ①处定义的变量a,每一次进入循环,都会重新定义一个新的变量.
D. 循环体是否执行,需要根据[循环判断表达式]返回的true或false而定.
题目6(单选):
下列代码的运行结果是( D )
public static void main(String [] args){
int i = 1;
while(i == 10){
++i;
System.out.println("执行循环啦");
}
}
选项:
A.语法错误.
B.打印9次执行循环啦.
C.打印10次执行循环啦.
D.没有输出结果.
题目7(单选) :
下列代码的运行结果是( A )
public static void main(String[] args) {
int count = 0;
int i = 2;
while( i < 7){
if (i % 2 == 1){
count++;
}
i++;
}
System.out.println(count);
}
选项:
A.2
B.3
C.4
D.5
题目8(单选):
下面有关do...while循环的执行流程,那些描述是正确的( B )
选项:
A.do...while循环在循环条件成立的情况下,循环语句体才能被执行.
B.do...while循环的循环条件即使不成立,循环语句体也能被执行1次.
C.do...while循环的循环语句体只能被执行一次.
D.do...while是先判断循环条件是否成立,再执行循环语句体.
2 代码题
题目9:
在中国历法中有十二生肖年份,2019年是己亥猪年,请在控制台输出从1949年(包含)到2019年(包含)中所有是猪年的年份。
参考步骤:
定义for循环,1949到2019的年份是循环次数.
对每个年份逐个判断,如果年份和2019的差值是12的倍数,说明这年是猪年.
打印符合条件的年份.
参考答案:
作业：
1.for循环的使用
public class Test11 {
public static void main(String[] args) {
System.out.println("以下年份都是猪年：(1949年-2019年)");
for (int i = 2019; i >= 1949; i=i-12) {
System.out.print(i);
System.out.print("年");
System.out.print(" ");
}
}
}
运行效果：
题目10:
中国使用的公历有闰年的说法,闰年的规则是:四年一闰,百年不闰,四百年再闰。(年份能够被4整除但不能被100整除算是闰年,年份能被400整除也是闰年).请打印出1988年到2019年的所有闰年年份。
参考步骤:
定义for循环,循环变量开始是1988,结束是2019.
在循环中对年份进行判断,判读条件为:可以被4整除,并且不可以被100整除,或者可以被400整除.
如果符合条件,输出该年份.
参考答案:
作业：
1.for循环嵌套if的使用
2.整除取余
public class Test12 {
public static void main(String[] args) {
System.out.println("以下年份都是闰年：");
for (int i = 2019; i >= 1988; i--) {
//可以被4整除,并且不可以被100整除,或者可以被400整除.
//解读：被4整除和不可被4整除要同时满足，或者就是或运算
if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
System.out.print(i);
System.out.print("年");
System.out.print(" ");
} else {
}
}
}
}
运行效果：
第六章：java循环选择随机综合测试题
1 选择题
题目1(单选):
下列代码的运行结果是( C )
public static void main(String[] args) {
int sum=0;
for (int i = 1; i < 3; i++) {
for (int j = 1; j < 3; j++) {
sum+=i*j;
}
}
System.out.println("sum="+sum);
}
选项:
A.sum=3
B.sum=4
C.sum=9
D.sum=5
题目2(单选):
下列代码的运行结果是( B )
public static void main(String [] args){
for (int i = 0; i < 1; i++) {
System.out.println("执行语句1");
for (int j = 0; j < 2; j++) {
System.out.println("执行语句2");
}
System.out.println("执行语句3");
}
}
选项:
A.
没有输出结果
B.
执行语句1
执行语句2
执行语句2
执行语句3
C.
执行语句1
执行语句2
执行语句3
D.
执行语句1
执行语句2
执行语句2
执行语句3
执行语句1
执行语句2
执行语句2
执行语句3
题目3(单选):
分析以下代码片段,并按照下列两个问题在横线处补全代码,下列选项正确的是( C )
public class Test01 {
public static void main(String[] args) {
for(int x=1; x<=10; x++) {
if(x % 3==0) {
// 补全代码
__________
}
System.out.println("我爱Java!");
}
}
}
问题:
① 在控制台输出2次:"我爱Java!" 横线处应该填写什么?
② 在控制台输出7次:"我爱Java!" 横线处应该填写什么?
选项:
A.
①continue ②break
B.
①continue ②continue
C.
①break ②continue
D.
①break ②break
题目4(单选):
下列代码的运行结果是( C )
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i%5==0){
System.out.println("hello");
break;
}
}
}
选项:
A.输出5个hello
B.输出4个hello
C.输出1个hello
D.输出9个hello
题目5(单选):
下列关于break和continue说法正确的是( C )
选项:
A.break是跳出本次循环,执行break之后,循环还可以继续执行.
B.continue是跳出整个循环,一定会让这个循环终止.
C.break除了用于循环还可以用于swtich语句,在switch语句中表示跳出switch语句,在循环中表示终止当前循环.
D.continue除了用于循环还可以用于switch语句,都表示继续匹配的意思.
题目6(单选):
下列代码的运行结果是( B )
public static void main(String[] args) {
int count = 0;
for(int i = 1;i <= 10;i++) {
if(i % 5 == 0) {
break;
}
if (i == 3 || i == 7 || i == 9){
continue;
}
count++;
}
System.out.println(count);
}
选项:
A.4
B.3
C.2
D.1
题目7(单选):
下列代码能够获取1到100(包含1和100)之间随机数的是( C )
选项:
A.
Random r = new Random();
int num = r.nextInt();
B.
Random r = new Random();
int num = r.nextInt(100);
C.
Random r = new Random();
int num = r.nextInt(100)+1;
D.
Random r = new Random(System.in);
int num = r.nextInt(100+1);
题目8(单选):
下列代码能够用于随机产生[1,99]包含1,包含99之间整数的是( B )
选项:
A.
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt(40)+59;
System.out.println(num);
}
B.
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt(99) + 1;
System.out.println(num);
}
C.
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt(99);
System.out.println(num);
}
D.
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt(100)-1;
System.out.println(num);
}
2 代码题
题目9:
有一个输出语句System.out.print("@"),表示输出一个"@",并且不换行,使用这个语句,在控制台打印出一个四行五列的长方形,效果如下:
@@@@@
@@@@@
@@@@@
@@@@@
参考步骤:
定义循环执行4次,代表一共4行.
在循环内部再次定义循环执行5次,代表每行输出5个符号.
在内层循环中输出符号,并且不换行.
每行符号打印结束之后,添加一个换行操作.
参考答案:.
作业：
1.for循环的嵌套使用
/**
* @Author 赵广陆
* @Date 2020/2/26 0026 15:35
* @Version 1.0
*/
/*
@@@@@
@@@@@
@@@@@
@@@@@
有一个输出语句有一个输出语句System.out.print("@"),表示输出一个"@",并且不换行,使用这个语句,在控制台打印出一个四行五列的长方形,
* */
public class Test {
public static void main(String[] args) {
for (int i = 0; i < 4; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("@");
}
System.out.println("");
}
}
}
运行效果：
题目10:
有一个输出语句System.out.print("@"),使用这个语句,在控制台打印出一个五行的三角形,效果如下
@
@@
@@@
@@@@
@@@@@
参考步骤:
定义循环执行5次,循环变量从1到5,代表一共5行.
定义内层循环执行i次,代表每行打印的个数是i,这个i即为外层循环的循环变量.
在内层循环中输出符号,并且不换行.
每行符号打印结束之后,添加换行操作.
参考答案:
作业：
1.循环嵌套的应用
/**
* @Author 赵广陆
* @Date 2020/2/26 0026 15:35
* @Version 1.0
*/
/*
@
@@
@@@
@@@@
@@@@@
有一个输出语句System.out.print("@"),使用这个语句,在控制台打印出一个五行的三角形,效果如下
* */
public class Test {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j <= i; j++) {
System.out.print("@");
}
System.out.println("");
}
}
}
运行效果：
第七章：java数组测试题
1 选择题
题目1(单选):
下列数组创建并初始化格式错误的是( C )
选项:
解析：数组不能即给定长度有付裕初值，画蛇添足！
A.int[] arr = new int[] {33,22,11};
B.int[] arr = new int[4];
C.double[] arr = new double[3]{5.2, 3.14, 6.18};
D.int[] arr = {11,22,33};
题目2(单选):
下列操作中能够正常编译运行的是( C )
选项:
A.
public static void main(String[] args){
int[] arr = {1,2,3};
int num = arr;
}
B.
public static void main(String[] args){
int[] arr = {1,2,3};
int num = arr0;
}
C.
public static void main(String[] args){
int[] arr = {1,2,3};
arr[1] = 5;
}
D.
public static void main(String[] args){
int[] arr = {1,2,3};
arr.[0] = 2;
}
题目3(单选):
代码如下,运行结果是7,则横线处应该填写的内容是( B )
public static void main(String[] args){
int[] arr = { 3,6,7,2,5,8 };
System.out.println(____________);
}
选项:
A.arr[6]
B.arr[2]
C.arr[1]
D.arr[0]
题目4(单选):
下列代码的运行结果是( D )
public static void main(String[] args) {
int arr[] = {1, 3, 5, 7, 9};
System.out.println("结果是："+arr[1]);
System.out.println("结果是："+arr[arr.length-1]);//数组长度是5-1是4 然后索引是从0开始
}
选项:
解析：数组长度是从1~n，数组索引是从0~n-1长度，也就是索引指向0就是数组第一个元素！
A.结果是:1 结果是:9
B.结果是:1 结果是:7
C.结果是:3 结果是:7
D.结果是:3 结果是:9
题目5(单选):
下列代码中,有关数组的定义格式错误的是( C )
选项:
A.int[] arr = {1,2,3,4,5,6};
B.int[] arr = new int[3];
C.int[] arr = new int[6]{1,2,3,4,5,6};
D.int[] arr = new int[]{1,2,3,4,5,6};
题目6(单选):
下列代码能够正常运行的是( B )
选项
A.
public class Demo{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7};
for (int i = 0; i <= arr.length; i++) {
System.out.println(arr[i]);
}
}
}
B.
public class Demo{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
C.
public class Demo{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7};
int i = 0;
while(i < arr.length){
System.out.println(arr[i]);
}
}
}
D.
public class Demo{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7};
for (int i = 0; ; i++) {
System.out.println(arr[i]);
}
}
}
题目7(单选):
下列代码能够获取任意数组中元素最大值的是( C )
选项:
A.
public class Demo{
public static void main(String[] args){
int[] arr = {23,544,56,1,23,45,21,1,78};
for (int i = 1; i < arr.length; i++) {
int max = arr[0];
if(max < arr[i]){
max = arr[i];
}
System.out.println(max);
}
}
}
B.
public class Demo{
public static void main(String[] args){
int[] arr = {23,544,56,1,23,45,21,1,78};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(max > arr[i]){
max = arr[i];
}
}
System.out.println(max);
}
}
C.
public class Demo{
public static void main(String[] args){
int[] arr = {23,544,56,1,23,45,21,1,78};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
}
System.out.println(max);
}
}
D.
public class Demo{
public static void main(String[] args){
int[] arr = {-23,-544,-56,-1,-23,-45,-21,-1,-78};
int max = 0;
for (int i = 0; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
}
System.out.println(max);
}
}
题目8(单选):
下面代码用于获取数组的最大值,画横线区域处应填写代码正确的是( C )
public static void main(String[] args){
int[] arr = { 2,7,-1,6,3 };
_____(1)______
for(int i=1;i<arr.length;i++){
if(___(2)____){
___(3)____
}
}
System.out.println("最大值是:" + max);
}
选项:
A.
(1)int max = 0; (2)arr[i]<max; (3)arr[i] = max;
B.
(1)int max = 0; (2)arr[i] > max; (3)max = arr[i];
C.
(1)int max = arr[0]; (2)arr[i] > max; (3)max = arr[i];
2 代码题
题目9:
创建一个长度为6的整数数组,请编写代码,随机生成六个0(包含)-100(不包含)之间的整数存放到数组中,然后计算出数组中所有元素的和并打印。
参考步骤:
定义长度为6的int数组。
创建随机数Random类对象。
遍历数组,在循环中生成随机数并给数组元素赋值。
定义求和变量,初始化值为0。
遍历数组,获取每一个元素,累加。
遍历结束,打印结果。
参考答案:
作业：
1.随机数的使用
2.数组的遍历
import java.util.Random;
/**
* @Author 赵广陆
* @Date 2020/2/28 0026 17:35
* @Version 1.0
*/
/*
创建一个长度为6的整数数组,请编写代码,随机生成六个0(包含)-100(不包含)之间的整数存放到数组中,然后计算出数组中所有元素的和并打印。
* */
public class Test03 {
public static void main(String[] args) {
Random ran = new Random();
int[] arr = new int[6];
System.out.print("随机数:");
for (int i = 0; i < arr.length; i++) {
int x = ran.nextInt(100);
System.out.print(" " + x);
arr[i] = x;
}
int a = 0;
for (int i = 0; i < arr.length; i++) {
a += arr[i];
}
System.out.println("和为" + a);
}
}
运行效果:
题目10:
请使用静态初始化的方式,创建一个长度为5的整数数组,并为数组中的元素赋值,遍历数组,在同一行打印所有元素,元素之间用空格隔开,比如:如果数组为{1,2,3,4,5}打印结果:1 2 3 4 5
参考步骤:
定义int数组,使用静态初始化方式为元素赋值。
使用for循环对数组进行遍历,循环索引从0开始,到数组的长度-1结束。
逐个打印数组元素,打印元素不换行,在输出元素的后面拼接空格。
参考答案:
作业：
1.静态数组的使用与遍历
/**
* @Author 赵广陆
* @Date 2020/2/28 0026 17:50
* @Version 1.0
*/
/*
请使用静态初始化的方式,创建一个长度为5的整数数组,并为数组中的元素赋值,遍历数组,在同一行打印所有元素,元素之间用空格隔开,比如:如果数组为{1,2,3,4,5}打印结果:1 2 3 4 5
* */
public class Test04 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
运行效果：
第八章：java方法入门测试题
1 选择题
题目1(多选):
下面关于方法的概述描述，正确的是（A B D ）
选项 :
A: 方法定义的先后顺序无所谓
B: 方法的定义不能产生嵌套包含关系。
C: 方法可以让程序的执行效率更高 //我感觉执行效率由数据和数据结构与算法有关
D: 方法定义好了之后，不会执行的，如果要想执行，一定要进行方法的调用
题目2(多选):
以下选项中，关于方法定义的参数或返回值描述正确的是（A B D）
选项 :
A: 方法的参数可以有，可以没有，也可以有多个
B: 方法的参数就是定义一些变量，当方法被调用的时候，用来接收数据使用的
C: 一个方法执行完成之后可以有一个返回值 ,也可以有多个返回值
D: 方法的返回值是方法执行完成之后得到的结果
题目3(多选):
关于对方法的调用，正确的是（A D）
选项 :
A: 有具体返回值的方法, 可以直接调用, 赋值调用以及输出调用
B: 无具体返回值的方法, 可以直接调用和输出调用//如果这个对，viod能输出什么？
C: 有具体返回值的方法, 只能赋值调用和输出调用
D: 无具体返回值的方法, 只能直接调用
题目4(单选):
代码如下：
public static void main(String[] args){
________________________________
}
public static void method(){
System.out.println("我是程序员");
}
运行结果是：
我是程序员
横线处应该填写的正确代码是（ C）
选项 :
A: method;
B: void v = method();
C: method();
D: method("我是程序员");
题目5(单选):
请观察以下代码，分别为第三行和第六行选出正确选项，保证可以在控制台上输出
public class Test08 {
public static void main(String[] args){
_____①_____
}
public _____②_____ print() {
System.out.println("wo ai java");
}
}
运行结果是：
wo ai java
横线处应该填写的正确代码是（ B ）
选项 :
A: ① void v = print(); ② static void
B: ① print(); ② static void
C: ① int v = print(); ② static int
D: ① print(); ② static
题目6(单选):
下列方法定义格式正确的是（B ）
A:
public static void method1(){//方法嵌套
public static void method2(){
}
}
B:
public static void method1(){
}
C:
public static void method1(){//空方法不需要返回值
return 10;
}
D:
public static boolean method1(int n){//无返回值
if(n < 10){
return false;
}else if(n > 10){
return true;
}
}
选项 :
A: 选择A
B: 选择B
C: 选择C
D: 选择D
题目7(单选):
观察以下代码，请选出方法调用过程的正确顺序（ D ）
public static void main(String[] args) {
System.out.println("开始执行"); //1
int a = print(10); //调用方法跳转至方法 //2
System.out.println(a); //3
}
public static int print(int n){ //4
n += 10; //5
return n; //6
}
选项 :
A: 1，2，3，4，5，6
B: 1，2，4，6，5，3
C: 1，4，5，6，2，3
D: 1，2，4，5，6，3
题目8:
以下选项中，关于方法的调用过程描述正确的是 (A C D )
public class Demo{
public static void main(String[] args) {
int a = 10;
int b = 20;
int sum = getSum(a,b);
System.out.println(sum);
isEquals(a, b);
}
public static int getSum(int a,int b){
int sum = a + b;
return sum;
}
public static void isEquals(int a,int b){
boolean c = a == b;
System.out.println(c);
}
}
选项 :
A: 由java虚拟机调用main方法，main方法先执行
B: 在main方法执行中，会定义a和b变量，并分别赋值10和20，然后先调用isEquals方法，再调用getSum方 法并输出结果
C: 调用getSum方法时，要先传入两个整数，否则编译失败。然后执行getSum方法内的代码，执行完成之后，将结果返回赋值给int类型的变量sum
D: 调用isEquals方法时，要先传入两个整数，否则编译失败。然后执行isEquals方法内的代码，执行完成之后，没有结果返回
2 代码题
题目9:
数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试
训练提示
根据方法的功能描述，方法的参数应该接收一个double类型数据。
小数的绝对值也是double，所以返回值类型也是double类型。
操作步骤
定义一个小数变量num。
定义获取绝对值的方法，方法的参数是一个double类型，返回值类型是double。
在方法内部使用if..else..判断。
3.1. 如果是负数则对负数取反并返回。
3.2. 如果不是负数则直接返回数字本身。
在主方法中调用绝对值方法，传入参数num,并接受返回值。
打印返回的结果。
参考代码
作业
1.方法的使用
import java.sql.SQLOutput;
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/2/29 0029 15:45
* @Version 1.0
*/
/*
* 数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。
* 请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试
* */
public class Test05 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double num = sc.nextDouble();
System.out.println(abs(num));
}
public static double abs(double num) {
if (num > 0) {
num = num;
} else {
num = -num;
}
return num;
}
}
运行效果：
题目10:
定义一个方法，该方法能够找出三个整数中的最大值并返回。在主方法中调用方法测试执行。
训练提示
根据题意，方法中需要使用三个整数，所以方法参数应该是三个整数类型。
方法需要有返回值，返回值的类型也是整数类型。
解题方案
操作步骤
定义方法getMax()，方法的参数是三个int类型变量a,b,c，方法的返回值是int类型。
在方法中使用多分支if...else...判断出最大值并返回。
在主方法中调用getMax()方法并接受返回值。
在主方法中打印结果。
参考代码
作业:
1.方法调用
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/2/29 0029 16:37
* @Version 1.0
*/
public class Test06 {
public static void main(String[] args) {
System.out.println("请依次输入三个数字，空格隔开或回车依次输入：");
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int max = getMax(a, b, c);
System.out.println("最大值是" + max);
}
//得到最大值的方法
public static int getMax(int a, int b, int c) {
if (a > b && a > c) {
return a;
} else if (b > a && b > c) {
return b;
} else {
return c;
}
}
}
运行效果：
第九章：java方法重载测试题
1 选择题
题目1(单选):
有关方法重载下列描述正确的是（ C ）
选项 :
A: 在多个类中，两个或者两个以上方法的名称一样，参数列表不一样，返回值必须一样，这些方法称之为重载
B: 在同一个类中，两个或者两个以上方法的名称一样，参数列表不一样，返回值必须相同，这些方法称之为重载
C: 在同一个类中，两个或者两个以上方法的名称一样，参数列表不一样，和返回值无关，这些方法称之为重载
D: 在多个类中，两个或者两个以上方法的名称一样，参数列表必须一样，和返回值无关，这些方法称之为重载
题目2(单选):
下面关于方法的重载，描述错误的是（ A ）
选项 :
A: 方法重载，是指方法的名称相同，参数列表也相同的多个方法
B: 方法重载，可以减少对方法名称的命名次数
C: 方法重载，只能在同一个java类当中
D: 方法重载，返回值类型可以不相同
题目3(单选):
下面关于方法的参数传递正确的是( C ）
选项 :
A: 方法的参数是基本数据类型, 形参的改变直接影响实参的值
B: 方法的参数是引用数据类型, 形参的改变不影响实参的值
C: 方法的参数是基本数据类型, 形参的改变不影响实参的值
D: 方法的参数是基本数据类型,传递的是地址值.方法的参数是引用数据类型, 传递的是数据值
题目4(单选):
以下选项中，不属于方法重载的是（B ）
A:
public class Demo{
public int getSum(int a,byte b){
return a + b;
}
public int getSum(int a,int b){
return a + b;
}
}
B：
public class Demo{
public int getSum(int b,int a){
return a + b;
}
public void getSum(int a,int b){
System.out.println(a + b);
}
}
C:
public class Demo{
public long getSum(long a,int b){
return a + b;
}
public long getSum(int a,long b){
return a + b;
}
}
D:
public class Demo{
public void getSum(int a,int b){
System.out.println(a + b);
}
public int getSum(int a,int b,int c){
return a + b + c;
}
}
题目5(单选):
观察下面代码，最终在控制台显示 33 正确的方法调用格式是（ C ）
public static void main(String[] args){
//此处需要调用下面的某个方法，在控制台当中显示33
}
public static void printData(int a,int b){
System.out.println(11);
}
public static void printData(int a){
System.out.println(22);
}
public static void printData(boolean b){
System.out.println(33);
}
public static void printData(){
System.out.println(44);
}
选项 :
A: printData(10,20);
B: printData(333);
C: printData(true)
D: printData();
题目6(单选):
下面代码执行之后，控制台显示的结果是（ B ）
public static void main(String[] args){
int[] arr = { 11,22,33,44,55 };
method(arr);
for(int i = 0 ; i < arr.length ; i++){
System.out.print(arr[i] + " ");
}
}
public static void method(int[] arr){
for(int i = 0 ; i < arr.length ; i++){
if( i % 2 == 0 ){
arr[i] += 100;
}
}
}
选项 :
A: 11 122 33 144 55
B: 111 22 133 44 155
C: 11 22 33 44 55
D: 111 122 133 144 155
题目7(单选):
下列代码的运行结果是（B ）
public static void main(String[] args) {
int arr[] = {1, 3, 5, 7, 9};
int num = 10;
showArray(arr, num);
System.out.println("arr[2]的结果是:"+arr[2]);
System.out.println("num的结果是："+num);
}
private static void showArray(int[] arr, int num) {
arr[2] = 6;
num = 1;
}
选项 :
A: arr[2]的结果是：6
num的结果是：1
B: arr[2]的结果是：6
num的结果是：10
C: arr[2]的结果是：5
num的结果是：1
D: arr[2]的结果是：5
num的结果是：10
题目8(单选):
下列代码的运行结果是（ C ）
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
changeArr(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+",");
}
}
public static void changeArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if(arr[i]%2==1) {
arr[i] = 10;
}
}
}
选项 :
A: 1，2，3，4，5，
B: 1，10，3，10，5，
C: 10，2，10，4，10，
D: 10，10，10，10，10，
2 代码题
题目9:
请定义一个方法，该方法可以实现对int类型的数组进行遍历，在控制台打印所有元素。实现方法后，请在主方法中调用方法，查看结果。例如，数组为{11, 22, 33}，打印格式为：[11, 22, 33]
训练提示
1、首先明确方法的返回值和参数列表，该方法只需要在控制台输出，f返回值类型为void.要实现打印数组元素的功能，需要方法的调用者把想打印的数组传递过来，所以参数列表是int[] arr
2、方法实现之后，不调用的话会执行吗？该怎样调用？
操作步骤
1、定义方法，返回值类型为void，参数列表为int[] arr
2、在方法中，遍历数组，判断是否是最后一个元素，并且根据不同的情况输出不同的格式。
3、在主方法中定义一个数组，调用方法，将数组作为参数传递，查看运行结果。
参考代码
作业：
1.方法的使用
import java.util.Arrays;
/**
* @Author 赵广陆
* @Date 2020/3/1 0001 15:34
* @Version 1.0
*/
/*
*请定义一个方法，该方法可以实现对int类型的数组进行遍历，在控制台打印所有元素。
* 实现方法后，请在主方法中调用方法，查看结果。例如，数组为{11, 22, 33}，打印格式为：[11, 22, 33]
*
* */
public class Test07 {
public static void main(String[] args) {
int[] arr = {11, 22, 33};
tra(arr);
}
// 1、定义方法，返回值类型为void，参数列表为int[] arr
private static void tra(int[] arr) {
//2、在方法中，遍历数组，判断是否是最后一个元素，并且根据不同的情况输出不同的格式。
System.out.println("arr = " + Arrays.toString(arr));
}
// 3、在主方法中定义一个数组，调用方法，将数组作为参数传递，查看运行结果。
}
运行效果：
题目10:
请定义一个方法，实现交换整数数组中两个索引上的元素值。并调用方法，查看运行效果。
例如，数组为{11, 22, 33, 44, 55, 66}，交换索引1和索引5位置上的元素，结果为{11, 66, 33, 44, 55, 22}
训练提示
1、首先明确方法的返回值和参数列表，交换元素, 不需要具体返回值.我们要操作哪个数组，要交换哪两个索引上的元素，所以参数列表应该接收一个数组,和两个变量(代表的要交换的索引)
2、在方法中，如果交换两个数组中的元素, 需要根据索引进行交换
3、在主方法中，用void修饰的方法,如何调用？
操作步骤
1、定义方法，返回值void，参数列表 int[] arr, int index1, int index2。
2、在方法中，定义临时变量，交换两个索引上的元素值。
3、在主方法中，创建一个int数组，调用方法，将数组作为参数传递。然后遍历数组查看结果
参考代码
作业：
1.索引数据类型形式参数可以改变
import java.util.Arrays;
/**
* @Author 赵广陆
* @Date 2020/3/1 0001 16:01
* @Version 1.0
*/
/*
* 请定义一个方法，实现交换整数数组中两个索引上的元素值。并调用方法，查看运行效果。
例如，数组为{11, 22, 33, 44, 55, 66}，交换索引1和索引5位置上的元素，结果为{11, 66, 33, 44, 55, 22}
* */
public class Test08 {
public static void main(String[] args) {
int index1 = 1;
int index2 = 5;
int arr[] = {11, 22, 33, 44, 55, 66};
tra(arr, index1, index2);
}
// 1、定义方法，返回值void，参数列表 int[] arr, int index1, int index2。
private static void tra(int[] arr, int index1, int index2) {
int a = arr[index1];
arr[index1] = arr[index2];
//2、在方法中，定义临时变量，交换两个索引上的元素值。
arr[index2] = a;
//3、在主方法中，创建一个int数组，调用方法，将数组作为参数传递。然后遍历数组查看结果
System.out.println("arr = " + Arrays.toString(arr) + ", index1 = " + index1 + ", index2 = " + index2);
}
}
运行效果：
第十章：java综合代码题
1 代码题
题目1:减肥活动
输入星期数，显示今天的减肥活动 周一：跑步 周二：游泳 周三：慢走 周四：动感单车 周五：拳击 周六：爬山 周日：好好吃一顿
操作步骤
键盘录入一个星期数，用一个变量接收
对星期数进行判断，这里用 switch 语句实现
在对应的语句控制中输出对应的减肥活动
参考代码
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 14:18
* @Version 1.0
*/
public class Test09 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数：");
int week = sc.nextInt();
switch (week) {
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("你输入的星期数有误");
}
}
}
题目2：逢七过
朋友聚会的时候可能会玩一个游戏：逢七过。 规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。 为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。 这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
操作步骤
数据在1-100之间，用for循环实现数据的获取
根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
在控制台输出满足规则的数据
参考代码
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 14:29
* @Version 1.0
*/
public class Test10 {
public static void main(String[] args) {
for (int x = 1; x <= 100; x++) {
//根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
if (x % 10 == 7 || x / 10 % 10 == 7 || x % 7 == 0) {
System.out.println(x);
}
}
}
}
题目3：不死神兔
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子， 假如兔子都不死，问第二十个月的兔子对数为多少？
操作步骤
为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
用循环实现计算每个月的兔子对数
输出数组中最后一个元素的值，就是第20个月的兔子对数
参考代码
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 15:19
* @Version 1.0
*/
/* 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
假如兔子都不死，问第二十个月的兔子对数为多少？*/
public class Test11 {
public static void main(String[] args) {
//在数组中不断叠加，有20个月叠加20次
int[] arr = new int[20];
//第一个月1只
arr[0] = 1;
//第二个月2两只
arr[1] = 1;
for (int x = 2; x < arr.length; x++) {
//第三个月多一只，三个月之后每个月再多一只
arr[x] = arr[x - 2] + arr[x - 1];
}
System.out.println("第二十个月兔子的对数是：" + arr[19]);
}
}
题目4：百钱买百鸡
我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。 百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
操作步骤
第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
这个时候，用于表示鸡雏的变量 z = 100 – x – y . 判断表达式 z%3==0 和表达式 5x + 3y + z/3 = 100 是否同时成立，如果成立，输出对应的 x，y，z 的值， 就是对应的鸡翁，鸡母，鸡雏的值
参考代码
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 15:42
* @Version 1.0
*/
/*
* 我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
* 百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？*/
public class Test12 {
public static void main(String[] args) {
//第1层循环，用于表示鸡翁的范围也就是全买鸡翁和一只不买的范围
for (int x = 0; x <= 20; x++) {
//第2层循环，用于表示鸡母的范围
for (int y = 0; y <= 33; y++) {
//这个时候，用于表示鸡雏的变量
//意思就是剩下的全买小鸡仔，小鸡仔最便宜
int z = 100 - x - y;
if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
System.out.println(x + "," + y + "," + z);
}
}
}
}
}
题目5：数组偶数求和
有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和， 要求是：求和的元素个位和十位都不能是7，并且只能是偶数
操作步骤
定义一个数组，用静态初始化完成数组元素的初始化
定义一个求和变量，初始值是0
遍历数组，获取到数组中的每一个元素
判断该元素是否满足条件，如果满足条件就累加
输出求和变量的值
参考代码
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 16:13
* @Version 1.0
*/
/*
*有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，
要求是：求和的元素个位和十位都不能是7，并且只能是偶数
* */
public class Test13 {
public static void main(String[] args) {
int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
//也就是68+88+996+210=1362
int sum = 0;
for (int x = 0; x < arr.length; x++) {
// 求和的元素个位和十位都不能是7，并且只能是偶数
if (arr[x] % 10 != 7 && arr[x] / 10 % 10 != 7 && arr[x] % 2 == 0) {
sum += arr[x];
}
}
System.out.println("sum:" + sum);
}
}
题目6：数组交换
已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换， 交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
操作步骤
定义一个数组，用静态初始化完成数组元素的初始化
循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
变量交换
遍历数组
参考代码
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 16:45
* @Version 1.0
*/
public class Test14 {
public static void main(String[] args) {
int[] arr = {19, 28, 37, 46, 50};
reverse(arr);
printArray(arr);
}
public static void reverse(int[] arr) {
for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
}
题目7：评委打分
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
操作步骤
1:定义一个数组，用动态初始化完成数组元素的初始化，长度为6
键盘录入评委分数
由于是6个评委打分，所以，接收评委分数的操作，用循环改进
定义方法实现获取数组中的最高分(数组最大值)，调用方法
定义方法实现获取数组中的最低分(数组最小值) ，调用方法
定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
按照计算规则进行计算得到平均分
输出平均分
参考代码
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/3/3 0003 16:55
* @Version 1.0
*/
public class Test15 {
public static void main(String[] args) {
int[] arr = new int[6];
Scanner sc = new Scanner(System.in);
for (int x = 0; x < arr.length; x++) {
System.out.println("请输入第" + (x + 1) + "个评委的打分：");
arr[x] = sc.nextInt();
}//printArray(arr);
int max = getMax(arr);
int min = getMin(arr);
int sum = getSum(arr);
int avg = (sum - max - min) / (arr.length - 2);
System.out.println("选手的最终得分是：" + avg);
}
public static int getSum(int[] arr) {
int sum = 0;
for (int x = 0; x < arr.length; x++) {
sum += arr[x];
}
return sum;
}
public static int getMin(int[] arr) {
int min = arr[0];
for (int x = 1; x < arr.length; x++) {
if (arr[x] < min) {
min = arr[x];
}
}
return min;
}
public static int getMax(int[] arr) {
int max = arr[0];
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) {
max = arr[x];
}
}
return max;
}
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
}
第十一章：java类和对象测试题
1 选择题
题目1(单选):
下列关于面向对象描述错误的是 ( C )
选项 :
A: 面向对象是一种基于面向过程的编程思想。
B: 使用面向对象思想完成一个功能，强调找一个具有该功能的对象，使用这个对象完成功能。
C: 面向对象与面向过程，两种思想相互独立，二者没有任何关联.
D: 毛毛想吃棉花糖，她有2种方案，一是出去小吃街上找个卖棉花糖的商贩，让商贩给做一个大棉花糖.二是 自己上网搜索制作棉花糖的步骤，然后学着一步步自己做。自己做，就是面向过程思想，关注步骤;找商贩做就是面向对象思想，关注具备功能的对象.
题目2(单选):
下列关于类和对象描述正确的是（ D ）
选项 :
A: 类是描述事物的属性和行为的特征而对象是一类事物的模板
B: 类是事物的具体体现而对象是一组相关属性和行为的集合
C: 类和对象可以看成是一类事物的模板
D: 类是对一类事物的描述，是抽象的,可以看做成模板, 而对象是一类事物的实例，是具体的
题目3(单选):
下列信息中包含的内容不是类与对象关系的是（ C ）
选项 :
A: 学生和小明同学
B: 电脑和联想Y430电脑
C: 猫和狗
D: 手机和华为P30手机
题目4(单选):
为Person类定义姓名(name)、年龄(age)属性，为Person类定义吃饭(eat)行为，横线处应该填写的代码是（ D ）
public class Person {
// 属性:姓名
// 属性:年龄
// 行为:吃饭
}
选项 :
A
String name;
String age;
public static void eat(){}
B
int name;
String age;
public void eat(){}
C
int name;
int age;
public static void eat(){}
D
String name;
int age;
public void eat(){}
题目5(多选):
代码如下：
public class Hero{
String name;
int age;
String gender;
public void skillQ(){
System.out.println("Q技能");
}
public void skillW(){
System.out.println("W技能");
}
public void skillE(){
System.out.println("E技能");
}
public void skillR(){
System.out.println("R技能");
}
}
下列说法正确的是（BD ）
选项 :
A: 英雄类中，变量name，age，gender没有赋值所以语法错误。
B: skillQ，skillW，skillE，skillR四个方法代表了这个英雄的四个行为。
C: 这个类中方法没有加static，所以语法错误。
D: 这个类是一个正确的定义格式，表示描述英雄这个事物，用属性和行为来进行描述的。
题目6(单选):
下列代码的运行结果是（ A ）
class Student {
String name;
int age;
public void show() {
System.out.println(name + "，" + age);
}
}
public class Test {
public static void main(String[] args) {
Student s = new Student();
s.show();
s.name = "张三丰";
s.age = 108;
s.show();
}
}
选项 :
A: null，0
张三丰，108
B: ""，0
"张三丰"，108
C: null，null
"张三丰"，108
D: null，null
张三丰，108
题目7(单选):
下列关于局部变量和成员变量描述错误的是（ B）
选项 :
A: 成员变量定义在类中，方法外；局部变量定义在方法内。
B: 成员变量和局部变量在整个类中都可以使用
C: 成员变量有默认值；局部变量没有默认值，必须先赋值，后使用.
D: 成员变量随对象一起在堆内存中存储，局部变量随方法的调用而存在于栈内存。
题目8(单选):
代码如下：
public class Student{
String name;
int age;
public void study(){
System.out.println("学习");
}
}
public class Demo{
public static void main(String [] args){
Student s = new Student(); ①
s.name = "小丽"; ②
s.age = 16; ③
s.study(); ④
s = new Student(); ⑤
s.name = "小丽";
s.age = 16;
s.study();
}
}
下列说法错误的是（D ）
选项 :
A: 关于①这一行代码，表示在堆里面开辟一个空间。等号左边的局部变量在栈，右边new出来的空间在堆，把右边的地址值赋值给左边的变量。
B: ②这里表示把"小丽"这个值赋值给s记录的对象中name属性 ，
C: ④这个代码表示调用成员方法，所以此时study这个方法会被加载进栈执行。
D: ⑤这里的对象跟①处的对象，属性都是小丽，16。所以表示同一个对象。
2 代码题
题目9:
请定义教师类（Teacher），属性包括姓名和工号。。定义教课（teach）方法，输出“工号为xxx的xxx老师正在讲课”。
训练提示
1、教师类，属性有两个，姓名和工号，定义为成员变量，都可以定义为字符串类型
2、教师类，有一个教课行为，定义成员方法，输出相应的信息
4、教师类定义完，在测试类中创建对象进行测试。
操作步骤
1、定义Teacher类，定义两个成员变量String name, String id，都使用private修饰
2、编写成员方法teach()，按照要求的格式将属性信息进行输出。
4、编写测试类TeacherTest，在主方法中创建教师对象，直接调用对象的属性,进行赋值
5、调用teach方法。
参考代码
Teacher类：
/**
* @Author 赵广陆
* @Date 2020/3/4 0004 16:59
* @Version 1.0
*/
/*
* 1、教师类，属性有两个，姓名和工号，定义为成员变量，都可以定义为字符串类型
2、教师类，有一个教课行为，定义成员方法，输出相应的信息
4、教师类定义完，在测试类中创建对象进行测试。
* */
public class Teacher {
private String name;
private String id;
public void teach(){
System.out.print("老师正在讲课");
}
public String getName(String name) {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId(String s) {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public String toString() {
return "工号为：" + id + name +"老师";
}
}
测试类：
/**
* @Author 赵广陆
* @Date 2020/3/4 0004 15:52
* @Version 1.0
*/
public class Test16 {
public static class Demo{
public static void main(String [] args){
Teacher teach=new Teacher();
teach.setId("007");
teach.setName("王");
System.out.print(teach.toString());
teach.teach();
}
}
}
运行效果
题目10:
定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。
定义测试类，在主方法中创建对象，直接给对象的属性赋值。
调用对象的两个功能，打印效果如下：
正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....
训练提示
类中的属性就是成员变量，类中的行为功能就是成员方法。
操作步骤
定义手机类，手机类中定义String类型的品牌，int类型的价格，String类型的颜色，
编写打电话的成员方法，方法中对成员变量进行使用。
编写发短信的成员方法，方法中对成员变量进行使用。
在测试类中创建手机对象，直接给对象的属性赋值，分别调用各个方法。
参考代码
手机类：
public class Phone {
String brand;
int price;
String color;
public void call(){
System.out.println("打电话....");
}
public void sendMessage(){
System.out.println("发短信....");
}
@Override
public String toString() {
return "正在使用" + "价格为"+price+"元"+ color+brand+"手机";
}
}
测试类：
/**
* @Author 赵广陆
* @Date 2020/3/4 0004 17:23
* @Version 1.0
*/
public class Test17{
public static void main(String[] args) {
Phone ph1=new Phone();
ph1.brand="小米";
ph1.color="黑色的";
ph1.price=3998;
System.out.print(ph1.toString());
ph1.call();
Phone ph2=new Phone();
ph2.brand="小米";
ph2.color="黑色的";
ph2.price=3998;
System.out.print(ph2.toString());
ph2.sendMessage();
}
}
运行效果：
第十二章：java封装构造测试题
1 选择题
题目1(单选):
下列关于private描述错误的是 ( D )
选项 :
A: 被private修饰的成员变量和成员方法，只能在本类中使用，不能在其他类中直接访问
B: private是一个权限修饰符，可以完成类对成员变量的封装，防止外部非法访问.
C: 类的成员变量被private修饰，如果想让成员变量被其他类使用，可以为成员变量提供对应public的setXxx和getXxx方法.
D: private仅用来修饰成员变量.
题目2(单选):
下列关于this描述错误的是（ B ）
选项 :
A: 当成员变量和局部变量重名时，可以使用this来区分。
B: this可以调用本类的成员变量和成员方法 ,调用不了构造方法
C: this表示本类对象的引用。
D: 在方法中访问本类成员变量(非重名)，可以省略this不写。
题目3(多选):
下列关于构造方法说法正确的是（BD ）
选项 :
A: 我们可以用对象直接调用构造方法。
B: 构造方法在创建对象的时候被调用，用来进行对成员变量的初始化
C: 构造方法的方法名可以随便定义，只要符合Java的基本命名规范即可。
D: 构造方法不能有返回值，连void都不能有。
题目4(单选):
代码如下：
public class Person{
private String name;
__________________
}
横线处填写Person类的构造方法的正确语法格式是（C ）
选项 :
A
public void Person(String name){
name = name;
}
B
public person(){
}
C
public Person(String name){
this.name = name;
}
D
public Person(String name){
return name;
}
题目5(单选):
代码如下：
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge(){
return age;
}
public void show(){
System.out.println(name + "---" + age);
}
}
下列描述正确的是（C ）
选项 :
A: 此时空参构造可以省略不写，因为虚拟机会默认给出。 X
B: 根据面向对象的要求，get和set方法不写，只要把定义变量前面的private删掉也可以。 //不满足封装效果感觉不对
C: 全参构造用来给成员变量初始化值,set方法用来给成员变量赋值
D: 构造方法的名字大小写都可以 X
题目6(单选):
下列代码的运行结果是（C ）
class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Demo{
public static void main(String [] args){
Student s = new Student();
s.setName("小丽");
s.setAge(16);
System.out.println(s.getName() + "---" + s.getAge());
}
}
选项 :
A: 语法错误，编译报错。
B: 小丽 --- 16
C: null --- 16
D: 小丽 --- 0
题目7(单选):
下列代码的运行结果是（D ）
public class Person{
private String name;
private int age;
public void setAge(int age){
this.age = age; //请重点关注
}
public int getAge(){
return age; //请重点关注
}
public void setName(String name){
name = name; //请重点关注
}
public String getName(){
return name; //请重点关注
}
public void show(){
System.out.println(age + "::"+ name);
}
}
public class Test{
public static void main(String[] args){
Person p = new Person();
p.age = 10;
p.setName("播仔");
p.show();
}
}
选项 :
A: 10::播仔
B: 0::播仔
C: 10::null
D: 语法错误，编译报错。
题目8单选):
下列代码的运行结果是（B ）
public class Person{
private String name="张三";
public Person(){
name="李四";
}
public Person(String name){
this.name=name;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void show(){
System.out.println(name);
}
}
public class Test{
public static void main(String[] args){
Person p1=new Person();
p1.show();
Person p2=new Person("王五");
p2.show();
}
}
选项 :
A: 张三
李四
B: 李四
王五
C: 张三
王五
D: 李四
张三
2 代码题
题目9:
定义标准学生类，属性包括姓名和年龄，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
训练提示
1、学生类，属性有两个，姓名和年龄，定义为成员变量，姓名是字符串类型，年龄是整数
2、提供空参构造、带参构造，提供两个成员变量的get和set方法
3、学生类，有一个show方法，定义成员方法，输出相应的信息
4、学生类定义完，在测试类中创建对象进行测试。
操作步骤
1、定义Student类，定义两个成员变量String name, int age，都使用private修饰
2、提供空参构造方法和有参构造方法，提供get和set方法
3、编写成员方法show()，按照要求的格式将属性信息进行输出。
4、编写测试类StudentTest，在主方法中创建学生对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值。
5、调用show方法。
参考代码
Student类：
/**
* @Author 赵广陆
* @Date 2020/3/5 0005 15:55
* @Version 1.0
*/
/*
* 定义标准学生类，属性包括姓名和年龄，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值
* 有参创建的对象直接赋值，并通过show方法展示数据。
* */
/*
* ### 操作步骤
1、定义Student类，定义两个成员变量String name, int age，都使用private修饰
2、提供空参构造方法和有参构造方法，提供get和set方法
3、编写成员方法show()，按照要求的格式将属性信息进行输出。
4、编写测试类StudentTest，在主方法中创建学生对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值。
5、调用show方法。
* */
public class Student {
private String name;
private int age;
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.print("name = " + name);
System.out.println("age = " + age);
};
}
测试类：
/**
* @Author 赵广陆
* @Date 2020/3/5 0005 16:14
* @Version 1.0
*/
public class StudentTest {
public static void main(String[] args) {
Student stu=new Student();
stu.setAge(18);
stu.setName("张三");
stu.show();
}
}
运行效果
题目10:
请定义教师类（Teacher），属性包括姓名和工号。要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值。定义教课（teach）方法，输出“工号为xxx的xxx老师正在讲课”。
训练提示
1、教师类，属性有两个，姓名和工号，定义为成员变量，都可以定义为字符串类型
2、提供空参构造、带参构造，提供两个成员变量的get和set方法
3、教师类，有一个教课行为，定义成员方法，输出相应的信息
4、教师类定义完，在测试类中创建对象进行测试。
操作步骤
1、定义Teacher类，定义两个成员变量String name, String id，都使用private修饰
2、提供空参构造方法和有参构造方法，提供get和set方法
3、编写成员方法teach()，按照要求的格式将属性信息进行输出。
4、编写测试类TeacherTest，在主方法中创建教师对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值。
5、调用teach方法。
参考代码
Teacher类：
/**
* @Author 赵广陆
* @Date 2020/3/5 0005 16:17
* @Version 1.0
*/
/*
* 定义标准学生类，属性包括姓名和年龄，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值
* 有参创建的对象直接赋值，并通过show方法展示数据。
* */
//4、编写测试类TeacherTest，在主方法中创建教师对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值。
public class Teacher {
String name;
private String id;
public Teacher() {
this.name = "王";
this.id = "007";
}
public void teach() {
System.out.println("工号为" + id + name + "老师正在讲课");
}
public String getId(String s) {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
public String getName(String name) {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Teacher(String name, String id) {
this.name = name;
this.id = id;
System.out.println("工号为" + id + name + "老师正在讲课");
}
@Override
public String toString() {
return "工号为" + id + name + "老师"+"正在讲课";
}
}
测试类：
/**
* @Author 赵广陆
* @Date 2020/3/5 0005 16:32
* @Version 1.0
*/
public class TeacherTest {
public static void main(String[] args) {
Teacher th=new Teacher();
//无惨构造直接赋初值
th.teach();
//有参构造直接赋值
Teacher th1=new Teacher("李","008");
//空参set get赋值
Teacher teach=new Teacher();
teach.setId("009");
teach.name="东哥";
System.out.print(teach.toString());
}
}
运行效果：
第十三章：java字符串String和StringBuilder测试题
1 选择题
题目1(单选):
下面是关于String类 API 当中与判断相关的方法，如果用于忽略大小写验证码的判断，最佳的方法是（B ）
选项 :
A：区分大小写比较
public boolean equals(Object anObject){ ... }
B：
public boolean equalsIgnoreCase(String anotherString){ ... }
C：测试此字符串是否以指定的后缀结尾。
public boolean endsWith(String suffix){ ... }
D：测试此字符串是否以指定的前缀开头。
public boolean startsWith(String prefix){ ... }
题目2(单选):
下列代码的运行结果是（ C ）
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = "ABC";
String s4 = "a";
String s5 = s4 + "bc";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println(s2.equals(s5));
System.out.println(s3.equalsIgnoreCase(s5));
}
选项 :
A: true false true true
B: true true false true
C: true true true true
D: true true true false
题目3(单选):
以下哪个选项可以获取字符串对象的长度（B ）
选项 :
A：
public int length
B：
public int length(){ ... }
C：
public int size(){ ... }
D：返回指定索引处的 char值。
public char charAt(int index){ ... }
题目4(多选):
下列关于String和StringBuilder的区别( BC )
选项 :
A: String是可变的字符序列
B: String是不可变的字符序列
C: StringBuilder是可变的字符序列
D: StringBuilder是不可变的字符序列
题目5(单选):
下列选项中,关于StringBuilder的说法正确的是( D )
选项 :
A: StringBuilder类只有一个空参构造
B: StringBuilder的length()方法可以得到该对象的字符容量 //返回长度（字符数）。
C: public StringBuilder()的作用是构造一个不带任何字符的字符串容器返回长度（字符数）。 ，其初始容量为 0 个字符
D: public StringBuilder()的作用是构造一个不带任何字符的字符串容器，其初始容量为 16 个字符
题目6(单选):
下列选项中,关于StringBuilder的说法正确的是 ( C )
选项 :
A: StringBuilder和String都是字符串类，所以它们所有方法都是相同的
B: StringBuilder和String都是字符串类，它们所有的构造方法都是相同的
C: 可以通过构造方法public StringBuilder(String str)把一个String对象转为StringBuilder对象
D: StringBuilder的对象可以使用字符串赋值，如：StringBuilder sb = "abc";
// StringBuilder sb1 = new StringBuilder("字符串"); //以String对象作为参数构建字符串
题目7(单选):
阅读如下代码, 选择出正确的运行结果( B )
public class Test {
public static void main(String[]args) {
StringBuilder sb = newStringBuilder("a");
sb.append("b");
sb.append("c");
sb.append("ddd");
sb.append("e");
System.out.println(sb.length());
}
}
选项 :
A: 5
B: 7
C: 4
D: 0
题目8单选):
请查看以下代码,正确的结果是( A )
StringBuilder sb = new StringBuilder();
sb.append("a");
sb.append("b").append("c").reverse();
System.out.println(sb.toString());
选项 :
A: cba
B: ABC
C: abc
D: cba
2 代码题
题目9:
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
训练提示
定义统计变量
遍历字符串,筛选出指定的字符, 让对应记录的变量累加
操作步骤
键盘录入一个字符串，用 Scanner 实现
要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
遍历字符串，得到每一个字符
判断该字符属于哪种类型，然后对应类型的统计变量+1
假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
大写字母：ch>='A' && ch<='Z'
小写字母： ch>='a' && ch<='z'
数字： ch>='0' && ch<='9' 5:
输出三种类型的字符个数
参考代码
import com.sun.org.apache.xerces.internal.impl.io.ASCIIReader;
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/3/7 0007 16:30
* @Version 1.0
*/
/*
* 键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
*
* 1. 键盘录入一个字符串，用 Scanner 实现
2. 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
3. 遍历字符串，得到每一个字符
4. 判断该字符属于哪种类型，然后对应类型的统计变量+1
假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
大写字母：ch>='A' && ch<='Z'
小写字母： ch>='a' && ch<='z'
数字： ch>='0' && ch<='9' 5:
5. 输出三种类型的字符个数
* */
public class Test20 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
char ch1 = 0;//大写字母：ch>='A' && ch<='Z'
char ch2 = 0;//小写字母： ch>='a' && ch<='z'
char ch3 = 0;//数字： ch>='0' && ch<='9' 5:
//ASCII A-Z 65-90 a-z 97-122 0-9 48-57
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);//返回指定索引处的 char值。
if (ch >= 65 && ch <= 90) {
ch1++;
} else if (ch >= 97 && ch <= 122) {
ch2++;
} else {
ch3++;
}
}
System.out.println("大写字母为：" + (int) ch1 + "小写字母" + (int) ch2 + "数字：" + (int) ch3);
}
}
运行效果
题目10:
请定义一个方法用于判断一个字符串是否是对称的字符串，并在主方法中测试方法。例如："abcba"、"上海自来水来自海上"均为对称字符串。
训练提示
1、判断是否对称，方法的返回值是什么类型boolean.参数列表需要接收一个S
2、怎样判断对称呢？如果可以将字符串反转，反转后发现跟原来的字符串完全一样，不就可以判断出来了吗，那么哪个类有字符串的反转功能呢？
操作步骤
1、定义方法，返回值类型为boolean，参数列表为String类型的一个参数。
2、将字符串转换为StringBuilder类型，调用StringBuilder的reverse()方法将字符串反转。
3、将反转后的字符串再转回String类型，并与原字符串比较，如果相等，返回true，否则返回false
4、在主方法中，定义一个字符串，调用方法测试结果。
参考代码
/**
* @Author 赵广陆
* @Date 2020/3/7 0007 17:10
* @Version 1.0
*/
/* 请定义一个方法用于判断一个字符串是否是对称的字符串，
并在主方法中测试方法。例如："abcba"、"上海自来水来自海上"均为对称字符串。
*1、定义方法，返回值类型为boolean，参数列表为String类型的一个参数。
2、将字符串转换为StringBuilder类型，调用StringBuilder的reverse()方法将字符串反转。
3、将反转后的字符串再转回String类型，并与原字符串比较，如果相等，返回true，否则返回false
4、在主方法中，定义一个字符串，调用方法测试结果。
构造方法用来构造对象，声明对象之后可以调用API方法！
*/
public class Test21 {
public static void main(String[] args) {
String s="abcba";
StringBuilder sb=new StringBuilder(s);
StringBuilder sb1 = sb.reverse();
String s1=sb1.toString();
Boolean aBoolean = StrCompare(s, sb1);
System.out.println("aBoolean = " + aBoolean);
}
public static Boolean StrCompare(String s, StringBuilder sb){
String s1 = sb.toString();
if ( s == s1) {
return true;
}else{
return false;
}
}
}
运行效果
第十四章：ArrayList集合
1 选择题
题目1(单选):
下列有关数组和集合说法,错误的选项为 ( A )
选项 :
A：数组和集合的长度都是可变的
B：数组的长度固定, 集合的长度可变
C：数组可以存储基本类型和引用类型数据
D: 集合中存储的是引用数据类型
题目2(单选):
下列关于集合说法,错误的选项是( A )
选项 :
A: ArrayList可以存储任意数据类型的数据
//ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 <int> 不能写，但是存储基本数据类型对应的包装类型是可以的。
B: ArrayList集合容器存储数据，其长度可以发生改变
C: ArrayList集合容器可以通过add方法存储数据
D: ArrayList 集合容器存储数据，存储的是地址值
题目3(单选):
下列代码可以正常编译运行的是（ C）
选项 :
A：
ArrayList<String> list = new ArrayList<String>();
list[0] = "程序员";
B：
ArrayList<int> list = new ArrayList<>();
list.add(1024);
C：
ArrayList<String> list = new ArrayList<>();
list.add("程序员");
D：
ArrayList<String> list = new ArrayList<>();
list.append("程序员");
题目4(单选):
下面代码中用于打印输出集合中的数据元素总量，横线处应该填写的正确代码是（ D ）
public static void main(String[] args){
ArrayList<String> list = new ArrayList<>();
list.add("itoldlu");
list.add("love");
list.add("life");
list.add("love");
list.add("java");
System.out.println("集合当中的元素个数有:" + ___________________);
}
选项 :
A: list.length
B: list.length()
C: list.size
D: list.size()
题目5(单选):
public static void main(String[] args){
ArrayList<String> list = new ArrayList<>();
list.add("php");
list.add("oldlu");
list.add("oldlu");
list.add("baima");
list.add("java");
System.out.println("集合当中的元素个数有:" + _________);
System.out.println("获取集合中的元素oldlu:" + _________);
System.out.println("删除集合中的元素php:" + _________);
}
横线处根据输出要求应该填写的代码是（ C ）
选项 :
A: ①list.size(5) ②list.get(1) ③list.remove(0)
B: ①list.length() ②list.get(2) ③list.remove(0)
C: ①list.size() ②list.get(2) ③list.remove(0)
D: ①list.size() ②list.get(3) ③list.remove(1)
题目6(单选):
代码如下：
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("orange");
list.add("pear");
for (int i = 0; i <______________ i++) {
System.out.println(______________);
}
}
完成集合数据的遍历并将数据显示出来，横线处应该填写的代码是（ C ）
选项 :
A: ①list.length(); ②list[i]
B: ①list.length(); ②list.get(i)
C: ①list.size(); ②list.get(i)
D: ①list.size(); ②list[i]
题目7(单选):
下面代码是 ArrayList集合存储 Student的对象之后，遍历输出到控制台的操作，横线处代码填写正确的是 ( D )
学生类 :
public Student{
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
测试类 :
public class Test{
public static void main(String[] args){
ArrayList<Student> list = new ArrayList<>();
Student stu01 = new Student("喜洋洋",18);
Student stu02 = new Student("令狐冲",19);
Student stu03 = new Student("石破天",16);
list.add(stu01);
list.add(stu02);
list.add(stu03);
//循环遍历集合,打印输出集合当中的每一个元素数据,显示在控制台当中。
for(int i=0; ____(1)____ ; i++){
__(2)__ = list.get(i);
System.out.println("姓名:" + stu.getName() + ",年龄:" + stu.getAge());
}
}
}
选项 :
A: ① i<list.length() ②Student stu
B: ① i<list.length() ②String stu
C: ① i<list.size() ②String stu
D: ① i<list.size() ②Student stu
题目8单选):
下列代码的运行结果是（B ）
public static void main(String[] args){
ArrayList<String> list = new ArrayList<>();
list.add("PHP");
list.add("Android");
list.add("iOS");
list.add("Java");
ArrayList<String> newList = method(list);
System.out.println(newList);
}
public static ArrayList<String> method(ArrayList<String> list){
ArrayList<String> array = new ArrayList<>();
for(int i=0;i<list.size();i++){
String str = list.get(i);
if(str.equals("Java")){
array.add("得Java者，得天下~");
}
}
return array;
}
选项 :
A: [PHP，Android，iOS，Java]
B: [得Java者，得天下~]
C: [PHP，Android，iOS，Java，得Java者，得天下~]
D: [PHP，Android，iOS，得Java者，得天下~]
2 代码题
题目9
现有如下字符串元素：["aaa", "bbb", "aaa", "aaa", "ccc", "bbb"]，请将所有的元素按顺序存入ArrayList集合中，并遍历集合查看存储结果。
训练提示
1、创建ArrayList集合，泛型如何定义？
2、怎样将数据添加到集合中？
3、怎样遍历集合？
操作步骤
1、创建ArrayList集合对象，泛型声明为String类型
2、调用集合的add方法，将元素依次存入集合
3、遍历集合
3.1、定义循环，索引从0到集合的size-1
3.2、通过ArrayList集合的get方法，依次获取索引上的元素
参考代码
import java.util.ArrayList;
/**
* @Author 赵广陆
* @Date 2020/3/8 0008 16:36
* @Version 1.0
*/
/*
* 现有如下字符串元素：["aaa", "bbb", "aaa", "aaa", "ccc", "bbb"]，
* 请将所有的元素按顺序存入ArrayList集合中，并遍历集合查看存储结果。 */
public class Test22 {
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<>();
al.add("aaa");
al.add("bbb");
al.add("aaa");
al.add("aaa");
al.add("ccc");
al.add("bbb");
for (int i = 0; i <al.size() ; i++) {
System.out.println(al.get(i));
}
System.out.println(al);
}
}
运行效果
题目10:
请定义教师（Teacher）类，属性包含姓名和专业名称。将若干教师对象存入ArrayList集合中，并遍历集合打印教师信息，格式如下：
姓名：果果老师, 专业：javase
姓名：张1老师, 专业：javaee
姓名：张2老师, 专业：php
姓名：张3老师, 专业：python
训练提示
1、怎样定义一个描述教师信息的类？
2、需要将教师对象存入集合，创建集合对象，泛型该怎样定义？
3、怎样将数据添加到集合中？
4、怎样遍历ArrayList集合？输出信息时，直接打印对象名称可以吗？怎样才能按照题目要求格式输出信息？
操作步骤
1、新建Teacher类，成员变量为String类型的name和course，私有修饰，提供构造方法，提供get和set方法。
2、创建ArrayList集合对象，泛型声明为Teacher类型
3、创建若干Teacher对象，可以使用构造方法为成员变量赋值，调用集合的add方法，将元素依次存入集合。
4、遍历集合
4.1、定义循环，索引从0到集合的size-1。
4.2、通过ArrayList集合的get方法，依次获取索引上的元素。
4.3、通过Teacher对象的get方法，获取属性值，拼接成要求的格式输出。
参考代码
老师类：
/**
* @Author 赵广陆
* @Date 2020/3/8 0008 17:08
* @Version 1.0
*/
public class Teacher {
private String name;
private String course;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourse() {
return course;
}
public void setCourse(String job) {
this.course = job;
}
public Teacher() {
}
public Teacher(String name, String job) {
this.name = name;
this.course = job;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", job='" + course + '\'' +
'}';
}
}
测试类：
import jdk.internal.dynalink.beans.StaticClass;
import java.util.ArrayList;
import java.util.Scanner;
/**
* @Author 赵广陆
* @Date 2020/3/8 0008 17:06
* @Version 1.0
*/
/*
* 请定义教师（Teacher）类，属性包含姓名和专业名称。
* 将若干教师对象存入ArrayList集合中，并遍历集合打印教师信息，格式如下：
*
*
姓名：果果老师, 专业：javase
姓名：张1老师, 专业：javaee
姓名：张2老师, 专业：php
姓名：张3老师, 专业：python
* 1、新建Teacher类，成员变量为String类型的name和course，私有修饰，提供构造方法，提供get和set方法。
2、创建ArrayList集合对象，泛型声明为Teacher类型
3、创建若干Teacher对象，可以使用构造方法为成员变量赋值，调用集合的add方法，将元素依次存入集合。
4、遍历集合
4.1、定义循环，索引从0到集合的size-1。
4.2、通过ArrayList集合的get方法，依次获取索引上的元素。
4.3、通过Teacher对象的get方法，获取属性值，拼接成要求的格式输出。*/
public class Test23 {
public static void main(String[] args) {
ArrayList<Teacher> al=new ArrayList<>();
addTeacher(al);
addTeacher(al);
addTeacher(al);
addTeacher(al);
for (int i = 0; i <al.size() ; i++) {
Teacher te=al.get(i);
System.out.println("姓名："+te.getName() + "," +"专业"+ te.getCourse());
}
}
public static void addTeacher(ArrayList<Teacher> al){
Scanner sc = new Scanner(System.in);
System.out.println("请输入老师姓名:");
String name = sc.nextLine();
System.out.println("请输入老师职业:");
String course = sc.nextLine();
Teacher te=new Teacher();
te.setName(name);
te.setCourse(course);
al.add(te);
}
}
运行效果
572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
