JAVA 1-6章测试题

JAVA 1-6章测试题
简答题：
1、JAVA实现跨平台的原理?
答：Java为我们提供了Java虚拟机（JVM），当程序运行时，Java首先将后缀名为.java的源文件转换为.class的字节码文件，然后JVM通过装载二进制文件、校验二进制码、解析、最后分发给不同的平台进行运行。
2、JAVA程序运行的原理?
答：1>Java通过编译把java源文件转换为字节码文件；
2>通过Java虚拟机（即JVM）加载二进制码文件；
3>校验二进制码的正确性；
4>解析二进制码文件；
5>分发给不同的平台进行运行。
3、JAVA中的直接数有几种？分别是什么?
答：有七种直接数，
分别是：int、long、float、double、boolean、char、String。
4、什么叫JAVA中的变量？变量分为几种？
答：Java中的变量就是指在程序运行的过程中可能会变化的值。
变量分为成员变量和局部变量。
5、局部变量与成员变量的区别？
答：局部变量与成员变量的区别：
1>局部变量是定义在类中的方法体中，而成员变量是定义在类中方法体外的；
2>局部变量只能在所定义的方法体中或者代码块中使用，而成员变量在本类中都可以使用。
6、String是基本数据类型吗？
答：不是。String是一个引用类型，它是java.lang包下的一个类(java.lang.String)，是final型的。
7、Char能不能保存一个中文？为什么？
答：可以。因为Java使用的是Unicode编码，支持中文。一个char占2字节16位，而一个中文占16位。
8、&与&&的区别？
答：&&为逻辑与逻辑运算符，而&为逻辑与位运算符。
9、2乘以8的最高效的运算方式是什么？
答：2>>3，意为23是位运算的结果。
10、在JAVA中如何跳出当前的多重嵌套循环？
答：使用标号跳出，例如：A:for(int i=0;i<n;i++){ break A; }。
11、break、continue、return的区别？
答：break：
1>在switch-case语句中，终止一个语句序列；
2>退出一个循环体(break所在的循环全部推出)；
3>可作为一种先进的goto语句；
4>一个循环中可以有一个以上的break语句，但不推荐多使用。
continue：
1>强迫一个循环体提早反复，跳过某一次不重要的；
2>continue只能跳过本次循环的某一次执行。
return
1>在有返回值的方法中必须使用return；
2>return返回到调用它的地方；
3>一个循环体中可以有多个return。
12、swtich否能作用在byte上，是否能作用在long上，是否能作用在String上？
答：在1.6版本中支持，switch语句的返回值类型必须是byte、short、int、char、枚举类型之一。不能作用在long和String上。1.7版本支持String类型。
13、什么叫方法的重载？方法重载的意义？
答：方法的重载就是指在本类中方法名相同而参数列表不同。方法重载可以实现代码的复用。
14、return只能写在方法的结束位置吗？为什么？
答：不是，在多重循环中，可以使用多个return，满足条件提前结束循环。
15、swtich语句支持的表达式可以为变量吗？case中可以为变量吗？
答：switch语句可以支持表达式是变量；但case语句中的值只能是常量（1.6版本中支持byte，short，int，char，枚举类型）。
16、Arrays类是专门负责处理什么的？使用Arrays中的sort方法对数组进行排序的时候要注意些什么？
答：Arrays类是专门负责处理数组的填充、查找、比较、排序等一系列的对数组的操作。
注意事项：
1>数组必须要有规律可循，就是可以进行排序
2>可以对引用类型进行排序，要指定排序规则。可通过Comparator(){}接口来实现。
17、冒泡法、选择法、插入法的排序原理？
答：1>冒泡法：在一组数据序列中，从左端开始将相邻的两个数字进行比较，如果左边的数据比右边的大，则交换其位置，一轮比较完成后，最大的数据会在数据序列最后的位置上“冒出”。
2>选择法：在一组无序的数据序列中，将其最大的数据与最后一个数据进行位置交换，则最后一个数据就排好了位置。再将剩下的为排列的数据中最大的数据与未排序的数据序列最后一个进行交换位置。
3>插入法：将序列分为两堆，用后面一堆的第一个数字和前边所有数据的做比较，如果小于则交换位置。
18、数组的特性是什么？
答：1>数组中的类型都是同类型的
2>数组的大小是确定的
3>数组中的元素可以是基本类型和引用类型
4>数组是引用类型，数组型数据是对象
5>数组是通过操作下标来使用的
19、JAVA中为什么要引入包体的概念？有何作用？
答：通过包可以划分不同的功能类，层次更加明确，可以更好的管理工程。
1>能够区分名称相同的类
2>有助于实施访问权限控制
3>有助于划分和组织Java应用中的各个类
20、递归要注意什么？
答：1>一定要有出口，否则会成为死循环
2>在本方法中自身调用自身
21、面向对象的特征有哪些？详细描述？
答：面向对象具有继承性、封装性、多态性。
1>类是相同属性和方法的封装体，因此类具有封装性；
2>子类可以在继承父类中能够继承的属性和方法的基础上，再增加自己特有的属性和方法，因此类具有继承性；
3>在一个类层次中，定义为父类的对象可被赋值为其任何子类的对象，并根据子类对象的不同而调用不同的方法，因此类具有多态性。
22、静态变量和实例变量的区别？
答：静态变量是指用static关键字修饰的成员变量，他在类装载的时候就进行了初始化，并且永驻内存，可通过类名来访问，不需创建对象；实例变量是指没有用static关键字修饰的成员变量，它只有在类创建对象的时候才初始化，它只能在类创建对象后，通过对象才可以访问。
23、构造函数是一个方法吗？有什么样的特点？
答：构造函数是一个方法。
1>构造方法的名称必须和类名相同；
2>构造方法没有返回类型约定，可以有参数列表，只是为了创建对象而存在，并为对象属性初始化的特殊方法；
3>当我们创建一个类的时候，如果我们不手动添加构造方法，那么系统会自动为我们提供一个默认的不带参的构造方法；如果我们手动添加了构造，则系统不会提供默认的构造了。
4>构造方法可以重载，通过调用不同的构造方法来表达对象的多种初始化行为。构造方法的重载是指定义多个形式参数列表不同的构造方法。
24、this、super的含义？使用的时候要注意什么？
答：1>this是指当前的对象，它是一个变量，在实例方法中解决实例变量与局部变量同名的问题。在类的构造方法中，通过this语句调用这个类的另一个构造方法。
2>Super：如果父类中没有提供无参数的构造方法，那么，我们必须通过super语句指导子类调用父类中的其他构造方法；
3>当子类中的局部变量或成员变量与父类中的成员变量同名时，通过super访问父类的成员变量；
4>当子类中的方法重写了父类中的方法并还需要调用父类中被重写的方法时，通过super访问父类中被重写的方法；5>super与this语句出现在构造方法中必须放在构造方法的第一行，并且不能同时出现；
6>super与this关键字不能出现在类方法、类代码快中；
25、构造器Constructor是否可被override（重写）？
答：构造方法不能被重写，但可以重载。因为构造方法不能被继承，而方法的重写是发生在继承关系下的，所以构造方法不能被重写。
26、构造函数的作用是什么？
答：构造函数是为了创建对象而存在，并为对象属性初始化的特殊方法。
27、详细叙述在创建一个类的对象的时候的内部过程？
答：1>类通过new关键字和构造方法创建对象
2>使用new开辟堆内存空间，并初始化
3>类中的属性保存在了堆内存中
4>创建的对象保存在了栈内存中
28、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？
答：是值传递，传递的是引用地址的首地址。
29、说出目前常用的类，包，接口，请各举几个？
答：Object类、Arrays类、java.util包、java.lang包……
30、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型？
答：1>都要求方法名相同，都可以用于抽象方法和非抽象方法之间
2>重写要求参数列表必须一致，而重载要求参数列表必须不一致
3>重写要求返回类型必须一致，而重载对此不做限制
4>重写只能用于子类重写父类的方法，而重载用于同一个类的所有方法（包括从父类中继承而来的方法）
5>重写对方法的访问修饰符有特殊要求，而重载对此不做限制
6>父类的一个方法只能被同一个子类重写一次，而一个方法在所在的类中可以被重载多次
7>构造方法能被重载，但不能被重写
31、谈谈final的含义？
答：1>final是不可改变的意思，当一个变量被定义为final型时，它就成了一个常量且必须初始化；
2>当一个类被定义为final型时，这个类不能被继承；
3>当一个方法被定义为final型时，这个方法可以被继承，但不能再被改写。
32、abstract class和interface有什么区别？
答：1>抽象类只能单继承，抽象方法是以abstract修饰的，只声明返回类型、方法名称、参数列表、没有方法体；
2>并且抽象类中不一定有抽象方法，但有抽象方法的类必须申明为抽象类；
3>抽象类不能被实例化，但是它有构造方法；
4>抽象类不能配合final修饰符。
5>修饰抽象方法时，abstract不能和private、static、final、native并列修饰同一个方法。Static修饰的方法是不能被重写的。
1>接口：在java中类支持单继承、多实现，而接口与接口2 之间支持多继承；
2>在接口中生命成员变量一定要初始化值为常量；
3>接口中没有构造函数，所以不可能创建实例；
4>一个类可以同时实现多个接口；
5>实体类在实现接口后，将拥有接口中的所有的静态常量和方法；
6>接口的修饰符只有两种：public和缺省；
33、在创建子类的对象时，是否生成父类的对象？通过什么来实现的？
答：不生成父类的对象。通过super关键字来实现。
34、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)？
答：接口可以继承接口；抽象类可以实现接口；抽象类可以继承实体类。
35、是否可以直接从一个static方法内部发出对非static方法的调用？为什么？
答：不能。静态方法在类装载时已经加载了，而非static方法只有在创建对象时才初始化，没有初始化是不能使用的。
36、内部类的作用是什么？体现在哪里？详细叙述。
答：1>内部类可以很好的实现隐藏，一般的非内部类，是不允许有private与protected权限的，但内部类可以；
2>内部类拥有外围类的所有元素的访问权限；
3>可以实现多重继承；
4>可以避免因修改接口而实现同一个类中两种同名方法的调用。
37、匿名内部类的本质是什么？
答：1>匿名内部类的本质就是重写父类或接口的方法。
2>匿名内部类的本质就是，在保证原有的应用不变的情况下，想进行局部的改变，而进行使用的。
38、使用接口有何作用？
答：1>可以实现多重继承；
2>可以实现类的多实现；
3>使用接口有利于软件层次结构的划分，有利于后期的维护和升级；
4>让设计和实现分离，降低耦合性；
39、类的修饰符有哪些？各自代表的含义？
答：普通类：public、默认、abstract、final
内部类：public、protected、static、private、abstract、final；访问权限的控制和方法是一样的。
Public：可以在整个项目中使用
Protected：只能在本包中和继承关系中使用
默认：只能在本包中使用
Private：只能在本类中使用
Abstract：抽象类，需要继承关系实现
Final：最终的类，不能被继承的类
Native：本地的，不是Java语言书写的
40、成员的修饰符有哪些？各自代表的含义？
答：成员变量：public、protected、默认、private、static、final
Public：可以在整个项目中使用
Protected：只能在本包中和继承关系中使用
默认：只能在本包中使用
Private：只能在本类中使用
Static：不用创建实例就可以使用的类的变量
Final：最终成员变量，不可以改变的常量
成员方法：public、static、private、protected、abstract、final、synchronized、native
Public：可以被其他任何类访问
Static：不用创建实例就可以使用，通过类名.就可以调用
Private：在该类中可以访问该方法
Protected：子类可以访问，同包中也可以访问
Abstract：抽象的方法，无方法体
Final：最终方法，可以被继承，但不能被改写
Synchronized：基于线程安全机制，加锁执行
Native：集成其他语言的代码，在java中没有代码体
默认：系统默认只能在同一个包中访问该方法
41、类、抽象类、接口之间的关系？
答：类可以继承类，类可以继承抽象类，抽象类可以继承类，抽象类可以继承抽象类，接口可以（多）继承接口，类可以实现接口，抽象类也可以实现接口。
42、方法重写的注意事项有哪些？
答：1>方法重写只存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中的方法只能被重载，不能被重写。
2>子类方法必须和父类方法具有相同的方法名、参数列表和返回值
3>子类可以定义与父类的类方法同名的类方法，以便在子类中隐藏父类的类方法
4>父类中的类方法不能被子类重写成实例方法，而父类的实例方法也不能被子类隐藏为类方法
5>父类中的private、final修饰的方法不能被重写；子类方法不能缩小父类的访问权限；子类方法不能抛出比父类方法更多的异常。
43、抽象类的特点有哪些？
答：1>被abstract修饰，不能被实例化；
2>抽象类可以包含抽象方法；
3>抽象类的子类也可以是抽象类；
4>继承抽象类的非抽象类，必须实现超类中的全部抽象方法
44、对于定义在方法体中的内部类，在内部类中使用方法中的变量的时候，有没有什么特殊的要求？为什么？
答：有。
1>方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
2>方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
45、final修饰的方法能不能被继承？
答：可以被继承，但不能被修改。
46、静态代码块、实例代码块、构造函数的运行顺序？为什么？
答：静态代码块最先运行，然后是实例代码块，最后是构造函数。因为静态代码块是属于类的，所以在类加载时就运行了。
Java虚拟机创建一个对象都包含以下步骤：
1>给对象分配内存
2>将对象的实例变量自动初始化为其变量类型的默认值
3>初始化对象，给实例变量赋予正确的初始值或执行实例代码块
4>调用相关的构造方法
47、继承的作用是什么？
答：继承是面向对象的特征之一，是复用程序代码的有力手段，当多个类之间存在相同的属性和方法时，可以从这些类中抽象出一个作为父类。
48、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
答：Math.round(11.5)=12.0；Math.round(-11.5)=-11.0
49、数组有没有length()这个方法? String有没有length()这个方法？
答：都有。数组的length() 方法是求数组的长度的，而String的length()的方法是求字符串的个数的。
50、类中完全是实现了的方法，能否将本类声明为一个抽象类？为什么？
答：可以。抽象类可以没有抽象方法，但含有抽象方法的类必须申明为抽象类。
51、静态内部类可以有静态成员，而非静态内部类则不能有静态成员对吗？为什么？
答：对！因为静态的成员在类装载的时候和类一起加载，然而非静态内部类相当于类的局部变量一样，在创建对象的时候才初始化，所以非静态内部类不能有静态成员。
52、何为javabean？什么叫标准的javabean，有何作用？
答：我们手动的创建的一个类都是javabean，标准的javabean是指类和方法都是私有的。
53、= = 和equals的用途解释？
答：1>如果“<mark>”的两边是基本数据类型，表示判断基本数据类型的数值是否相同；
2>如果“</mark>”两边是引用数据类型，比较引用类型是否引用同一个对内存的地址；
3>“equals”，如果使用的是object类中的equals方法，那么就等同于“==”，比较的是引用内存的地址；
4>“equals”，如果是改写后的equals方法，则遵循的是改写后的规则。
54、静态变量、实例变量、局部变量的声明周期及初始化过程介绍？
答：静态变量：类的静态变量在内存中只有一个，Java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被所有类的实例共享。静态变量可以通过类名访问。静态变量的生命周期取决于类的生命周期。
实例变量：类的每个实例都有相应的实例变量，每创建一个类的实例，Java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中。实例变量的生命周期取决于实例的生命周期。
局部变量：局部变量的生命周期，取决于所属的方法何时被调用及结束调用。当JVM中的某个线程调用一个方法时，会为这个方法中的局部变量分配内存；当JVM中的某个线程结束调用一个方法时，会结束这个方法中的局部变量的生命周期。
55、目前我们学到运行时异常列举,至少5个以上？
答：空指针异常：java.NullPointerExcetion
类型匹配异常：
指针溢出异常：java.lang.ArrayIndexOutBoundsException

