判断
1-1
如果在子类的构造方法中，没有使用关键字super调用父类的某个构造方法，那么默认有super();语句，即调用父类的不带参数的构造方法。(T)
解析：如果父类只有有参构造方法，那么子类必须要重写父类的构造方法，子类在继承父类时，如果没有相同的带参构造方法，那么他就需要在其构造方法中明确的通过super()调用父类的带参构造方法，否则构造不出父类，从而也构造不出他自己了
1-2
package语句必须放到java程序的最开始。(T)
解析 ：JAVA中，程序中如果有package语句，该语句一定是源文件中的第一条可执行语句。
1-3
类可以有两种重要的成员：成员变量和方法，类还可以有一种成员：内部类。(T)
解析：
内部类
(1)类可以有两种重要的成员:成员变量和方法,类还可以有一种成员:内部类。
(2)java支持在一个类中声明另一个类，这样的类称为内部类，而包含内部类的类称为内部类的外部类。声明内部类如同在类中声明方法和成员变量一样，一个类把内部类看作是自己的成员.内部类的外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。
(3)内部类的类体中不可以声明类变量和方法，外嵌类的类体中可以用内部类声明对象,作为外嵌类的成员。
1-4
构造函数名应与类名相同，返回类型为void。(F)
解析：
构造方法是一种特殊的方法，具有以下特点。
(1)构造方法的方法名必须与类名相同。
(2)构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
(3)构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
(4)构造方法不能由编程人员调用，而要系统调用。
(5)一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构 造器，这个构造器不执行任何代码。
(6)构造方法可以重载，以参数的个数，类型，或排列顺序区分。
1-5
可以使用protected修饰符来防止方法和数据被不同包的非子类访问。(T)
解析：protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及 子类访问，即使子类在不同的包中也可以访问。
1-6
类及其属性、方法可以同时有一个以上的修饰符来修饰。(T)
解析：例如：public static void test()
1-7
修饰符protected主要是允许其他包中的子类来访问父类的特定属性。(T)
解析：protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及 子类访问，即使子类在不同的包中也可以访问。
1-8
Java中类和方法都不允许嵌套定义。(F)
解析：类可以嵌套，例如匿名内部类，方法不可以被嵌套。
1-9
对于abstract类，不能创建该类的对象。(T)
解析：：abstract抽象类不能用new实例化对象，abstract方法只允许声明不能实现。
1-10
一个Java类可以有多个父类。(F)
解析：Java类只支持单继承，不支持多继承。也就是说只可以有1个父类。
1-11
引用一个类的属性或调用其方法，必须以这个类的对象为前缀。(F)
解析：static属性和方法可以用类名为前缀。其他的都用对象。
1-12
Java的字符类型采用的是Unicode编码，每个Unicode码占16个比特。(T)
1-13
在Java程序中，可以使用protected来修饰一个类。(T)
1-14
子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。(T)
解析：子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。
1-15
可以使用protected修饰符来防止方法和数据被不同包的非子类访问。(T)
解析：protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及 子类访问，即使子类在不同的包中也可以访问。
选择：
2-1
在Java中，负责对字节代码解释执行的是 ( )
虚拟机
2-2
在面向对象的软件系统中，不同类对象之间的通信的一种构造称为___。
消息
2-3
以下哪句是错误的？(c)
A.
编译器会搜索要import的类的编译结果文件而不是源文件
B.
import是告诉编译器要import的包的信息
C.
import是把要import的类的源代码插入到import语句所在的地方
D.
编译器在编译的时候需要能访问得到要import的类的编译结果文件
解析：编译器会搜索要import的类的编译结果文件而不是源文件 import是告诉编译器要import的包的信息
2-4
下面哪一句是关于非静态的内部类正确的描述?(B)
A.
It must implement an interface.
B.
It can access private instance variables in the enclosing object.(它可以访问封闭对象中的私有实例变量。)
C.
It is accessible from any other class
D.
It can only be instantiated in the enclosing class.
E.
It must be final if it is declared in a method scope.
解析：静态都是用来修饰类的内部成员的。比如静态方法，静态成员变量，静态常量。它唯一的作用就是随着类的加载(而不是随着对象的产生)而产生，以致可以用类名+静态成员名直接获得。这样静态内部类就可以理解了，因为这个类没有必要单独存放一个文件，它一般来说只被所在外部类使用。并且它可以直接被用 外部类名+内部类名 获得。
2-5
非静态内部类，有时也称为实例内部类或成员内部类，它具有以下特点，除了( )。(A)
A.
在创建非静态内部类的实例时，外部类的实例不是必须存在
B.
非静态内部类的实例自动持有外部类的实例引用
C.
外部类实例和内部类实例之间是一对多的关系
D.
一个内部类实例只会引用一个外部类实例
解析：非静态内部类，必须有一个外部类的引用才能创建。
2-6
以下程序段输出结果的是( )
public class Test {
public static void main(String args[]){
String str="ABCDE";
str.substring(3);
str.concat("XYZ");
System.out.print(str);
}
}
解析：没有赋值，str不变。
2-7
若在某一个类定义中定义有如下的方法：abstract void performDial( );该方法属于( )。
抽象方法
2-8
以下关于Java的局部内部类的说法错误的是( C)
A.
局部内部类只能在当前类中使用
B.
局部内部类不能包含静态成员
C.
局部内部类可以访问外部类的所有成员
D.
在局部内部类中定义的内部类不能被private修饰符修饰
解析：局部内部类特点：不能使用任何的访问修饰符。
会生成两个.class文件，一个是Outer.class ，另一个是Outer$LocalInner.class。
局部内部类只能访问方法中声明的final类型的变量。我们是无法在外部去创建局部内部类的实例对象的，因为局部内部类是定义在方法中的，而方法是需要所在类的对象去调用。
2-9
如果要使条件method( -4.4 ) == -4成立，则用到java.lang.Math 类中哪个方法？
round()
解析：round 表示"四舍五入"，算法为Math.floor(x+0.5) ，即将原来的数字加上 0.5 后再向下取整，所以 Math.round(11.5) 的结果为 12，Math.round(-11.5) 的结果为 -11。
2-10
关于以下程序代码的说明正确的是(D) 。
1．class HasStatic{
2． private static int x=100；
3． public static void main(String[ ] args){
4． HasStatic hs1=new HasStatic( );
5． hs1.x++;
6． HasStatic hs2=new HasStatic( );
7． hs2.x++;
8． hs1=new HasStatic( );
9． hs1.x++;
10． HasStatic.x--;
11． System.out.println(“x=”+x);
12． }
13． }
A.
5行不能通过编译，因为引用了私有静态变量
B.
10行不能通过编译，因为x是私有静态变量
C.
程序通过编译，输出结果为：x=103
D.
程序通过编译，输出结果为：x=102
2-11
编译和运行下列程序会出现什么样的结果( A)。
public class Ref {
public static void main(String[] args){
Ref r = new Ref();
r.amethod(r);
}
public void amethod(Ref r){
int i = 99;
multi(r);
System.out.println(i);
}
public void multi(Ref r){
r.i = r.i * 2;
}
}
A.
编译出错
B.
输出：99
C.
输出：198
D.
运行出错
2-12
程序员可以根据以下哪一个实体来模拟真实世界的编程？(C)
A。
事件驱动编程
B。
函数式程序设计
C.
面向对象程序设计
D。
程序设计
2-13
哪个关键字用于定义类，包括父类的非私有属性和行为，以及特定于所定义类的附加属性和行为？(A)
A。
延伸
B。
超级的
C.
继承
D。
终结器
2-14
下面哪个函数是public void aMethod(){…}的重载函数？( D )
A.
void aMethod( ){…}
B.
public int aMethod(){…}
C.
public void aMethod ( ){…}
D.
public int aMethod ( int m){…}
解析：重载：
方法名相同
方法的参数类型，参数个不一样
方法的返回类型可以不相同
方法的修饰符可以不相同
main 方法也可以被重载
2-15
假设类A有如下定义，且a是A类的一个实例，则必定错误的选项是(D )。
class A {
int i;
static String s;
void method1() { }
static void method2() { }
}
A.
System.out.println(a.i)；
B.
a.method1();
C.
A.method1();
D.
A.method2() ;
2-16
关于被私有访问控制符private修饰的成员变量，以下说法正确的是(C )
A.
可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B.
可以被两种类访问和引用：该类本身、该类的所有子类
C.
只能被该类自身所访问和修改
D.
只能被同一个包中的类访问
程序填空题：
5-1
(检验密码)一些网站设定了一些制定密码的规则。编写一个方法，检验一个字符串是否合法的密码。假设密码规则如下： 密码必须至少有8个字符。 密码只能包含字母和数字。 密码必须至少有2个数字。 请编写一个程序，提示用户输入密码，如果改密码符合规则就显示“Valid password”，否则显示“Invalid password”。
public class Main {
public static void main(String[] args) {
// Prompt the user to enter a password
java.util.Scanner input = new java.util.Scanner(System.in);
//System.out.print("Enter a string for password: ");
String s = input.nextLine();
if (isValidPassword(s)) {
System.out.println("Valid password");
}
else {
System.out.println("Invalid password");
}
}
/** Check if a string is a valid password */
public static boolean isValidPassword(String s) {
// Only letters and digits?
for (int i = 0; i < s.length(); i++) {
if ((!Character.isLetter(password.charAt(i))) &&
!Character.isDigit(s.charAt(i)))
return false;
}
// Check length
if (s.length()< 8)
return false;
// Count the number of digits
int count = 0;
for (int i = 0; i < s.length(); i++) {
if (Character.isDigit(s.charAt(i)))
count++;
}
if (count >= 2)
return true;
else
return false;
}
}
5-2
相同的数组。如果两个数组list1和list2的内容相同，那么就说它们是相同的。使用下面的程序可以判断两个数组是否相同，请填空补全程序。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int size1 = input.nextInt();
int[] list1 = new int[size1];
// Enter values for list1
for (int i = 0; i < list1.length; i++)
list1[i] = input.nextInt();
int size2 = input.nextInt();
int[] list2 = new int[size2];
// Enter values for list2
for (int i = 0; i < list2.length; i++)
list2[i] = input.nextInt();
input.close();
if (equals(list1,list2)) {
System.out.println("Two lists are identical");
} else {
System.out.println("Two lists are not identical");
}
}
public static boolean equals(int[] list1, int[] list2) {
if (list1.length!=list2.length)
return false;
Arrays.sort(list1);
Arrays.sort(list2);
for (int i = 0; i < list1.length; i++)
if (list1[i] != list2[i])
return false;
return true;
}
}
函数题：
6-1 定义一个股票类Stock (10分)
定义一个名为Stock的股票类，这个类包括：一个名为symbol的字符串数据域表示股票代码。一个名为name的字符串数据域表示股票名称。一个名为previousClosingPrice的double数据域，它存储前一日的股票交易价格。一个名为currentPrice数据域，它存储当前的股票交易价格。创建一个有特定代码和名称的股票的构造方法。一个名为getChangePercent()方法返回从previousClosingPrice变化到currentPrice的百分比。
类名为：
Stock
裁判测试程序样例：
import java.util.Scanner;
/* 你提交的代码将被嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String symbol1=input.next();
String name1=input.next();
Stock stock = new Stock(symbol1, name1);
stock.previousClosingPrice = input.nextDouble();
// Input current price
stock.currentPrice = input.nextDouble();
// Display stock info
System.out.println(stock.name+" Price Changed: " + stock.changePercent() * 100 + "%");
input.close();
}
}
输入样例：
002594
比亚迪
56.98
55.40
输出样例：
比亚迪 Price Changed: -2.77290277290277%
答案：
class Stock
{
String symbol;
String name;
double previousClosingPrice;
double currentPrice;
public Stock(String s,String n)
{
symbol=s;name=n;
}
public double changePercent()
{
return -(previousClosingPrice-currentPrice)/previousClosingPrice;
}
}
6-2 从抽象类shape类扩展出一个正n边形 (10分)
在一个正n边形(Regular Polygon)中，所有边的边长都相等，且所有角的度数相同(即这个多边形是等边、等角的)。请从下列的抽象类shape类扩展出一个正n边形类RegularPolygon,这个类将正n边形的边数n和边长a作为私有成员，类中包含初始化边数n和边长a的构造方法。 public abstract class shape {// 抽象类 public abstract double getArea();// 求面积 public abstract double getPerimeter(); // 求周长 } 计算正n边形的面积公式为： Area=n×a×a/(tan((180度/n))×4);
类名：RegularPolygon
裁判测试程序样例：
abstract class shape {// 抽象类
/* 抽象方法 求面积 */
public abstract double getArea();
/* 抽象方法 求周长 */
public abstract double getPerimeter();
}
/* 你提交的代码将嵌入到这里 */
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
int n=input.nextInt();
double side = input.nextDouble();
shape rp = new RegularPolygon(n,side);
System.out.println(d.format(rp.getArea()));
System.out.println(d.format(rp.getPerimeter()));
input.close();
}
}
输入样例：
5 7
输出样例：
84.3034 35
答案：
class RegularPolygon extends shape
{
private double a;
private int n;
public RegularPolygon()
{
n=0;
a=0;
}
public RegularPolygon(int n,double a)
{
this.n=n;
this.a=a;
}
public double getArea()
{
return n*a*a/(Math.tan( Math.toRadians(180/n))*4);
}
public double getPerimeter()
{
return n*a;
}
}
编程题：
7-1 找出最大的对象 (10分)
(找出最大的对象)编写一个方法，返回对象数组中最大的对象。方法签名如下： public static
Object max(Comparable[] a) public static Object max(Comparable[] a)
import java.util.*; public class Main{ public static Object
max(Comparable[] a) { /// 请填写此部分内容 }
public static void main(String[] args){
String[] sArray = new String[5];
Integer[] intArray = new Integer[5];
Scanner input = new Scanner(System.in);
for(int i=0;i
sArray[i] = input.next();
}
for(int i=0;i
intArray[i] = new Integer(input.nextInt());
}
System.out.println("Max string is " +(String)max(sArray));
System.out.println("Max integer is " + (Integer)max(intArray));
}
}
所有对象都是Comparable接口的实例。对象在数组中的顺序是由compareTo方法决定的。 编写测试程序，从键盘输入5个字符串和5个整数，创建一个由5个字符串构成的数组、一个由5个整数构成的数组。找出数组中最大的字符串、整数并输出。
请在这里描述输出格式。例如：对每一组输入，在一行中输出A+B的值。
输入样例:
在这里给出一组输入。例如： Xi’an (输入5个字符串，每行一个) Beijing ShangHai GuangZhou ShenZhen
8 9 12 7 6 (输入5个整数，以空格分隔)
输出样例:
在这里给出相应的输出。例如： Max string is Xi’an (输出最大的字符串) Max integer is 12
(输出最大的整数)
答案：
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static Object max(Comparable[] a){
Arrays.sort(a);
return a[a.length-1];
}
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String[] s1=new String[5];
Integer[] i1=new Integer[5];
int i=0;
while(i<5){
s1[i]=in.next();
i++;
}
int j=0;
while(j<5){
i1[j]=in.nextInt();
j++;
}
System.out.println("Max string is "+max(s1));
System.out.println("Max integer is "+max(i1));
in.close();
}
}
7-2 两个巨大素数(质数)的乘积 (10分)
得到两个巨大素数(质数)的乘积是简单的事，但想从该乘积分解出这两个巨大素数却是国际数学界公认的质因数分解难题。这种单向的数学关系，是不对称加密RSA算法的基本原理。 本题给出两个大素数(128bit位)的乘积和其中一个素数，请你编程求出另一个素数。
输入格式:
44022510695404470886511586569647292146578314354528108825807522926455663589709
(大素数的乘积) 189193782774204832019945226750213439577 (其中一个大素数)
输出格式:
232684764001698545563067004009755869717 (另一个素数)
输入样例:
60883665878129858935918958333091530420746054622405737630613777684610994823161
271963475875372143777333694041058521413
输出样例:
223867067745633357281812540202957589797
答案：
import java.util.*;
import java.lang.*;
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
BigInteger a = input.nextBigInteger();
BigInteger b = input.nextBigInteger();
BigInteger c = a.divide(b);
System.out.println(c);
}
}
BigInteger的使用：
7-3 大数整除 (10分)
请编写程序，从键盘输入一个整数n，找出大于long.MAX_VALUE且能被n整除的前3个数字。
输入格式:
输入一个作为除数的整数n，例如： 17
输出格式:
输出大于long.MAX_VALUE且能被n整除的前3个数字，例如下列三个数能被17整除且大于long.MAX_VALUE： 9223372036854775816 9223372036854775833 9223372036854775850
输入样例:
103
输出样例:
9223372036854775832 9223372036854775935 9223372036854776038
代码(部分正确)：
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
BigInteger bigNum=new BigInteger(String.valueOf(Long.MAX_VALUE));
int n=in.nextInt();
int count=0;
while(count<3){
if(bigNum.mod(BigInteger.valueOf(n)).intValue()==0){
System.out.println(bigNum);
count++;
}
bigNum=bigNum.add(BigInteger.ONE);
}
}
}
7-4 Remove duplicates (10分)
(Remove duplicates) Write a method that removes the duplicate elements from an array list of integers using the following header: public static void removeDuplicate(ArrayList list) Write a test program that prompts the user to enter n integers to a list ,After sort the distinct intergers and displays the distinct integers separated by exactly one space.
input style :
Input the number n for the length of the array in the first line, and the next line input n integers for the array…
output style:
Displays the distinct integers separated by exactly one space
input sample:
5
32 43 32 22 22
output sample:
32 43 22
答案：
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int num = s.nextInt();
int []a = new int[num];
int []b = new int[num];
int flag = 1;
int count = 0;
int index=0;
for(int i=0;i
flag = 1;
int temp = s.nextInt();
index++;
for(int j=0;j
if(temp==a[j]){
flag = 0;
break;
}
}
if(flag==1){
a[i]=temp;
b[count]=temp;
count++;
}else{
continue;
}
}
for(int m=0;m
System.out.print(b[m]+" ");
}
}
}
7-5 查找电话号码 (10分)
文件phonebook1.txt中有若干联系人的姓名和电话号码。 高富帅 13312342222 白富美 13412343333 孙悟空 13512345555 唐三藏 13612346666 猪悟能 13712347777 沙悟净 13812348888 请你编写一个简单的通信录程序，当从键盘输入一个姓名时查找到对应的电话号码并输出。如果没找到则显示Not found. 由于目前的自动裁判系统暂时不能支持用户读入文件，我们编写程序从键盘输入文件中的姓名和电话号码，当输入的名字为noname时，表示结束。noname后面有一个名字，需要查找其对应的电话号码。
输入格式:
高富帅 13312342222 白富美 13412343333 孙悟空 13512345555 唐三藏 13612346666 猪悟能
13712347777 沙悟净 13812348888 noname (表示结束) 唐三藏 (需要查找此人的电话号码)
输出格式:
13612346666 (输出对应的电话号码)
输入样例:
白富美 13412343333 孙悟空 13512345555 唐三藏 13612346666 猪悟能 13712347777 沙悟净
13812348888 noname
白骨精
输出样例:
Not found.
答案：
import java.util.*;
public class Main {
public static void main(String args[]){
Map hm=new HashMap();
Scanner in=new Scanner(System.in);
while(in.hasNext()){
String name=in.next();
if(name.equals("noname")){
break;
}
else{
String phone=in.next();
hm.put(name, phone);
}
}
String seek_name=in.next();
if(hm.containsKey(seek_name)){
System.out.println(hm.get(seek_name));
}
else {
System.out.println("Not found.");
}
}
}
2510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
