下列循环体执行的次数是（ ）。 int x=10, y=30; do{ y -= x; x++; }while(x++

答案是：C

在编写Java程序时，如果不为类的成员变量定义初始值，Java会给出它们的默认值，下列说法中不正确的一个是（ ）。 A boolean的默认值是false B byte的默认值是0

答案是：C

判断：continue语句用在循环语句中，它的作用是跳出循环。 A 错 B 对

答案是：对

列表达式1+2+ "aa"+3的值是（ ）。 A "aa3" B "3aa3 " C "12aa" D "12aa3"

答案是：B

下列说法中，不正确的一个是（ ）。 A case子句中可以有多个语句，并且不需要大括号{}括起来 B switch语句的功能可以由if…else if语句来实现 C

答案是：C

下列选项中，不属于Java核心包的一项是（ ）。 A java.lang B java.util C java.io D javax.s

答案是：D

假设a是int类型的变量，并初始化为1，则下列（ ）是合法的条件语句？ A if(a=2){} B if(true){} C if(a){} D

答案是：B

下列循环体执行的次数是（ ） int y=2, x=4; while(--x != x/y){ } A 1 B 3 C 2 D

答案是：B

下列（ ）不属于Java语言流程控制结构？ A 分支语句 B 跳转语句 C 赋值语句 D 循环语句

答案是：C

判断：main函数是java程序的执行入口。 A 对 B 错

答案是：A

判断：Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。 A 对 B 错

答案是：A

下列关于运算符优先级的说法中，不正确的一个是（ ） A 同一优先级的运算符在表达式中都是按照从右到左的顺序进行运算的 B 运算符按照优先级顺序表进行运算 C

答案是：A

判断：强制类型转换运算符的功能是将一个表达式的类型转换为所指定的类型。（ ） A 错 B 对

答案是：B

判断：若x=5，则表达式（x+5）/3的值是3 A 对 B 错

答案是：对

Java语言属于（ ）种语言？ A 面向机器的语言 B 面向操作系统的语言 C 面向对象的语言 D 面向过程的语言

答案是：C

设a、b为long型变量，x、y为float型变量，ch为char类型变量且它们均已被赋值，则下列语句中正确的是（ ）。 A switch ch {} B switch(x+y) {}

答案是：学生答案：C

以下的变量定义语句中，合法的是（ ） A byte $_b1 = 12345; B double d = Double.MAX_VALUE; C float _

答案是：B

在Java语言中，（ ）是最基本的元素？ A 包 B 方法 C 对象 D 接口

答案是：C

判断：Java语言使用的是Unicode字符集，每个字符在内存中占8位。 A 对 B 错

答案是：B

判断：说明或声明数组时不分配内存大小,创建数组时分配内存大小。（ ） A 错 B 对

答案是：对

下列标识符（名字）命名原则中，正确的是（ ） A 常量全部大写 B 接口名的首字母小写 C 类名的首字母小写 D 变量名和方法名的首字母

答案是：A

编译下面源程序会得到哪些文件（ ）？ class A1{ } class A2{ } public class B{ public static void main(String[] ar

答案是：A

下列JAVA语句中,不正确的一项是( ) A char c,d=.a.; B double e=0.0f C float e=0.0d; D

答案是：C

下面哪些选项是正确的main方法说明？（ ） A public main(String args[]) B void main() C private stat

答案是：public static void main(String args[])

下列关于Java语言简单数据类型的说法中，正确的一项是（ ）。 A double型数据占计算机存储的32位 B boolean类型的数据作为类成员变量的时候，相同默认的初始值为true

答案是：以0开头的整数代表8进制整型常量

2 判断：JDK安装是不可以修改安装目录。 A 错 B 对

答案是：错

已知a=2, b=3，则表达式a%b*4%b的值为（ ） A -2 B 2 C 1 D -1

答案是：2

public class Father{ int a=100; public void miner(){ a--; } public static void main(String[] args){ Father x

答案是：0 100 0 99

// AbstractClassDemo.java源代码如下： abstract class Shape { //定义抽象类Shape和抽象方法display abstract void display(); } clas

答案是：答案：(1) Circle； (2) Rectangle； (3) Triangle。

import java.io.*; public class Test { public static void main(String args[]) throws IOException { Buffere

答案是：100 不能；因为方法Integer.parseInt(str)不能将字符串“exit”转化为整数，抛出异常。

import java.io.*; public class Test { public static void main(String args[]) throws IOException { Buffere

答案是：25 终止应用程序的运行。

阅读下面的程序，回答问题(问3分，问3分，共6分)。 import java.awt.*; import javax.swing.*; public class T extends JFrame {

答案是： 接口名：ActionListener 接口中的方法：public void actionPerformed(ActionEvent e)

下列程序的运行结果是__12345____。 public class MyClass { int a[] = { 1, 2, 3, 4, 5 }; void out() { for (int j = 0; j < a.

答案是：12345

以下程序的输出结果__。 public class Father { String name, address, tel; int age; public Father(String name, int age) {

答案是：姓名:Tom 年龄:15 家庭住址:金水区 电话:66123456 学校：九中

以下程序的输出结果为_____。 public class Tom { private float weight; private static String name; public void setWeight(flo

答案是：汤姆猫体重：20.0斤

以下程序的输出结果为_____。 public class Course { private String cNumber; private String cName; private int cUnit; publi

答案是：课程号:101 课程名:ASP 学分:3

以下程序的输出结果为________。 public class Person { String name; int age; public Person(String name, int age) { this.n

答案是：Peter is 17 years old!

阅读以下程序，写出输出结果。 class Animal { Animal() { System.out.print ("Animal "); } } public class Dog extends An

答案是：输出结果：Animal Dog

以下程序段的输出结果为 5 6 7 8 9 。 public class TestArray { public static void main(String args[ ]){ i

答案是：5 6 7 8 9

以下程序的输出结果为 。 class StringTest1 { public static void main(String[] args) { String s1="hello"; Strin

答案是：相等

import java.io.* ; public class abc { public static void main(String args[ ]) { System.out

答案是：运行结果：a=60 b=20 c=30

import java.io.* ; public class abc { public static void main(String args[ ]) { int i

答案是：运行结果：s = 180

import java.io.*; public class abc { public static void main(String args [ ]) { AB s = new AB("Hello!","I lo

答案是：运行结果：Hello! I love JAVA.

建立线程的方法有哪几种？Runnable接口在线程创建中的作用？

答案是：Java中创建线程主要有三种方式： 一、继承Thread类创建线程类 （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 （2）创建Thread子类的实例，即创建了线程对象。 （3）调用线程对象的start()方法来启动该线程。 二、通过Runnable接口创建线程类 （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。 （2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。 （3）调用线程对象的start()方法来启动该线程。 三、通过Callable和Future创建线程 （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。 （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。 （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。 （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值 Runnable接口在线程创建中的作用：使用Runnable接口，相比直接继承Thread类，有以下好处：避免单继承的局限性 ，便于共享资源。

一个线程执行完run()方法后，进入了什么状态？该线程还能再调用start()方法吗？

答案是：当run()方法执行完毕后，线程自动消亡，当Thread类调用start()方法时，Java虚拟机自动调用它的run()方法，而当run()方法结束时，该Thread会自动终止。以前Thread类中存在一个停止线程的stop()方法，不过它现在被废弃了，因为调用这个方法，很容易使程序进入不稳定状态。当实例化一个Thread对象并执行start()方法后，线程进入“可执行”状态，开始执行，虽然多线程给用户一种同时执行的感觉，但事实上在同一时间点上，只有一个线程在执行，只是线程之间转换的动作很快，所以看起来好像同时在执行一样。

线程有几种状态，引起线程中断的主要原因有哪些？

答案是：线程主要有以下状态：创建，可执行，非可执行，消亡。 引起线程中断的主要原因如下： （1）JVM将CPU资源从当前线程切换给其他线程，使本线程让出CPU的使用权处于中断状态。 （2）线程使用CPU资源期间执行了sleep方法，使当前线程进入休眠状态。 （3）线程使用CPU资源期间执行了wait( )方法，使得当前线程进入等待状态。 （4）线程使用CPU资源期间执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。

线程与进程有什么关系？

答案是：在一个操作系统中，每个独立执行的程序都可以称为一个进程，也就是“正在运行的程序”。而在进程中还可以有多个执行单元同时执行，这些执行单元可以看作程序执行的一条条线索，被称为线程。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。 进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的执行单位，一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程。 线程间可以共享进程中的某些内存单元(包括代码与数据)，线程的中断与恢复可以更加节省系统的开销。

从字节流到字符流的转化过程中，有哪些注意事项？

答案是：字符流转换字节流，其实就没必要了，直接使用 byte b[]=String s.getByte() 转换为字节就可以直接用字节流了。使用IO流一定要关闭哦，:close()方法。 24．FileInputStream流的read()方法和FileReader流的read()方法有何不同？ 答：FileInputStream流的read()方法以字节为单位读文件，FileReader流的read()方法以字符为基本单位处理数据。

简述可以用哪几种方法对文件进行读写。

答案是：使用FileWriter类写文本文件，使用FileWriter类往文本文件中追加信息，写入的文本很少，使用FileWrite类就可以了。但如果需要写入的内容很多，就应该使用更为高效的缓冲器流类BufferedWriter。使用FileReader类读文本文件，使用BufferedReader类读文本文件。

字节流和字符流之间有什么区别？

答案是：stream结尾都是字节流，reader和writer结尾都是字符流。两者的区别就是读写的时候一个是按字节读写，一个是按字符。实际使用通常差不多。在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。

BufferedReader流能直接指向一个文件对象吗？为什么？

答案是：BufferedReader br=new BufferedReader(new FileReader("路径\\路径\\文件名"));不能直接流向文件对象，要在里面套一个FileReader。

能否将一个对象写入一个随机访问文件？

答案是：没有直接的方法可以将对象写入到随机存取文件中。但是可以使用ByteArray输入/输出流作为中介，来向随机存取文件中写入或从随机存取文件中读出字节，并且可以利用字节流来创建对象输入/输出流，以用于读写对象。需要注意的是在字节流中要包含一个完整的对象，否则读写对象时将发生错误。例如，java.io.ByteArrayOutputStream可用于获取ObjectOutputStream的字节流，从中可得到byte数组并可将之写入到随机存取文件中。相反，我们可以从随机存取文件中读出字节数组，利用它可构造ByteArrayInputStream,进而构造出ObjectInputStream,以读取对象。

什么叫流？简述流的分类。

答案是：流（stream）是一组有序的数据序列。根据操作的类型，分为输入流和输出流两种。输入流的指向称为源，程序从指向源的输入流中读取数据。当程序需要读取数据时，就会开启一个通向数据源的流，这个数据源可以是文件、内存或是网络连接。而输出流的指向是字节要去的目的地，程序通过向输出流中写入数据把信息传递到目的地。当程序需要写入数据时，就会开启一个通向目的地的流。

说明throws与throw的作用？

答案是：若某个方法可能会发生异常，但不想在当前方法中来处理这个异常，那么可以将该异常抛出，然后在调用该方法的代码中捕获该异常并进行处理。将异常抛出，可通过throws关键字来实现。throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常，多个异常可用逗号分隔。 使用throw关键字也可抛出异常，与throws不同的是，throw用于方法体内，并且抛出一个异常类对象，而throws用在方法声明中来指明方法可能抛出的多个异常。 通过throw抛出异常后，如果想由上一级代码来捕获并处理异常，则同样需要在抛异常的方法中使用throws关键字在方法的声明中指明要抛出的异常；如果想在当前的方法中捕获并处理throw抛出的异常，则必须使用try…catch语句。上述两种情况，若throw抛出的异常是Error、RuntimeException或它们的子类，则无须使用throws关键字或try…catch语句。

在Java的异常处理机制中，try程序块、catch程序块和finally程序块各起到什么作用？try-catch-finally语句如何使用？

答案是：在Java语言中，对容易发生异常的代码，可通过try…catch语句捕获。在try语句块中编写可能发生异常的代码，然后在catch语句块中捕获执行这些代码时可能发生的异常。try语句块中的代码可能同时存在多种异常，那么到底捕获的是哪一种类型的异常，是由catch语句中的“异常类”参数来指定的。catch语句类似于方法的声明，包括一个异常类型和该类的一个对象，异常类必须是Throwable类的子类，用来指定了catch语句要捕获的异常，异常类对象可在catch语句块中被调用，例如调用对象的getMessage()方法获取对异常的描述信息。在使用多个catch语句捕获try语句块中的代码抛出的异常时，需要注意catch语句的顺序。若多个catch语句所要捕获的异常类之间具有继承关系，则用来捕获子类的catch语句要放在捕获父类的catch语句的前面。否则，异常抛出后，先由捕获父类异常的catch语句捕获，而捕获子类异常的catch语句将成为执行不到的代码，在编译时会出错。finally子句需要与try…catch语句一同使用，不管程序中有无异常发生，并且不管之前的try…catch是否顺利执行完毕，最终都会执行finally语句块中的代码，这使得一些不管在任何情况下都必须执行的步骤被执行，从而保证了程序的健壮性。

系统定义的异常与用户自定义的异常有何不同？如何使用这两类异常？

答案是：通常使用Java内置的异常类就可以描述在编写程序时出现的大部分异常情况，但根据需要，有时要创建自己的异常类，并将它们用于程序中来描述Java内置异常类所不能描述的一些特殊情况。自定义的异常类必须继承自Throwable类，才能被视为异常类，通常是继承Throwable的子类Exception或Exception类的子孙类。

什么是异常？简述Java的异常处理机制？

答案是：所谓异常就是程序运行时可能出现一些错误，比如试图打开一个根本不存在的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误作出处理。 Java使用try-catch语句来处理异常，将可能出现的异常操作放在try-catch语句的try部分，将发生异常后的处理放在catch部分。

什么是最终类？什么是最终变量？什么是最终方法？

答案是：final class A{}，这样定义的类A就是最终类，最终类不可被继承，也就是说不能写这样的代码，class B extends A{}了。 final是java中的一个关键字，可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。如果一个类的域被关键字final所修饰，它的取值在程序的整个执行过程中将不会改变。final void B(){}，这样定义的方法就是最终方法，最终方法在子类中不可以被重写，也就是说，如果有个子类继承这个最终方法所在的类，那么这个子类中就不能再出现void B(){}这样的方法了。

什么是抽象类？什么是抽象方法？各自有什么特点？

答案是：有abstract关键字修饰的类为抽象类，抽象类是表示部分地实现功能，比如把某些已经确定的功能实现了，而抽象的功能则表示未实现，因为不能确定子类用什么方式实现它或者说把可能性和机会留给子类。抽象类和抽象方法的目的是相同的。当子类实现这些抽象方法后就是叫”实现“，如果这个方法在父类中已经实现了不是抽象的而子类再来实现一次就是“覆盖”或“重写“了父类的方法，这2个都叫实现了”多态“特性。“多态”就是某个“共性”在各个子类中表现出不同的“个性”，但都同时保留着“共性”。抽象类与抽象方法的特点：抽象类不一定有抽象方法，有抽象方法的类一定是抽象类。抽象类不能实例化。

4．比较接口与抽象类的异同。

答案是：接口与抽象类的共同点如下：（1）接口与抽象类都不能被实例化，能被其他类实现和继承（2）接口和抽象类中都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

一个类如何实现接口？实现某接口的类是否一定要重载该接口中的所有抽象方法？

答案是：实现接口就必须重写该接口的所有方法,java中接口里的方法都是抽象的,没有方法体。Java中一个类实现了某接口,可以不实现所有接口的方法,可以由它的子类实现

什么是接口？如何定义接口？接口与类有何区别？

答案是：Java中的接口是一个特殊的抽象类，接口中的所有方法都没有方法体。我们把用于完成特定功能的若干属性组织成相对独立的属性集合。这种属性的集合就是接口。 定义接口与定义类非常相似。实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类。一个类只能由一个父类，但是它可以同时实现若干个接口。这种情况下如果把接口理解成特殊的类，那么这个类利用接口实际上就获得了多个父类，即实现了多重继承。与类定义相仿，声明接口时也需要给出访问控制符，不同的是接口的访问控制符只有public一个。用public修饰的接口是公共接口，可以被所有的类和接口使用，而没有public修饰符的接口则只能被同一个包中的其他类和接口利用。接口也具有继承性。定义一个接口是可以通过extends关键字声明该新接口是某个已经存在的父接口的派生接口，它将继承父接口的所有属性和方法。与类的继承不同的是一个接口可以有一个以上的父接口，它们之间用逗号分隔，形成父接口列表。新接口将继承所有父接口中的属性和方法。

简述接口定义的一般格式。

答案是：接口定义的语法格式如下： [修饰符] interface 接口名 [extends 父接口名列表]{ [public] [static] [final] 常量; [public] [abstract] 方法; 修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。接口名：必选，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。方法：接口中的方法只有定义而没有被实现。

类的封装性、继承性和多态性各自的内涵是什么？

答案是：封装性是指的把代码封装到大括号中,只能访问自己内部的数据,外边的东西访问不了. 继承性就是一个类声明继承另一个类,那么另一个类就是它 的父类,父类里边的变量跟方法子类可以直接拿来用,除非父类的访问权限不允许。多态分为方法的重载和重写,重载是指方法的名和返回类型相同,但是参数不同.重写是指子类继承父类的方法,但是在子类自己类体里边又写了一个方法, 跟父类中的方法名,返回类型,参数列表都完全一样,但是方法体不同,也就是说它有自己的实现方式.这就是重写.

为什么要对类进行封装？封装的原则是什么？

答案是：对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。封装的原则主要是靠经验吧，只要尽力让封装的每个类里面的属性和方法独立，方便以后操作，减少耦合性就好了。

什么是成员变量的继承？什么是成员变量的覆盖？

答案是：通过继承可以得到父类的成员变量，子类的成员变量包括从父类继承的成员变量（包括从祖先类中继承的成员变量）以及子类中重新定义的成员变量。java的成员变量和局部变量重名 JAVA会用局部变量覆盖掉成员变量。

什么是重载方法？什么是覆盖方法？它们的主要区别是什么？

答案是：方法的重载是指在一个类中，出现多个方法名相同，但参数个数或参数类型不同的方法，则称为方法的重载。Java在执行具有重载关系的方法时，将根据调用参数的个数和类型区分具体执行的是哪个方法。方法重载之间必须保证参数不同，但是需要注意，重载方法在被调用时可能出现调用歧义。 当子类继承父类中所有可能被子类访问的成员方法时，如果子类的方法名与父类的方法名相同，那么子类就不能继承父类的方法，此时，称子类的方法覆盖了父类的方法。覆盖体现了子类补充或者改变父类方法的能力，通过覆盖，可以使一个方法在不同的子类中表现出不同的行为。 方法覆盖（Overriding）和方法重载（Overloading）是Java多态性的不同表现。覆盖Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。 如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被覆盖(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。 如果在同一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

什么是多态？使用多态有什么优点？Java中的多态有哪几种？重载方法与覆盖方法分别属于哪种多态？

答案是：多态是面向对象程序设计的重要部分，是面向对象的3个基本特性之一。在Java语言中，通常使用方法的重载（Overloading）和覆盖（Overriding）实现类的多态性。方法重写（Overriding）和方法重载（Overloading）是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

若在一个public类中的成员变量及成员方法的访问控制符为protected，则此类中的成员可供什么样的包引用？

答案是：当子类与父类不在同一包中，父类中使用private修饰符修饰的成员变量和友好的成员变量不会被继承，也就是子类只能继承父类中使用public和protected访问修饰符修饰的成员变量作为子类的成员变量，同样，子类也只能继承父类中使用public和protected访问修饰符修饰的方法作为子类的方法。 在一个类A中，它所定义的成员变量和方法都被protected所修饰，类A被类B、类C继承，那么在类B与类C中都继承了类A的成员变量和方法。这时，如果在类C中创建一个自身的对象，那么该对象可以访问父类的和自身定义的protected修饰的变量和方法。但是在其他类中，比如Student类，对于子类C自己声明的protected成员变量和方法，只要Student类与C类在同一包中，创建的对象就可以访问这些被protected修饰的成员变量和方法。对于子类C从父类中继承的protected成员变量和方法，只要Student类与C类的父类在同一包中，创建的对象就能够访问继承的protected成员变量和方法。

如何创建一个类的子类？

答案是：声明一个类的子类的格式如下： class 子类名 extends 父类名 { … }

1．什么是继承？什么是父类？什么是子类？继承的特性可给面向对象编程带来什么好处？什么是单继承？什么是多重继承？

答案是：继承是一种由已有的类创建新类的机制。利用继承，可以先编写一个共有属性的一般类，根据该一般类再编写具有特殊属性的新类，新类继承一般类的状态和行为，并根据需要增加它自己的新的状态和行为。 由继承而得到的类称为子类，被继承的类称为父类（超类）。 声明一个类的子类的格式如下： class 子类名 extends 父类名 { … } 单继承：子类只能继承一个父类 多重继承：子类可以有多个父类.

简答实例变量和类变量的区别？

答案是：（1）不同对象的实例变量互不相同 （2）所有对象共享类变量 （3）通过类名直接访问类变量

面向对象的特点？

答案是：封装性 、继承、多态

Import语句和package语句的功能分别是什么？

答案是：使用import语句引入包中的类。创建包可以通过在类或接口的源文件中使用package语句实现。

什么是包？如何创建包？如何引用包？

答案是：Java要求文件名和类名相同，所以如果将多个类放在一起时，很可能出现文件名冲突的情况，这时Java提供了一种解决该问题的方法，那就是使用包将类进行分组。包（package）是Java提供的一种区别类的命名空间的机制，是类的组织方式，是一组相关类和接口的集合，它提供了访问权限和命名的管理机制。创建包可以通过在类或接口的源文件中使用package语句实现，package语句的语法格式如下: package 包名; 包名：必选，用于指定包的名称，包的名称必须为合法的Java标识符。当包中还有子包时，可以使用“包1.包2.….包n”进行指定，其中，包1为最外层的包，而包n则为最内层的包。类可以访问其所在包中的所有类，还可以使用其他包中的所有public类。访问其他包中的public类可以有以下两种方法。 （1）使用长名引用包中的类,使用长名引用包中的类比较简单，只需要在每个类名前面加上完整的包名即可。（2）使用import语句引入包中的类,由于采用使用长名引用包中的类的方法比较繁琐，所以Java提供了import语句来引入包中的类。

Java中创建对象的一般格式是什么？如何初始化对象？如何给对象赋值？

答案是：对象的声明,声明对象的一般格式如下： 类名 对象名; 类名：必选，用于指定一个已经定义的类。 对象名：必选，用于指定对象名称，对象名必须是合法的Java标识符。 实例化对象,在声明对象时，只是在内存中为其建立一个引用，并置初值为null，表示不指向任何内存空间。声明对象以后，需要为对象分配内存，这个过程也称为实例化对象。创建对象后，就可以访问对象的成员变量，并改变成员变量的值了，而且还可以调用对象的成员方法。通过使用运算符“.”实现对成员变量的访问和成员方法的调用。

简述构造方法的特点与作用？

答案是：构造方法是类的一个特殊成员，它会在类实例化对象时被自动调用。而普通方法只有在使用的时候才会被调用。在定义构造方法时要求方法名与类名相同、在方法名的前面没有返回值类型的声明、在方法中不能使用return语句返回一个值

Java中成员方法定义的一般格式是什么？成员方法有哪些修饰符？

答案是：Java中类的行为由类的成员方法来实现。类的成员方法由方法声明和方法体两部分组成。其一般格式如下： [修饰符] <方法返回值的类型> <方法名>( [参数列表]) { [方法体] ｝ [修饰符]用于指定方法的访问权限，可选值为public、protected和private。 方法返回值的类型用于指定该方法的返回值的类型，如果该方法没有返回值，必须使用关键字void进行标识。方法返回值的类型可以是任何Java数据类型。

Java中成员变量定义的一般格式是什么？成员变量有哪些修饰符？

答案是：在类体中所声明的变量称为类的成员变量，而在方法体中声明的变量和方法的参数则称为局部变量。成员变量修饰符private,protect,public public范围最大。 Java用成员变量来表示类的状态和属性，声明成员变量的基本语法格式如下： [修饰符] [static] [final] <变量类型> <变量名>; 修饰符：可选参数，用于指定变量的被访问权限，可选值为public、protected和private。 static：可选，用于指定该成员变量为静态变量，可以直接通过类名访问。如果省略该关键字，则表示该成员变量为实例变量。 final：可选，用于指定该成员变量为取值不会改变的常量。 变量类型：必选：用于指定变量的数据类型，其值可以为Java中的任何一种数据类型。 变量名：必选，用于指定成员变量的名称，变量名必须是合法的Java标识符。

Java中类定义的一般格式是什么？定义类的修饰符有哪些？各自的特点是什么？

答案是：JAVA中定义类的简单语法 [修饰符] class 类名 { 零到多个构造器定义.. 零到多个Field.. 零到多个方法.. } 修饰符可以是public、final、abstract，或省略 public ，使用对象：类、接口、成员；无论它所处在的包定义在哪，该类（接口、成员）都是可访问的 private ，使用对象：成员；成员只可以在定义它的类中被访问 static ，使用对象：类、方法、字段、初始化函数。成名为static的内部类是一个顶级类，它和包含类的成员是不相关的。静态方法是类方法，是被指向到所属的类而不是类的实例。静态字段是类字段，无论该字段所在的类创建了多少实例，该字段只存在一个实例被指向到所属的类而不是类的实例。初始化函数是在装载类时执行的，而不是在创建实例时执行的。 final ，使用对象：类、方法、字段、变量。被定义成final的类不允许出现子类，不能被覆盖（不应用于动态查询），字段值 不允许被修改。 abstract ，使用对象：类、接口、方法。类中包括没有实现的方法，不能被实例化。如果是一个abstract方法，则方法体为空，该方法的实现在子类中被定义，并且包含一个abstract方法的类必须是一个abstract类。 protected ，使用对象：成员。成员只能在定义它的包中被访问，如果在其他包中被访问，则实现这个方法的类必须是该成员所属类的子类。

什么是对象？什么是类？二者有何关系？

答案是：在面向对象语言中，对象是对类的一个具体描述，是一个客观存在的实体。万物皆对象，也就是说任何事物都可看做对象，如一个人、一个动物，或者没有生命体的轮船、汽车、飞机，甚至概念性的抽象，如公司业绩等等。一个对象在Java语言中的生命周期包括创建、使用和销毁3个阶段。 类的概念 : 类是具有相同属性和服务的一组对象的集合。为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分。

简述面向对象的基本思想、主要特征和基本要素?

答案是：面向对象的开发方法（简称OO）的基本思想：OO方法认为，客观世界是由各种各样的对象组成的，每种对象都有各自的内部状态和运动规律，不同的对象之间的相互作用和联系就构成了各种不同的系统。当我们设计和实现一个客观系统时，如能在满足需求的条件下，把系统设计成由一些不可变的（相对固定）部分组成的最小集合，这个设计就是最好的。而这些不可变的部分就是所谓的对象。 对象是OO方法的主体，对象至少应有以下特征： 模块性。即对象是一个独立存在的实体，从外部可以了解它的功能，但其内部细节是“隐蔽”的，它不受外界干扰。对象之间的相互依赖性很小，因而可以独立地被其它各个系统所选用。 继承和类比性。事物之间都有一定的相互联系，事物在整体结构中都会占有它自身的位置。在对象之间有属性关系的共同性，在OO方法学中称之为继承性次结构是靠继承关系维系着的。 对象是一个被严格模块化了的实体，称之为封装（encapsulation）。这种封装了的对象满足软件工程的一切要求，而且可以直接被面向对象的程序设计语言所接受。

5．字符数组与字符串有本质的不同，而字符串实际上是String类和StringBuffer类的对象，这种说法对吗？

答案是：这种说法不对，字符数组与字符串在内存中都是线性分布的的一系列数据，本质上没有不同，只是操作上有点差异。

4．Java中的数组实际上是一个隐含的“数组类”的对象，而数组名实际上是该对象的一个引用，这种说法对吗？

答案是：对。Java中的数组其实是一个对象，是一个特殊的对象。

字符串类String 和StringBuffer类有何不同？

答案是：StringBuffer其实是一个可变的String,通俗点说是长度能够自由变动的字符串。 （1） String类 ，该类一旦产生一个字符串，其对象就不可变。String类的内容和长度是固定的。如果程序需要获得字符串的信息需要调用系统提供的各种字符串操作方法实现。虽然通过各种系统方法可以对字符串施加操作，但这并不改变对象实例本身，而是生成一个新的实例。系统为String类对象分配内存，是按照对象所包含的实际字符数分配的。 （2） StringBuffer类 ，这个类肯定有缓冲的功能。该类处理可变的字符串。如果要修改一个StringBuffer类的字符串，不需要再创建新的字符串对象，而是直接操作原来的串。该类的各种字符串操作方法与String类提供的方法不相同。系统为StringBuffer类分配内存时，除去当前字符所占的空间外，还提供另外的16个字符大小的缓冲区。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。

2．在Java中怎样定义和使用一维数组、二维数组？

答案是：使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，:java中使用 [][] 来定义二维数组 定义数组时也可同时初始化。在java中数组被看成是一个对象，如果用new定义数组时，必须指定其维度，定义二维数组必须指定其行数，列数可以指定，可以不指定。

1．创建数组元素为基本数据类型的数组时，系统都会指定默认值吗？布尔型的默认值是什么？

答案是：java 在声明了一个数组，并为其分配好存储空间后，未赋值之前会默认对其初始化： 整形数组 默认初始值为0； 布尔数组默认初始值为 false； String 数组以及 对象数组初始值为 null.

循环语句有哪几种形式？它们的语法格式是什么样的？

答案是：（1）for循环语句 for语句的语法格式： for (表达式1; 表达式2; 表达式3) { 若干语句 } （2）while 循环 while语句的语法格式： while (表达式) { 若干语句 } （3）do-while循环 do-while语句的语法格式： do { 若干语句 } while(表达式);

试说明Switch语句的格式是如何定义的？

答案是：switch 语句是单条件多分支的开关语句，它的一般格式定义如下(其中break语句是可选的）： switch(表达式) { case 常量值1: 若干个语句 break; case 常量值2: 若干个语句 break; ... case 常量值n: 若干个语句 break; default: 若干语句 }

条件分支语句按语法格式可细分为3种形式，请说明这3种形式的语法格式？

答案是：（1）if语句 if 语句的语法格式： if（表达式）{ 若干语句 } （2）if-else语句 if-else 语句的语法格式： if(表达式) { 若干语句 } else { 若干语句 } （3）if-else if -else 语句 if-else if-else语句的语法格式： if(表达式) { 若干语句 } else if(表达式) { 若干语句 } … … else { 若干语句 }

break语句和continue语句有哪两种形式？

答案是：break语句：在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。 continue语句：continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。 return语句：return语句可以用于从当前的方法中退出，返回到该调用的方法的语句处，继续执行。return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。

3．for循环语句中，关键字for后面括号内的表达式是否可以使用多个用逗号分隔的表达式？for-each语句的特点是什么？

答案是：for 里面只能有2个分号,分割了3个语句。使用 foreach语句是java5的新特征之一,在遍历数组、集合方面,foreach为开发人员提供了极大的方便。

2．while循环语句与do-while循环语句有何不同?

答案是：while语句的一般形式为： while(表达式)语句 其中表达式是循环条件，语句为循环体。 while语句的语义是：计算表达式的值，当值为真(非0)时， 执行循环体语句。 do-while语句的一般形式为: do 语句 while(表达式)； 这个循环与while循环的不同在于:它先执行循环中的语句,然后再判断表达式是否为真, 如果为真则继续循环；如果为假, 则终止循环。因此, do-while循环至少要执行一次循环语句。

1．if语句中，<条件表达式>一定是逻辑型表达式吗? switch语句中，<语句序列>里一定有break语句吗?

答案是：if语句中的表达式不限于逻辑表达式,可以是任意的数值类型。在 switch 语句中使用break语句将终止语句的序列。当遇到 Break语句时，程序将整个 switch 语句后面的一行代码处开始执行，就有一种跳出switch 语句的效果。break 语句是可选的，如果省略掉break 语句程序将执行下一条 case ，如果你需要使用多条 case ，你可以不用没有 break 语句。

Java里的语句可分为哪几类？

答案是：1．方法调用语句 2．表达式语句：表达式尾加上分号。 3．复合语句：可以用{ }把一些语句括起来构成复合语句。 4．空语句：一个分号也是一条语句，称做空语句。 5．控制语句：控制语句分为条件分支语句、开关语句和循环语句。 6．package语句和 import语句：它们和类、对象有关。

Java提供了哪些运算符？

答案是：Java提供了丰富的运算符，具体有： 算术运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、instanceof运算符

Java的基本数据类型是什么？

答案是：Java语言有8种基本数据类型，分别是：boolean、byte、short、int、long、float、double、char。这8种基本数据类型习惯上可分为以下四大类型： 逻辑类型：boolean 整数类型：byte、short、int、long 字符类型：char 浮点类型：float、double

6．在Java转义字符表示中，ASCII码值对应的字符如何表示？Unicode字符集中对应的字符如何表示？

答案是：Java中的字符通过Unicode字符编码，以二进制的形式存储到计算机中，计算机可通过数据类型判断要输出的是一个字符还是一个整数。Unicode编码采用无符号编码，一共可存储65536个字符，所以Java中的字符几乎可以处理所有国家的语言文字。

5．在Java 语言中，表示字符串常量和字符常量时应注意哪些问题？

答案是：声明为字符型的常量或变量用来存储单个字符，它占用内存的2个字节来存储，字符型利用关键字“char”进行声明。

4．整型常量有哪三种表示形式？浮点型变量有哪两种表示形式？布尔型常量可以转换成其他数据类型吗？

答案是：所谓常量，就是值永远不允许被改变的量。声明一个常量，就必须用关键字final修饰。 声明为整数型的常量或变量用来存储整数，整数型包括：字节型（byte），短整型（short） 整型（int），长整型（long）。声明为浮点数型的常量或变量用来存储小数，浮点数包括单精度型（float）和双精度（double）两个基本数据类型，这两个数据类型的区别是它们在内存中所占用的字节数不同，因此，它们所能够存储的整数的取值范围也不同

3．Java定义了哪些基本数据类型？基本数据类型和引用数据类型的特点？字节型和字符型数据有何区别？长度为32位的基本数据类型有哪些？

答案是：Java语言中的数据类型划分为两大类，分别是基本数据类型和引用数据类型。 其中基本数据类型由Java语言定义，不可以再进行划分。基本数据类型的数据占用内存的大小固定，在内存中存入的是数值本身 引用数据类型在内存中存入的是引用数据的存放地址，并不是数据本身。

标识符有何用途？Java中定义标识符的规则有哪些？

答案是：用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。简单地说，标识符就是一个名字。Java关于标识符的语法规则如下： （1）标识符可以由字母、数字、下划线“_”或$组成； （2）标识符必须以字母、下划线“_”或$开头，随后可跟数字； （3）标识符是大小写区别对待的。例如，Class和class代表不同的标识符； （4）在自定义标识符时，应该使其能反映它所表示的变量、对象或类的意义。 为了提高程序的可读性，在定义标识符时，要尽量遵循“见其名知其意“的原则。 Java标识符的具体命名规则如下： 一个标识符可以由几个单词连接而成，以表明它的意思。 对于类名，每个单词的首字母都要大写，其他字母则小写，例如RecordInfo。 对于方法名和变量名，与类名有些相似，除了第一个单词的首字母小写外，其他单词的首字母都要大写，例如getRecordName() 。 对于常量名，每个单词的每个字母都要大写，如果由多个单词组成，通常情况下单词之间用下划线（_）分隔，例如MAX_VALUE。 对于包名，每个单词的每个字母都要小写，例如com.frame。

1．Java的关键字有哪些？

答案是：在Java语言中还定义了一些专有词汇，统称为关键字，例如public、class、int等，它们都具有一种特定的含义，只能用于特定的位置，不能作为标识符使用。

Java代码块的写法有哪两种风格？当代码量较大时应当采用哪种编程风格？

答案是：（1）Allmans风格 Allmans风格也称“独行”风格，即左、右大括号各自独占一行。 （2） Kernighan风格 Kernighan风格也称“行尾”风格，即左大括号在上一行的行尾，而右大括号独占一行 。 当代码量较大时不适合使用“独行”风格，因为该风格将导致代码的左半部分出现大量的左、右大括号，导致代码清晰度下降，这时应当使用“行尾”风格。

当源文件有多个类时，请说明源文件的命名规则？

答案是：Java允许在一个Java源文件中编写多个类，但其中的多个类至多只能有一个类使用public修饰。如果源文件中有多个类，但没有public类，那么源文件的名字只要和某个类的名字相同，并且扩展名是java就可以了；如果有一个类是public类，那么源文件的名字必须与这个类的名字安全相同，扩展名是java。

如果JDK的安装目录为D:\jdk,应当怎么设置path和classpath的值？

答案是：设置环境变量Path的值为D:\jdk\bin; 设置环境变量ClassPath的值为D:\jdk\lib\dt.jar; D:\jdk\lib\tools.jar;

Java源程序的组成？

答案是：1）package语句 2）import语句 3）类（class） 4）方法 5）语句

Java程序的开发步骤

答案是：（1）编写源文件。扩展名必须是.java。 （2）编译Java源程序。使用Java编译器（javac.exe）编译源文件，得到字节码文件。 （3） 运行Java程序。使用Java SE平台中的Java解释器（java.exe）来解释执行字节码文件。

Java语言的特点？

答案是：简单性、面向对象、分布式处理、健壮性、结构中立、安全性、可移植性、解释性、高性能、多线程、动态

目前为： 1/1 页  首页   上页 下页 尾页