编程题：
1、使用冒泡法、选择法、插入法完成对数组的排序功能。
冒泡法：
public class SortMaoPao {
// 冒泡法排序
// 在一组数据序列中，从左端开始将相邻的两个数字进行比较，如果左边的数据比右边的大，则交换其位置，
// 一轮比较完成后，最大的数据会在数据序列最后的位置上“冒出”。
public static void main(String[] args) {
int[] is = { 5, 8, 3, 12, 24, 30, 18, 1, 10, 13 };
for (int i = 0; i < is.length - 1; i++) {
int stemp = 0;
for (int j = 0; j < is.length - 1; j++) {
if (is[j] > is[j + 1]) {
stemp = is[j + 1];
is[j + 1] = is[j];
is[j] = stemp;
}
}
System.out.println(java.util.Arrays.toString(is));
}
System.out.println(java.util.Arrays.toString(is));
}
}

选择法：
public class SortXuanZe {
// 选择法排序
// 在一组无序的数据序列中，将其最大的数据与最后一个数据进行位置交换，则最后一个数据就排好了位置。
// 再将剩下的为排列的数据中最大的数据与未排序的数据序列最后一个进行交换位置。
public static void main(String[] args) {
int[] is = { 5, 8, 3, 12, 24, 30, 18, 1, 10, 13 };
for (int i = 0; i < is.length; i++) {
int max = 0;
for (int j = 1; j < is.length-i; j++) {
if (is[j] > is[max]) {
max = j;
}
int stemp = is[max];
is[max] = is[is.length - i - 1];
is[is.length - i - 1] = stemp; System.out.println(java.util.Arrays.toString(is));
}
}
System.out.println(java.util.Arrays.toString(is));
}
}

