JavaSE练习题
JavaSE核心技术
姓名 _______________ 序号 _______________ 得分 _______________
第一部分：选择题
1、 [ 单选题 ]
在java代码中，以下哪些是声明一个方法抛出异常的正确形式？请选择一个正确答案：
（ A ）
A、void m() throws IOException{};
B、void m() throw IOException{};
C、void m(void) throws IOException{};
D、m() throws IOException{};
E、void m() {} throws IOException
解析：throw是语句抛出一个异常，throws是方法可能抛出异常的声明。
2、 [ 单选题 ]
若在Java代码中，某一个类定义中定义有如下的方法：static void testMethod( ) 该方法属于 ：
（ C ）
A、本地方法
B、最终方法
C、静态方法
D、抽象方法
3、 [ 单选题 ]
在java代码中，设 X 、Y 均为已定义的类名，下列声明类X的对象x1的语句中正确的是：
（ A ）
A、X x1;
B、X x1= X ( ); 解析：少new
C、X x1=new Y( )
D、int X x1;
4、 [ 单选题 ]
下列哪一个是合法的标识符:
（ ）
A、12class 不能数字开头
B、+void 只能字母、下划线、数字、$组成。
C、-5 负数
D、_black
解析：
1)、名称只能由字母、数字、下划线、$符号组成
2)、不能以数字开头
3)、名称不能使用JAVA中的关键字。
4)、坚决不允许出现中文及拼音命名。
5、 [ 单选题 ]
Random．nextInt（20）得到的结果不可能是 （ C ）
A、0
B、10
C、20
D、19
解析：//随机生成一个整数，这个整数的范围就是[0,20）
6、 [ 单选题 ]
欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的 （ B ）
A、ArrayList myList=new Object（）；
B、List myList=new ArrayList（）；
C、ArrayList myList=new List（）；
D、List myList=new List（）；
解析：
7、 [ 单选题 ]
下列数据类型的精度由高到低的顺序是：
（ B ）
A、float，double，int，long
B、double，float，int，byte
C、byte，long，double，float
D、double，int，float，long
8、 [ 单选题 ]
下列针对int类型的私有属性age的访问器方法格式正确的是:
（ C ）
A、void getAge(int age)
B、int getAge(int age)
C、void setAge(int age)
D、int setAge()
9、 [ 单选题 ]
下列类头定义中，错误的是：
（ A ）
A、public x extends y
B、public class x extends y
C、class x extends y implements y1
D、class x
10、 [ 单选题 ]
在java中，对于try和catch子句的排列方式，下面哪一项是正确的：
（ A ）
A、子类异常在前，父类异常在后
B、父类异常在前，子类异常在后
C、父类异常和子类异常不区分顺序
D、父类异常和子类异常不能出现在同一个try程序段内
11、 [ 单选题 ]
以下关于迭代器Iterator描述正确的是:
（ D ）
A、Iterator 可以对所有实现了Collection接口的集合实现类,进行双向迭代
B、通过迭代器，可以遍历集合中的元素，可以对元素进行读取和添加
C、全部正确
D、迭代器的设计初衷是替代 Java Collections Framework 中的 Enumeration
解析：
https://www.cnblogs.com/zyuze/p/7726582.html
12、 [ 单选题 ]
关于集合框架描述错误的是 （ D ）
A、List和Set具有相同的父接口
B、List中的元素可以重复，而Set不可以重复
C、影响HashMap性能的因素在于其初始容量和加载因子，因此，HashMap中元素永远不会灌满Hash桶
D、在软件实务中，应该为HashMap提供尽可能小的初始容量，当容量不足时候，使其自动扩容，以节约内存开销
13、 [ 单选题 ]
以下关于HashMap的描述正确的是 （ B ）
A、HashMap是映射的实现方式之一，每个键/值对都是由其内部的动态数组进行直接存储
B、对于所有的键值对，可以直接导出形成Set集合
C、HashMap读取的最快方式是应用迭代接口进行读取
D、HashMap中的每个映射，都必须以键值对的方式进行整体Entry操作，不可以独立获取其key或是value
14、 [ 单选题 ]
对于以下程序，描述正确的是
public static void main(String[] args) {
List<int> data=new ArrayList<>();
data.add(1);
data.add(2);
data.add(3);
ListIterator<int> li=data.listIterator(1);
while(li.hasPrevious()){
System.out.println(li.previous());
}
} （ D ）
A、输出结果是1
B、输出结果是2和1
C、无输出结果
D、存在编译错误
15、 [ 单选题 ]
以下关于字符串截取，描述错误的是 （ B ）
A、Java中的字符串截取方法进行了重载。
B、Java中的字符串截取方法，可以从指定索引开始一直截取到最后一个字符。当指定索引不存在时候，返回空字符串。
C、对于字符串截取方法，subString(int beginIndex,int endIndex)返回值包含开始位置的字符,但不包含结束位置的字符。
D、对于区间字符串截取,java是从某一索引开始,到某一索引结束;而Oracle中则是从某一索引开始截取指定长度。
16、 [ 单选题 ]
对于字符串实现类,描述正确的是 （ D ）
A、String 是定长字符串，一经定义长度不可以变，一旦长度发生变化，会产生新的字符串对象，但进行局部替换时候不会产生新字符串对象。
B、从Java1.5开始，新增了StringBuffer对象，用以处理动态字符串
C、String word=new String(“hello neusoft”)时候,内存中产生的字符串个数是一个。
D、对于动态字符串,如果需要保证其线程安全性,需要使用StringBuffer,如果在不涉及线程安全的环境中,建议使用StringBuilder,因为其性能更好。
17、 [ 单选题 ]
以下描述错误的是 （ B ）
A、java中对于数据的输入输出是通过流实现的
B、java中的流分为输入流和输出流，输入流用以向文件中写入数据
C、对于I/O流Java提供了两种实现手段，分别是字节流和字符流，但在底层，一切I/O都是基于字节流实现的
D、缓冲流的意图在于通过空间消耗，换取时间上的效率
18、 [ 单选题 ]
在FileOutputStream类的构造方法中，下面哪个类是合法 （ A ）
A、File
B、InputStream
C、OutputStream
D、FileOutputStream
19、 [ 单选题 ]
File类型中定义了方法（ ）来判断一个文件是否存在 （ D ）
A、createNewFile
B、contains
C、delete
D、exists
20、 [ 单选题 ]
在Java中,JDBC API定义了一组用于与数据库进行通信的接口和类，它们包括在( )包中 （ B ）
A、java.lang
B、java.sql
C、java.util
D、java.math
21、 [ 单选题 ]
初始化基本ResutlSet对象rst，获取rst的第一行数据，以下正确的是
（ B ）
A、rst.hashNext()
B、rst.next()
C、rst.first()
D、rst.nextRow()
22、 [ 单选题 ]
Java编程中有关数据库的事务（JDBC）的叙述正确的是？（）
（ B ）
A、事务是通过 Statement对象控制的，默认每条语句一个事务
B、事务是通过 Connection对象控制的,调用conn.setAutoCommit(false)禁止自动提交
C、事务是通过 ResultSet对象控制的，当关闭 ResultSet对象时自动提交
D、Java中的事务不可以设置事务的隔离级别
23、 [ 单选题 ]
关于equals()与==描述正确的是 （ A ）
A、如果一个类没有重写equals方法，那么equals可以用来比较两个变量引用的内存对象是否相同
B、在String类中，equals()与==作用是相同的
C、在一个方法中，如果定义了如下语法：
String str1=”abcd”;
String str2=”abcd”;
此时，equals()返回true，而==返回false
D、在内存对象是否相同的判断上，是不可以应用equals()的
24、 [ 单选题 ]
在Java语言中，以下关于hashCode的描述正确的是
（ C ）
A、如果两个对象的hashCode相同，那么一定是同一个内存对象
B、即使两个对象的hashCode不同，也有可能是同一个内存对象
C、即使两个对象不同，也完全有可能存在相同的hashCode
D、即使是同一个内存对象，得到的hashCode也可能不同
25、 [ 单选题 ]
以下关于java日期格式组合正确的是 （ C ）
A、yyyy-MM-dd ：hh24：mi：ss
B、YYYY-MM-DD
C、yyyy-MM-dd HH：mm：ss
D、YYYY-MM-DD HH24：MI:SS
26、 [ 多选题 ]
下列哪两个语句能够创建一个InputStream输入流并且打开文件“file.txt”准备读取 （ BE ）
A、InputStream in＝new FileReader(“file.txt”)；
B、InputStream in＝new FileInputStream(“file.txt”)；
C、InputStream in＝new InputStreamFileReader (“file.txt”, “read”)；
D、FileInputStream in＝new FileReader(new File(“file.txt”))；
E、FileInputStream in＝new FileInputStream(new File(“file.txt”))；
27、 [ 多选题 ]
Java程序代码如下：
List a = new ArrayList();
a.add(“Alpha”);
a.add(“Bravo”):
a.add(“Charlie”);
a.add(“Delta”);
Iterator iter = a.iterator();
______________________
下列哪两组的两行代码添加在虚线处，可按字典顺序打印输出ArrayList集合中的全部元素
（ AC ）
A、for (int i＝0；i<a.size()； i++) System.out.println(a.get(i)))；
B、for (int i＝0； i ＜ a.size()； i++) System.out.println(a[i])；
C、while( iter.hasNext() ) System.out.println(iter.next()) ；
D、for (int i＝0, i ＜ a.size()； i++) System.out.println(iter[i])；
E、for (int i＝0； i ＜ a.size()； i++) System.out.println(iter.get(i))；
28、 [ 多选题 ]
以下哪些是接口
（ AC ）
A、List
B、ArrayList
C、Set
D、HashMap
29、 [ 多选题 ]
Java中的集合类包括ArrayList、LinkedList、HashMap等，下列关于集合类描述正确的是
（ ABD ）
A、ArrayList和LinkedList均实现了List接口
B、ArrayList的查询速度比LinkedList快
C、添加和删除元素时，ArrayList的表现更佳
D、HashMap实现了Map接口，它允许任何类型的键和值对象，并允许将 null 用作键或值
30、 [ 多选题 ]
以下哪个方法可得到结果内容是"Java"的字符串
（ AC ）
A、"helloJava".substring(5)
B、"pringJava".substring(6)
C、"ThinkinJava4th".substring(7,11)
32、 [ 单选题 ]
在java代码中，一个变量声明为boolean aa;下面赋值语句中正确的是：
（ A ）
A、aa=false;
B、aa=False;
C、aa="true";
D、aa=0;
33、 [ 单选题 ]
已经定义数组：int[] m=new int[4], 当使用语句m[10]=10; 时可以捕获的异常类型是：
（ A ）
A、java.lang.Exception
B、java.lang.NullPointerException
C、java.io.IOException
D、java.sql.SQLException
34、 [ 单选题 ]
在java中，下面关于abstract描述正确的是：
（ B ）
A、可以用来声明变量、方法
B、可以用来声明方法和类，如果方法是abstract的，那么类必须也是abstract的
C、abstract的method可以是static的
40、 [ 单选题 ]
以下程序执行结果是什么
public static void main(String[] args){
String str１="str";
String str２=new String("str");
System.out.print(str1.equals(str2));
System.out.print(＂,＂);
System.out.print(str1==str2);
}
（ B ）
A、false，false
B、ture，false
C、true，true
D、false，true
41、 [ 单选题 ]
以下Java程序输出结果是什么
public static void main(String[] args) {
Set set = new HashSet();
set.add("key1");
set.add("key1");
set.add("key3");
Map map = new HashMap();
map.put("key1", "key1");
map.put("key1", "key2");
map.put("key3", "key3");
System.out.println(set.size() + "_" + map.size());
}
（ B ）
A、3_3
B、2_2
C、2_3
D、3_2
42、 [ 单选题 ]
下列语句会中创建几个对象？
String s1 ="hello world"
String s2 ="hello world"
（ D ）
A、0个
B、1个
C、2个
D、3个
43、 [ 单选题 ]
要删除book表中书籍(bookName)是"Java"的记录，哪个选项放在如下Java代码的空行处，可使代码正确执行。
String sql＝”delete from book where bookName＝?”；
PreparedStatement pst＝con.preparedStatement(sql)；
______________________________
pst.execute()；
（ A ）
A、pst.setString(1,”Java”)
B、pst.setString(0,”Java”)
C、pst.setInt(0,”Java”)
D、以上选项都不正确
44、 [ 单选题 ]
应用程序的main方法中有以下语句，则输出的结果是
String s1 = "0.5";
String s2 = "12";
double x = Double.parseDouble(s1);
System.out.println(s2+x );
（ B ）
A、12.5
B、120.5
C、12
D、“12.5”
45、 [ 单选题 ]
看如下代码,其中list是一个ArrayList类型的对象，哪个选项的代码填写到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？( )
Iterator it = list.iterator();
int index = 0;
while (it.hasNext()){
Object obj = it.next();
if (needDelete(obj)) { //needDelete返回boolean，决定是否要删除
//todo delete
}
index ++;
} （ D ）
A、list.remove(obj)；
B、list.remove(index)；
C、list.remove(it.next())；
D、it.remove()；
46、 [ 单选题 ]
对于以下语句Integer val=null;以下哪个语句会引发空指针异常 （ D ）
A、String str1=val+”ABC”
B、int width=String.valueOf(val).length();
C、"null".equals(val);
D、int a=val+200;
47、 [ 单选题 ]
代码如下：String str=”A^B^C^D”;以下代码需要将其转换成数组，正确的是 （ B ）
A、String val[]=str.split("//^");
B、String val[]=str.split("\\^");
C、String val[]=str.split("\^");
D、String val[]=str.split("^");
48、 [ 单选题 ]
对于程序:
public static void main(String[] args)
{
List<String> e=new ArrayList<>();
____________________ //插入位置
System.out.println(e);
}
如下哪行代码放入目标位置会产生异常: （ D ）
A、e.add(2，“OK”)
B、e.set(0，“OK”)
C、e.remove(0)
D、以上都会
49、 [ 单选题 ]
以下关于HashMap方法描述错误的是 （ B ）
A、clear（）方法只是清除了所有的映射，内存对象实际上依然存在
B、remove(Object k)方法删除的key如果不存在，会引发异常,因此一般在调用该方法之前，需要先调用containsKey(Object k)方法，判断key是否存在
C、当isEmpty( )返回true的时候，size（）方法的返回值是0
D、HashMap中的key是不可以重复的，但是可以用null做key
53、 [ 单选题 ]
以下关于线程的说法中错误的一项是 （ D ）
A、一个线程是一个Thread类的实例
B、Java中主线程的是最先开始,最后结束的
C、线程是进程的子集，一个进程可以有很多线程，每条线程用以执行不同的任务
D、当一个进程包含多个线程时候,每个线程的内存空间都是独立的
55、 [ 多选题 ]
以下哪些方法是属于Thread类的 （ ABC ）
A、getId（）
B、destory（）
C、sleep（）
D、exist（）
59、 [ 多选题 ]
在Java中，下列关于类的定义的选项中，哪些可以通过new Thing()方法来创建该类的一个对象：
（ AD ）
A、public class Thing { public Thing() {}}
B、public class Thing { public Thing(void) {} }
C、public class Thing { public Thing(String s) {} } }
D、public class Thing { public void Thing(String s) {} }
60、 [ 单选题 ]
下列类定义中，不正确的是： （ D ）
A、class x
B、class x extends y
C、class x implements y1,y2
D、public class x extends X1,X2
61、 [ 单选题 ]
下列叙述正确的是：
（ C ）
A、Java中类允许多重继承
B、Java一个类只能实现一个接口
C、Java中类只能单重继承
D、Java中一个类可以继承多个抽象类
62、 [ 单选题 ]
在Java中，关于类的说法，正确的是：
（ C ）
A、编写代码时，声明的类可以不继承任何类
B、编写代码时，声明的类可以继承自多个类
C、编写代码时，声明的类一定继承自一个类
D、编写代码时，声明的类可能继承自一个类可能继承自多个类，但不能不继承某个类
63、 [ 单选题 ]
下列那些说法是正确的是： （ C ）
A、final修饰是为了与abstract修饰符对应，没有final的类，应该是abstract。
B、final的类不能创建对象。
C、final类可以创建对象。
D、final类不可以有父类。
64、 [ 单选题 ]
定义一个接口时，下列哪个关键字用不到： （ D ）
A、public
B、extends
C、interface
D、class
65、 [ 单选题 ]
下列关于访问器方法说法正确的是： （ A ）
A、get方法可以读取属性的值
B、set方法用来读取属性的值
C、必须为每个private属性提供访问器方法
D、public属性不能有访问器方法
66、 [ 单选题 ]
抛出异常时使用下列哪个关键字：
（ A ）
A、throw
B、catch
C、try
D、throws
E、finally
68、 [ 单选题 ]
某个类中存在一个方法：void getSort(int x)，以下能作为该方法的重载的声明的是： （ B ）
A、public getSort(float x)
B、double getSort(int x,int y)
C、int getSort(int y)
D、void get(int x,int y)
69、 [ 单选题 ]
创建二维数组a[3][4]后，a[0].length的值应该等于： （ D ）
A、0
B、2
C、3
D、4
70、 [ 单选题 ]
在switch(expression)语句中，expression的数据类型不能是： （ C ）
A、byte
B、char
C、float
D、short
71、 [ 单选题 ]
设 int x = 1 ;int y = 2 ;int z = 3;则表达式 y＋＝z－－/＋＋x中y的值是：
（ A ）
A、3
B、3.5
C、4
D、5
72、 [ 单选题 ]
下面的Java语句错误的是：
（ C ）
A、byte a=2;
B、double a=1.0;
C、float a=1.0
D、double a=1;
73、 [ 单选题 ]
下列有关Eclipse的说法错误的是：
（ B ）
A、Eclipse是集成开发环境，当Java文件保存时，Eclipse会自动编译生成.class文件。
B、Eclipse是集成开发环境，在Eclipse中更改文件代码后，Eclipse会自动保存该文件。
C、Eclipse是集成开发环境，但是没有Eclipse，记事本也可以开发Java代码。
D、Eclipse是集成开发环境，必须要先安装java开发环境，才能开发Java程序。
第二部分：填空题
1、 [ 填空题 ]
写出代码运行结果______ Caught e _________
public class ExceptionDemo {
public static void mySqrt(int a) throws Exception {
if (a < 0)
throw new Exception();
}
public static void main(String args[]) {
try {
mySqrt(25);
mySqrt(-5);
} catch (Exception e) {
System.out.print("Caught e");
}
}
}
2、 [ 填空题 ]
写出代码运行结果______1977-8-16_________
class ParentConstructor {
public int year;
public int month;
public int day;
public static final int default_month = 2;
public static final int default_day = 16;
public ParentConstructor(int y, int m, int d) {
year = y;
month = m;
day = d;
}
public ParentConstructor(int y) {
this(y, default_month, default_day);
}
public ParentConstructor(int y1977, int m8) {
this(y, m, default_day16);
}
}
public class ChildConstructor extends ParentConstructor {
public ChildConstructor(int h) {
super(1977, 8);
}
public static void main(String[] args) {
ChildConstructor t = new ChildConstructor(12);
System.out.println(t.year + "-" + t.month + "-" + t.day);
}
}
3、 [ 填空题 ]
写出代码运行结果______ ABDCBDCB _________
public class Delta {
static boolean foo(char c) {
System.out.print(c);
return true;
}
public static void main(String[] argv) {
int i = 0;
for (foo('A'); foo('B') && (i < 2); foo('C')) { // abdcbdcb
i++;2
foo('D');
}
}
}
4、 [ 填空题 ]
写出代码运行结果_______ a=7,b=18
public static void main(String args[]) {
int a = 6, b;
b = a++ * 3;
System.out.print("a=" + a + ",b=" + b);
}
5、 [ 填空题 ]
写出代码运行结果______ sum=30_________
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 10; i++) {
if (5 % 2 != 0)
continue;
else
sum += i;
}
System.out.println("sum=" + sum);
}
6、 [ 填空题 ]
执行以下程序
public static void main(String[] args){
String str１="str";
String str２=new String("str");
System.out.print(str1.equals(str2));
System.out.print(＂,＂);
System.out.print(str1==str2);
}
结果是_________ ture，false__________________
7、 [ 填空题 ]
要删除book表中书籍，列名为bookName，值是"Java"的记录，补全Java代码的空行处，可使代码正确执行。
String sql＝”delete from book where bookName＝?”；
PreparedStatement pst＝con.prepareStatement(sql)；
________ pst.setString(1,"Java");或者_ pst.setString("bookName","Java")_____________________;
pst.execute()；
8、 [ 填空题 ]
在java中byte类型的取值范围是___-128 到 127___
9、 [ 填空题 ]
在java代码段中，有一个方法被调用代码为double[] arrs = sort(""),该方法的声明代码为________ public double[] sort(String arr)___________(如果调用代码错误，无法写出方法声明，请在横线处填入“代码错误”)
10、 [ 填空题 ]
二维数组初始化为Student[][] a = new Student[4][2],a.length的值为____4_______(如果数组初始化代码错误，请在横线处填入“代码错误”)
11、 [ 填空题 ]
写出代码运行结果_______ y=0________
public static void main(String args[]) {
int x=2;
int y = x++/3;
System.out.println("y="+y);
}
12、 [ 填空题 ]
写出代码运行结果______ 0 2 4_________
public static void main(String args[]) {
int i = 0;
for ( int i=0;; i < 4; i += 2) {
System.out.print(i + "");
}
System.out.println(i);
}
13、 [ 填空题 ]
写出代码运行结果______23_________
public class ScopeTest {
public int i = 1;15
public void firstMethod() {
int i = 7, j = 8;
this.i = i + j;
secondMethod(this.i);
}
public void secondMethod(int i) {
int j = 8;
this.i = i + j;
}
public static void main(String[] args) {
ScopeTest obj = new ScopeTest();
obj.firstMethod();
System.out.println(obj.i);
}
}
14、 [ 填空题 ]
写出代码运行结果_______30 10 20________
class A1 {
int i, j;30 40
void setA(int i, int j) {
this.i = i;
this.j = j;
}
}
class B1 extends A1 {
int j, k;10 20
void setB(int j, int k) {
this.j = j;
this.k = k;
}
}
public class TestAB {
public static void main(String[] args) {
B1 sub = new B1();
sub.setB(10, 20);
sub.setA(30, 40);
System.out.println(sub.i + " " + sub.j + " " + sub.k);
}
}
15、 [ 填空题 ]
写出代码运行结果______ ACD _________
public static void main(String[] args) {
try {
badMethod();
System.out.print("A");
} catch (Exception ex) {
System.out.print("B");
} finally {
System.out.print("C");
}
System.out.print("D");
}
public static void badMethod() {
}
16、 [ 填空题 ]
在java中，使用代码定义如下：
public class Test {
private static final int a;
public static void main(String[] args) {
a = 20;
}
}
请判断代码是否正确，如果错误，请指出问题 __ a不能使用final修饰，去掉final_______（如果正确，请在横线处填入 正确，如果错误，请在横线处填入 如何解决）
17、 [ 填空题 ]
在java中，计算字符串长度的语法是_ length() 方法、__,计算数组长度的语法是_ length属性_,计算List长度方法是___ size()方法____
18、 [ 填空题 ]
java.lang.String是否可以再有子类____不可以_____,为什么____因为String是final类______
19、 [ 填空题 ]
Java中存在如下语句Double val=null;此时执行如下语句产生的情况分别是:
String.valueOf(val)：______返回字符串null ________
val.toString()： ______引发空指针异常___
20、 [ 填空题 ]
String str=new String(“helolo”),此时内存中字符串对象个数是_____2_______个
21、 [ 填空题 ]
Java中所有类都是类__ Object ____的子类。
22、 [ 填空题 ]
任何一个Java程序都默认引入了一个包，这个包的名字叫java. __ lang ___。
23、 [ 填空题 ]
在java中short类型的取值范围是____-32768 到 32767___
27、 [ 填空题 ]
写出代码运行结果__1,2,5,10___
public static void main(String[] args) {
int n = 10;
for (int i = 1; i <= n; i++) {
if (n % i != 0)
continue;
System.out.print(i + ",");
}
}
28、 [ 填空题 ]
写出代码运行结果___ i=10,j=40____
public class Pass {
static int j = 20;
public static void main(String argv[]) {
int i = 10;
Pass p = new Pass();
p.amethod(i);
System.out.println("i="+i+",j="+j);
}
public void amethod(int[] x) {
x = x * 2;20
j = j * 2;40
}
}
29、 [ 填空题 ]
写出代码运行结果____ parent child child_____
class Parent {
void printMe() {
System.out.println("parent");
}
}
class Child extends Parent {
void printMe() {
System.out.println("child");
}
void printAll() {
super.printMe();
this.printMe();
printMe();
}
}
public class T {
public static void main(String args[]) {
Child myC = new Child();
myC.printAll();
}
}
31、 [ 填空题 ]
在java中，使用代码定义如下：
public class Test {
private static final int[] a = {10};
public static void main(String[] args) {
a[0] = 20;
}
}
请判断代码是否正确，如果错误，请指出问题 _____正确____（如果正确，请在横线处填入 正确，如果错误，请在横线处填入 如何解决）
41、 [ 填空题 ]
Java中最顶层的类是__ Object_
42、 [ 填空题 ]
程序中实现多线程的方法有两种：继承___Thread__类和实现Runnable接口
第三部分：问答题
1、 [ 问答题 ]
在Java中，数据类型有哪些，作为属性默认值是什么？作为数组元素的初始值是什么？
1、整数类型（byte、short、int、long）的基本类型变量的默认值为0。
2、单精度浮点型（float）的基本类型变量的默认值为0.0f。
3、双精度浮点型（double）的基本类型变量的默认值为0.0d。
4、字符型（char）的基本类型变量的默认为 “\u0000”。
5、布尔性的基本类型变量的默认值为 false。
6、引用类型的变量是默认值为 null。
2、 [ 问答题 ]
int和Integer有什么区别
int是Java的原始数据类型，也叫基本数据类型。
Integer是Java中为int提供的包装类，它是类而不是基本数据类型,它的内部其实包含一个int型的数据。
装箱和拆箱
3、 [ 问答题 ]
请简述使用JDBC调用数据库的步骤.
1.载入JDBC驱动程序
2.定义连接URL
3.建立连接
4.创建Statement对象
5.执行查询或更新
6.结果处理
7.关闭连接
4、 [ 问答题 ]
在Java中，中断循环的关键字有什么，简述作用
提前中断循环，需要在循环语句块中添加break或continue语句。
break语句用于终止某个语句块的执行。用在循环语句体中，可以强行退出循环。
continue语句用在循环语句体中，用于终止某次循环过程，跳过循环体中continue语句下未执行的循环，开始下一次循环过程。
5、 [ 问答题 ]
在Java中，进行方法调用需要注意哪些问题
形参必须注明数据类型
实参直接写，不需要类型声明
return只能返回一次
遇到return语句，方法结束执行，后续语句不执行
方法的返回值，必须与方法声明中的返回值类型匹配
方法定义，不能写在main()中
方法是不能嵌套的
6、 [ 问答题 ]
在Java中，构造器的特征和作用
1、构造器（构造方法/构造器，Constructor）特征：
具有与类相同的名称
不含返回值类型
不能在方法中用return语句返回一个值
一般访问权限为public
在一个类中，具有上述特征的方法就是构造器。
2、构造器的作用
完成对象的创建，即完成对象的实例化
一般使用构造器来完成对成员变量的初始化
7、 [ 问答题 ]
在Java中，简述垃圾回收机制原理
Java的垃圾回收机制是自动的，实际上是JVM内部运行的一个优先级比较低的后台线程。
垃圾回收机制仅仅作用于堆内存，与栈内存无关。
确定对象为垃圾需要回收的条件如下：
对象的引用被赋值为null
一次性使用的匿名对象
超出生命周期
8、 [ 问答题 ]
在Java中，简述this关键字概念及使用this关键字的情况
this关键字：
代表对象自身的引用，通常在类的方法定义中使用
用this关键字的情况：
方法中的变量与成员变量重名
在一个构造器中，调用其它重载的构造器
返回当前对象的引用
9、 [ 问答题 ]
说明Java中继承的含义和规则，简写类继承的语法
继承的含义：
子类继承父类的所有属性和方法，同时也可以增加自己的属性和方法。
继承的规则：
Java中只能单继承，也就是说每个类只能有一个直接父类；一个父类可以有多个子类。
继承语法：
class 子类名 extends 父类名
10、 [ 问答题 ]
单例的作用是什么，使用Java编写一个单例的程序
单例模式（singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点
11、 [ 问答题 ]
在Java中，详细说明什么是多态，多态存在的条件，多态执行的效果是什么。
多态（动态绑定、Polymorphism )：
不同的对象对同一行为作出的不同响应
多态存在的三个必要条件：
要有继承，或实现
要有重写
父类引用指向子类对象
多态执行的效果：
当调用父类中被重写的方法后，运行时创建的是哪个子类的对象，就调用该子类中重写的那个方法
12、 [ 问答题 ]
在Java中，讲述子类实例化的过程中，子类创建构造器要求有什么？
在子类中创建构造器时，必须调用父类的构造器
子类可以在自己的构造器中使用super关键字来调用父类的构造器，代码如下：
super (参数1，参数2，…);
如果使用super关键字调用父类构造器，必须写在该子类构造器的第一行
如调用的是父类中无参的构造器，则可以不写super( )
如果子类中调用了父类无参的构造器，而父类中没有无参构造器则系统编译出错
15、 [ 问答题 ]
描述Set、List、Map三个接口，在保存元素时，各有什么特点
Set、List中只能存储单列元素。--1分
Map存储键值对。--1分
Set保存元素时，不允许重复、无序。--1分
List保存元素时，允许重复、有序。--1分
Map保存元素时，不允许键重复。--1分
16、 [ 问答题 ]
Collection 和 Collections的区别
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口
18、 [ 问答题 ]
请详细描述＂==＂和equals方法的区别
equals()方法是Object类的方法，在Object类中比较两个对象引用是否指向同一个对象，一般都被子类方法覆盖，不再比较引用的值 --2分
"=="是比较运算符:，当比较基本数据类型时，比较两个数据值是否相等；当比较引用数据类型时，比较两个引用是否指向同一个对象。--2分
19、 [ 问答题 ]
String类与StringBuilder类的比较，StringBuffer与StringBuilder的比较。
1、String类与StringBuilder类的比较
1.1) String类与StringBuilder类相同点：
1.1.1) String与StringBuffer两个类都完成对字符串的各种操作；
1.1.2) String类与StringBuffer类都被放到了java.lang包中
1.2) String类与StringBuilder类两者的主要区别在于：
1.2.1） String类对象中的内容初始化不可以改变
1.2.2）StringBuffer类对象中的内容可以改变
2、StringBuffer与StringBuilder的比较
2.1） StringBuffer与StringBuilder的相同点
2.1.1） StringBuffer和StringBuilder都是长度可变的字符串。
2.1.2） 两者的操作基本相同。
2.2） 两者的主要区别在于
2.2.1）StringBuffer类是线程安全的；
2.2.2）StringBuilder类是线程不安全的。
2.2.3）StringBuffer在JDK1.0中就有，而StringBuilder是在JDK5.0后才出现的。
2.2.4）StringBuilder的一些方法实现要比StringBuffer快些。
20、 [ 问答题 ]
在Java中，如何实现方法重载，重载规则是什么
方法的重载（overload）：方法的重载就是在同一个类中允许同时存在一个以上同名的方法
方法重载的规则：
方法名称相同
方法的参数必须不同
参数个数不同 或
参数类型不同
方法的返回值类型可以相同，也可以不同
22、 [ 问答题 ]
在Java中，类变量、局部变量、实例变量定义有什么不同，作用域都是什么
类变量：
用static修饰的成员变量，它们在类被载入时创建，只要类存在，static变量就存在
实例变量：
类体中声明的成员变量，即非static的属性，创建对象后存在
局部变量：
方法体中声明的变量，方法中的参数，或代码块中声明的变量，都是局部变量。局部变量只在方法调用的过程中有效，方法调用结束后失效
23、 [ 问答题 ]
在Java中，说明权限修饰符有哪些，及作用，并说明每个权限含义
权限修饰符作用：
用来控制类的成员和类的使用范围
权限修饰符有：
类成员的访问权限修饰符：private、default、protected、public
类的访问权限修饰符：public、default
权限含义：
24、 [ 问答题 ]
在Java中，static关键字可以修饰的元素有哪些？说明静态变量（类变量）的特点和访问形式，说明静态方法（类方法）的特点、访问形式、作用和使用的注意事项，什么是静态代码块，静态代码块中的代码什么时候执行，静态代码块作用
static可以修饰的元素：
属性、方法、代码块
1）静态变量特点：
所有对象共享
在类被载入时创建，只要类存在，static变量就存在
两种方式访问：
直接访问：类名.属性；
实例化后访问：对象名.属性
2）静态方法特点：
不需要实例化，可以直接访问
两种方式访问：
直接访问：类名.方法名()
实例化后访问：对象名.方法名()
static方法的作用：
简化方法的使用；
便于访问静态属性；
注意事项
静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员
静态方法中不能使用this、super关键字
静态方法不能被非静态方法覆盖，静态方法不能修饰构造器
3）静态代码块： 一个类中由static关键字修饰的，不包含在任何方法体中的代码块
当类被载入时，静态代码块被执行，且只被执行一次
静态块经常用来进行类属性的初始化
32、 [ 问答题 ]
Java中有几种类型的流，JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
从传输单位的不同分为：字节流，字符流 --1分
从传输方向的不同分为：输入流 输出流 ----1分
对应的提供的API类包括：FileInputStream FileOutputStream FileReader FileWriter DataInputStream DataOutputStream 等等 --2分
33、 [ 问答题 ]
请描述ArrayList和LinkedList的区别
Arraylist采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦
。 --2分
Linkedlist采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要从第一个索引开始
35、 [ 问答题 ]
描述HashMap和HashTable的区别
两者都属于Map接口的实现类，都实现了键值对映射。
区别在于：
HashMap 允许一个 null 键和多个 null 值，HashTable 不允许 null 键和 null 值。 --2分
由于HashTable诸多方法是线程同步的，因此性能上要比HashMap差 。--2分
37、 [ 问答题 ]
描述如何创建和启动多线程。
第一种方法：继承Thread类，重写run()方法。
第二种方法：实现Runnable接口，实现run()方法。
启动：
调用start()方法来启动线程
38、 [ 问答题 ]
下列程序是否正确，如果正确输出结果是：
class Parent {
public String getInfo() {
return "Parent getInfo invoked";
}
}
class Child extends Parent {
public String getInfo() {
return "Child getInfo invoked";
}
}
public class VirtualMethod {
public static void main(String[] args) {
Parent p = new Child();
System.out.println(p.getInfo());
}
}
Child getInfo invoked
39、 [ 问答题 ]
下列程序是否正确，如果正确输出结果是：
public class OverridingChild extends OverridingParent {
public void method(int a) {
System.out.println("Invocation child class");
}
public static void main(String[] args) {
OverridingChild t = new OverridingChild();
t.method();
}
}
class OverridingParent {
public void method() {
System.out.println("Invocation parent class");
}
}
Invocation parent class
41、 [ 问答题 ]
下列程序是否正确，如果正确输出结果是：
public class Cruncher {
void crunch(int i) {
System.out.print("int");
}
void crunch(String s) {
System.out.print("String");
}
public static void main(String args[]) {
Cruncher crun = new Cruncher();
char ch = 'p';
int c = 12;
crun.crunch(ch);
System.out.print(";");
crun.crunch(c);
}
}
int;int
47、 [ 问答题 ]
请描述线程都包含哪些状态（包含不同的阻塞状态），并说明状态之间如何转换。
主要状态包括：新建、就绪、运行、阻塞、死亡状态。 --2分
其中阻塞状态又可分为：等待阻塞、同步阻塞、其他阻塞状态。 --1分
各状态之间切换如下：
1.新建状态(New)：用new语句创建的线程对象处于新建状态 --1分
2.就绪状态(Runnable)：当一个线程对象被创建后,其他线程调用它的start()方法后,该线程就进入就绪状态，Java虚拟机会为它创建方法调用栈和程序计数器,处于这个状态的线程位于可运行池中,等待获得CPU 的使用权。 --1分
3.运行状态(Running)：当处于就绪状态的线程对象获得CPU 的使用权之后,该线程就进入运行状态,处于这个状态的线程对象占用CPU,执行线程体程序代码。在并发运行环境中,如果计算机中有只有一个CPU,那么任何时刻只会有一个线程对象处于这个状态。如果计算机有多个CPU,那么同一时刻可以让几个线程对象占用不同的CPU,使它们处于运行状态。只有处于就绪状态的线程才有机会转到运行状态。--1分
4.阻塞状态(Blocked)：阻塞状态是指线程因某些原因放弃CPU,暂时停止运行。当线程处于阻塞状态时,Java虚拟机不会给线程分配CPU,直到线程重新进入就绪状态,它才有机会转到运行状态。
阻塞状态可分为以下3种,分别是:
等待阻塞状态:也叫位于对象等待池中的阻塞状态(BlockedinObject’swaitpool),当正在运行的线程执行某个对象的wait()方法时,Java虚拟机就会把该线程放到这个对象的等待池中。 --1分
同步阻塞状态:也叫位于对象锁池中的等待状态(BlockedinObject’slockpool),当正在运行的线程试图获得某个对象的同步锁时,如果该对象的同步锁已经被其他线程占用,Java虚拟机就会把这个线程放到这个对象的锁池中。 --1分
其他阻塞状态:当正在运行的线程执行了sleep()方法,或者调用了其他线程的join()方法,或者发出了I/O 请求时,就会进入这个状态。当sleep()方法超时、join()等待线程终止或者超时、或者I/O 处理完毕时,线程重新转入就绪状态。 --1分
5.死亡状态(Dead)：当线程结束run()方法的执行时,就进入死亡状态,该线程结束生命周期。线程有可能是正常执行完run()方法退出,也有可能是遇到异常而退出,不管线程正常结束还是异常结束,都不会对其他线程造成影响。--1分
第四部分：组合题
1、 [ 组合题 ]
解决图形问题，根据如下要求，编写程序：
1） [ 问答题 ]
设计Shape表示图形类，有面积属性area、周长属性per，颜色属性color，有两个构造方法（一个是默认的、一个是为颜色赋值的），还有3个抽象方法，分别是：getArea计算面积、getPer计算周长、showAll输出所有信息。
1） 【问答题】 答案：
public abstract class Shape { -- 抽象类
double area;
double per;
char color;
Shape(){
}
Shape(char color){
this.color = color;
}
public abstract double getArea();
public abstract double getPer();
public abstract void showAll();
}
2） [ 问答题 ]
为Shape图形类设计2个子类：
Rectangle表示矩形类，增加2个属性，width表示长度、height表示宽度，重写getPer、getArea和showAll三个方法，另外又增加一个构造方法（一个是默认的、一个是为高度、宽度、颜色赋值的）。
Circle表示圆类，增加1个属性，radius表示半径，重写getPer、getArea和showAll三个方法，另外又增加两个构造方法（为半径、颜色赋值的）。
设计2个子类：
Rectangle表示矩形类，增加两个属性，width表示长度、height表示宽度，重写getPer、getArea和showAll三个方法，另外又增加一个构造方法（一个是默认的、一个是为高度、宽度、颜色赋值的）。
参考答案：
public class Rectangle extends Shape { --继承
double width;
double height;
Rectangle(){
}
Rectangle(double width, double height,char color){
super(color);
this.width = width;
this.height = height;
}
public double getArea() {
area = width*height;
return area;
}
public double getPer() {
per = 2*(width+height);
return per;
}
public void showAll() {
System.out.println("长："+width);
System.out.println("宽："+height);
System.out.println("面积:"+getArea());
System.out.println("周长:"+getPer());
System.out.println("颜色:"+getColor());
}
}
Circle表示圆类，增加1个属性，radius表示半径，重写getPer、getArea和showAll三个方法，另外又增加两个构造方法（为半径、颜色赋值的）。
public class Circle extends Shape {
final double pi = 3.14;
double radius;
Circle(){
}
Circle(double radius,char color){
super(color);
this.radius = radius;
}
public double getArea() {
area = pi*radius*radius;
return area;
}
public double getPer() {
per = 2*pi*radius;
return per;
}
public void showAll() {
System.out.println("半径："+radius);
System.out.println("面积:"+getArea());
System.out.println("周长:"+getPer());
System.out.println("颜色:"+getColor());
}
}
3） [ 问答题 ]
编写测试类，在main方法中，创建一个长度为2的Shape数组shapes，创建一个颜色为蓝色，边长为1和2的Rectangle对象为数组的第一个元素，创建一个颜色为红色，半径为1.2的Circle对象为数组的第二个元素，使用for..each方式遍历该数组，调用每个元素的showAll方法得到图形的资料。
public class PolyDemo {
public static void main(String[] args) {
Shape[] shapes = new Shape[2];
shapes[0] = new Rectangle(1,2,'蓝');
shapes[1] = new Circle(1.2,'红');
for(Shape s : shapes){
s.showAll();
}
}
}
2、 [ 组合题 ]
根据如下要求，编写程序：
1） [ 问答题 ]
（1）创建一个抽象员工类ColaEmployee，包含如下属性和方法 属性：员工的姓名(字符串类型)；员工的生日月份(整型) 抽象方法：getSalary(int month)。
public abstract class ColaEmployee { String name; int month; ColaEmployee() { } ColaEmployee(String name, int month) { this.name = name; this.month = month; } abstract double getSalary(int month); }
2） [ 问答题 ]
（2）创建ColaEmployee的三个子类SalariedEmployee (拿固定工资的员工)、HourlyEmployee（拿小时工资的员工）、SalesEmployee（按月销售额和提成率拿工资的员工），并在各类中分别覆盖父类的抽象方法getSalary()，其中每个类中的方法实现说明如下： SalariedEmployee类：拿固定工资的员工。参数：固定工资 HourlyEmployee：按小时拿工资的员工，每月工作超出160 小时的部分按照1.5 倍工资发放。参数：每小时的工资（整型），每月工作的小时数(整型)。 SalesEmployee：按月销售额和提成率拿工资的员工，参数：月销售额(整型)，提成率(浮点型)
public class SalariedEmployee extends ColaEmployee {
double salary;
SalariedEmployee() {
}
SalariedEmployee(String name, int month, double salary) {
super(name, month);
this.salary = salary;
}
@Override
double getSalary(int month) {
return salary;
}
}
public class HourlyEmployee extends ColaEmployee {
int hourSalary;
int hour;
HourlyEmployee() {
}
HourlyEmployee(String name, int month, int hourSalary, int hour) {
super(name, month);
this.hourSalary = hourSalary;
this.hour = hour;
}
@Override
double getSalary(int month) {
double salary = 0;
if (hour <= 160) {
salary = hour * hourSalary;
} else {
salary = 160 * hourSalary + (hour - 160) * hourSalary * 1.5;
}
return salary;
}
}
public class SalesEmployee extends ColaEmployee {
int monthSalary;
float rate;
SalesEmployee() {
}
========101TEST========SalesEmployee========101TEST========(String name, int month, int monthSalary, float rate) {
super(name, month);
this.monthSalary = monthSalary;
this.rate = rate;
}
@Override
double getSalary(int month) {
double salary = monthSalary * rate;
return salary;
}
}
3） [ 问答题 ]
（3）创建一个测试类，包含两个方法，分别为： payWage(ColaEmployee emp,int month):计算不同类型员工某个月工资。 主方法main(String[] args)：在主方法中分别创建一个拿固定工资的员工、拿小时工资的员工、按月销售额和提成率拿工资员工的对象，并把这三个对象放入一个ColaEmployee类型数组中，然后遍历数组，分别计算这个数组中每个员工某个月的工资。
public class TestCompany {
public static void main(String[] args) {
// TODO Auto-generated method stub
ColaEmployee[] a = new ColaEmployee[3];
a[0]=new SalariedEmployee("大川",2,3500);
a[1]=new HourlyEmployee("海鸥",2,20,200);
a[2]=new SalesEmployee("abc",5,30000,0.1f);
for(ColaEmployee c:a){
payWage(c,2);
}
}
public static void payWage(ColaEmployee emp,int month){
System.out.println(emp.name+"的工资:"+emp.getSalary(month));
}
}
第五部分：编程题
1、 [ 编程题 ]
判断101-200之间有多少个素数，并输出所有素数。（素数(质数)就是除了1和它本身以外，没有其他的数可以被它整除）
package com.neuedu;
public class PrimeNumber
{
public static void main(String[] args)
{
//for循环遍历101-200
for(int i = 101; i < 200; i++)
{
boolean b = false;
//内层循环判断i是否为素数
for(int j = 2; j <= i-1; j++)
{
//除了1和它本身以外，如果i可以整除其他数就b = false
if( i % j == 0 )
{
b = false;
break;
}
//如果不能整除就b = true
else
{
b = true;
}
}
//如果b = true就打印出来
if(b == true)
{
System.out.println(i);
}
}
}
}
2、 [ 编程题 ]
打印出100-999所有的“水仙花数”。
思路：
水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。
（例如：1^3 + 5^3+ 3^3 = 153）
package com.neuedu;
public class NarcissisticNumber
{
public static void main(String[] args)
{
int b, s, g;
for(int i = 100; i < 1000; i++)
{
g = i % 10; //g存个位数
s = ( i / 10 ) % 10; //s存十位数
b = i / 100; //b存百位数
//如果它的个十百位数字的3次幂之和等于它本身则打出
if( i == ( (g*g*g) + (s*s*s) + (b*b*b) ) )
{
System.out.println(i + "是水仙花数");
}
}
}
}
3、 [ 编程题 ]
现有如下HashMap:
Map<String,String> data=new HashMap<>();
data.put("empno", "10001");
data.put("ename", "scott");
data.put("job", "添坑队长");
请解析出每个键及其对应的值,并打印到控制台
参考答案:
Map<String,String> data=new HashMap<>();
data.put("empno", "10001");
data.put("ename", "scott");
data.put("job", "添坑队长");
Set<Map.Entry<String, String>> entrySet=data.entrySet(); //2分
for(Map.Entry<String, String> entry:entrySet) //1分
{
System.out.println(entry.getKey()+" : "+entry.getValue());//2分
}
4、 [ 编程题 ]
编写一个程序，从文件（文件名键盘输入）得到该文件保存的10个正整数，并输出这10个整数的最大值和最小值。
public class GetMaxMin{
public static void main(String[] args) throws Exception {
String file = new Scanner(System.in);
int i, n=10, max=0, min=0 , temp = 0;
try{
Reader in = new FileReader(file);
BufferedReader br=new BufferedReader(new InputStreamReader(in);
max=min=Integer.parseInt(br.readLine( ));
} catch ( Exception e ) {
System.out.println("文件错误");
}
for ( i = 2 ; i <= n ; i ++ ) {
try {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
temp=Integer.parseInt(br.readLine( ));
if (temp > max ) max=temp;
if (temp < min) min=temp;
}catch( IOException e ) { } ;
}
System.out.println("max="+max+"\nmin="+min);
}
}
5、 [ 编程题 ]
有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
提示：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。
package com.neuedu;
public class EleventhNumberRange {
public static void main(String[] args) {
int count = 0;
for(int x=1; x<5; x++) {
for(int y=1; y<5; y++) {
for(int z=1; z<5; z++) {
if(x != y && y != z && x != z) {
count ++;
System.out.print(x*100 + y*10 + z + " ");
if(count % 4 == 0) {
System.out.println();
}
}
}
}
}
System.out.println("共有" + count + "个三位数");
}
}
7、 [ 编程题 ]
请编写一个方法，计算两个日期之间的实际天数
要求：
1.日期参数以字符串类型接收。
2.实际天数包含开始日期和结束日期。如:
Date1:”2017-01-01”
Date2:”2017-01-04”
实际天数为4天
public static void date(String bdate,String edate) throws Exception{//方法参数正确1分
DateFormat df=new SimpleDateFormat("yyyy-MM-dd"); //1分
Date date1=df.parse(bdate); //调用parse方法1分
Date date2=df.parse(edate);
long btime=date1.getTime(); //调用getTime方法1分
long etime=date2.getTime();
long time=etime-btime;
long day=time/1000/60/60/24+1;// 1分
System.out.println(day);
}
8、 [ 编程题 ]
写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数．
public int countWords(String file, String find) throws Exception
{
int count = 0;
Reader in = new FileReader(file); --1分
int c;
while ((c = in.read()) != -1) { --2分
while (c == find.charAt(0)) { --2分
for (int i = 1; i < find.length(); i++) { --2分
c = in.read(); --1分
if (c != find.charAt(i)) break; --1分
if (i == find.length() – 1) count++; --2分
}
}
}
return count;
}
9、 [ 编程题 ]
使用for循环，求1到100之间所有能被3整除的整数的和。
public static void main(String[] args) {
int i;
int sum = 0;
for (i = 1; i <= 100; i++) { --4分
if (i % 3 == 0) { --4分
sum += i; --2分
}
}
System.out.println("sum:" + sum);
}
题目解析：
10、 [ 编程题 ]
在一个有8个整数（18，25，7，36，13，2，89，63）的数组中找出其中最大的数及其下标。
public static void main(String[] args) {
int[] a = { 18, 25, 7, 36, 13, 2, 89, 63 }; //-----------2分
int x = 0; //-----------1分
int max = a[0]; //-----------1分
for (int i = 1; i < a.length - 1; i++) { //-----------2分
if (a[i] > max) { //-----------2分
max = a[i]; //-----------1分
x = i; //-----------1分
}
}
System.out.println("最大元素：" + max + "；下标：" + x);
}
11、 [ 组合题 ]
根据如下要求，编写程序：
1） [ 问答题 ]
（1）定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串属性face和suit，分别用来描述一张牌的牌面值（如：A、K、Q、J、10、9、…、3、2等）和花色（如：“黑桃”、“红桃”、“梅花”和“方块”）。
（2）定义Card类中的public访问权限的构造方法，为类中的属性赋值。
（3）定义protected访问权限的方法getFace()，得到扑克牌的牌面值。
（4）定义protected访问权限的方法getSuit()，得到扑克牌的花色。
（5）定义方法toString()，返回表示扑克牌的花色和牌面值字符串（如“红桃A”、“梅花10”等）。
1） 【问答题】 答案： public class Card {
private String face;
private String suit; //-----------1分
public Card(String face,String suit){ //-----------1分
this.face=face;
this.suit=suit; //-----------1分
}
protected String getFace() { //-----------1分
return this.face; //-----------1分
}
protected String getSuit() { //-----------1分
return this.suit; //-----------1分
}
public String toString(){ //-----------1分
return this.suit+this.face; //-----------1分
}
}
2） [ 问答题 ]
（6）编写main方法，在其中定义字符串数组f和s，分别表示扑克牌的牌面值和花色；定义一个数组存储52个Card对象，并为这些对象分别赋值。
2） 【问答题】 答案： public static void main(String[] args) {//-----------1分
String[] f = { "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2" };
String[] s = { "黑桃", "红桃", "梅花", "方块" };//-----------1分
Card[] card = new Card[52]; //-----------1分
for (int j = 0; j < s.length; j++) {//-----------1分
for (int k = 0; k < f.length; k++) {//-----------1分
card[k * 4 + j] = new Card(f[k], s[j]); //-----------1分
}
}
}
个性签名：独学而无友，则孤陋而寡闻。做一个灵魂有趣的人！
如果觉得这篇文章对你有小小的帮助的话，记得在右下角点个“推荐”哦，博主在此感谢！
Java入门到入坟
万水千山总是情，打赏一分行不行，所以如果你心情还比较高兴，也是可以扫码打赏博主，哈哈哈(っ•̀ω•́)っ✎⁾⁾！