插入法：
public class SortChaRu {
// 插入法排序
// 将序列分为两堆，用后面一堆的第一个数字和前边所有数据的做比较，如果小于则交换位置。
public static void main(String[] args) {
int[] is = { 5, 8, 3, 12, 24, 30, 18, 1, 10, 13 };
for (int i = 0; i < is.length - 1; i++) {
for (int j = i; j >= 0; j–) {
if (is[j + 1] < is[j]) {
int stemp = is[j + 1];
is[j + 1] = is[j];
is[j] = stemp;
}
}
}
System.out.println(java.util.Arrays.toString(is));
}
}
2、使用二维数组输出杨辉三角。
import java.util.Scanner;
public class YangAngle {
// 杨辉三角
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入组数：”);
int group = sc.nextInt();
int[][] s = new int[group][];
for (int i = 0; i < s.length; i++) {
s[i] = new int[i + 1];
for (int j = 0; j <=i; j++) {
if (j == 0 || j == i) {
s[i][j] = 1;
} else {
s[i][j] = s[i - 1][j] + s[i - 1][j - 1];
}
System.out.print(s[i][j] + “\t”);
}
System.out.println();
}
}
}
3、求1! + (1!+2!) + …… +(1!+2!+3!+4!+5!)的值。
public class JC {
//求1! + (1!+2!) + …… +(1!+2!+3!+4!+5!)的值。
public static void main(String[] args) {
int sum = 0;
int stemp = 0;
for (int i = 1; i <= 5; i++) {
int item = 1;
for (int j = 1; j <= i; j++) {
item *= j;
}
stemp += item;
System.out.println(stemp);
sum += stemp;
}
System.out.println(“1! + (1!+2!) + …… +(1!+2!+3!+4!+5!)=”+sum);
}
}
4、求出100以内的素数之和。

public class PrimeSum {
// 100以内的素数之和 1不是素数
public static void main(String[] args) {
int sum = 2;
for (int i = 3; i <=11; i++) {
for (int j = 2; j <i; j++) {
if(i%j<mark>0&&i>j){
break;
}
if(i%j!=0&&i</mark>j+1){
sum+=i;
}
continue;
}
}
System.out.println(“100以内的素数之和为：” + sum);
}
}
5、使用两种方案完成单态模式。
1>第一种单态：饿汉式
利用的是static的特性（提前初始化，并且只是初始化一次，保存一份，永驻内存）
public class SingleOne {
// 使用的是static的属性—>初始化一次，永驻内存。
private static SingleOne singleone = new SingleOne();
// 定义一个活的singleone的对象的方法—>提供给外部进行获得SingleOne类的对象。
public static SingleOne getInstance() {
return singleone;
}
// 手动定义一个private方法
private SingleOne() {
}
}
2>第二种单态：懒汉式
public class SingleTwo {
private static SingleTwo singletwo = null;
// 提供一个对外可以获得当前这个类的对象的方法
public synchronized static SingleTwo getInstance() {
if (singletwo == null) {
singletwo = new SingleTwo();
}
return singletwo;
}
private SingleTwo() {
}
}
6、计算10000以内的完全数。

public class AllNum {
//10000以内的完全数。
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <i; j++) {
if (i%j<mark>0) {
sum+=j;
}
}
if(sum</mark>i){
System.out.println(“10000以内的完全数有：”+i);
}
sum=0;
}
}
}