Java语法基础篇选择题练习

Java选择题练习：数组（牛客网）

1.假设一个 list初始化为{2，9，5，4，8，1}。 在第一轮冒泡排序后，list变成了（）?

• 正确答案: D
  A 2, 9, 5, 4, 8, 1
  B 2, 9, 5, 4, 1, 8
  C 2, 5, 9, 4, 8, 1
  D 2, 5, 4, 8, 1, 9

解析：冒泡排序：将最大值放到末尾，一直缩小范围到第一位。

2.若有定义"char a [10]， *p=a; ”，那么下列赋值语句正确的是( )。

• 正确答案: D
  A a [] =“abcdefg”;
  B a=”abedefg";
  C *p=”abcdefg";
  D p=”abcdefg ";

解析：将字符串赋值给字符数组：
1.定义时直接用字符串赋值。 char a[10]＝"hello";但是不能先定义再赋值，即以下非法：char a[10];a[10]＝"hello";
2.利用strcpy。 char a[10]; strcpy(a,“hello”);
3.利用指针。 char *p; p＝"hello";这里字符串返回首字母地址赋值给指针p。另外以下非法：char a[10]; a＝"hello"; a已经指向在堆栈中分配的10个字符空间，不能再指向数据区中的"hello"常量。可以理解为a是一个地址常量，不可变，p是一个地址变量。
4.数组中的字符逐个赋值。

3.将一个n×n的对称矩阵A的下三角部分按行存放在一个一维数组B中，A[0][0]存放在B[0]中，那么第i行的对角元素A[i][i]在B中的存放位置是( )

• 正确答案: A
  A (i+3)×i/2
  B (i+1)×i/2
  C (2n-i+1)×i/2
  D (2n-i-l)×i/2

解析：
B[0] = A[0][0]，i=0，在第0个位置，ABCD均符合
B[2] = A[1][1] ，i=1，在第2个位置，只有A符合
再试一下B[5] = A[2][2]，i=2，在第5个位置，也只有A符合

4.以下二维数组声明合法的是（ ）

• 正确答案: C
  A char[2][3] ch = new char[][]
  B char[2][] ch = new char[][3]
  C char[][] ch = new char[2][3]
  D char[][] ch = new [2]char[3]

解析：定义数组，等号左边不能出现数字，也就是数组的不管什么大小 不能出现在左边

5.( )数组A[8][10] 中（下标均从0开始）， 每个元素的长度为3个字节，按列存储时，元素A[4][7]的起始地址为（SA为数组存储时的首地址）

• 正确答案: C
  A SA+141
  B SA+222
  C SA+180
  D SA+225

解析：
数组总共8行10列，要找的元素在第5行第8列，数组按列存储。
因此要找的元素首地址为：SA+3*(8-1)8+3(5-1) = SA+180。

6.一维数组与线性表的区别是( )。

• 正确答案: A
  A 前者长度固定,后者长度可变
  B 后者长度固定,前者长度可变
  C 两者长度均固定
  D 两者长度均可变

解析：数组的长度是固定不变的，数组是线性表的一种。而线性表有多种形式，其长度可变。

7.int (*p)[3] p的含义是什么?

• 正确答案: B
  A 一个指向int元素大小为3的指针数组
  B 一个指向元素个数为3的int数组的指针
  C 不合法
  D 以上说法都不正确

解析：
1、int(*p)[4];------ptr为指向含4个元素的一维整形数组的指针变量（是指针）
2、int p[4];-------定义指针数组p，它由4个指向整型数据的指针元素组成（是数组）
3、int()[4];--------实际上可以看作是一种数据类型。也就是第一个（int(*p)[4];）

8.针对以下代码，哪些选项执行后是true的：（）

class CompareReference{
   public static void main(String [] args){
   float f=42.0f;
   float f1[]=new float[2];
   float f2[]=new float[2];
   float[] f3=f1;
   long x=42;
   f1[0]=42.0f;
  }
}

• 正确答案: B C
  A f1 == f2
  B x == f1[0]
  C f1 == f3
  D f2==f1[1]

解析：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。

9.对以下二维数组的正确声明是（ ）

• 正确答案: C
  A int a[3][];
  B float a(3,4)
  C double a[][4];
  D float a(3)(4);

解析：数组存储数据是行优先存储，如果只定义行不定义列数组存储就没有界限。给出总元素个数，行数等于总元素对列数取整。编辑器会根据列数去计算行数，但不会根据行数去计算列数

10.在一个长度为n的顺序表中删除第i个元素，要移动_______个元素。如果要在第i个元素前插入一个元素，要后移_________个元素。

• 正确答案: A
  A n-i，n-i+1
  B n-i+1，n-i
  C n-i，n-i
  D n-i+1，n-i+1

解析：
删除第i个元素，要移动后面n-i个元素
在第i个元素之前插入，要移动包括i在内的n-i+1个元素

11.设有数组A[i,j],数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当用以列为主存放时，元素A[5,8]的存储首地址为()。

• 正确答案: A
  A BA+180
  B BA+225
  C BA+222
  D BA+141

解析：
1 2 3 4 5 6 7 8 9 10
1 前 前 前 前 前 前 前 前 后 后
2 前 前 前 前 前 前 前 前 后 后
3 前 前 前 前 前 前 前 前 后 后
4 前 前 前 前 前 前 前 前 后 后
5 前 前 前 前 前 前 前 这里 后 后
6 前 前 前 前 前 前 前 后 后 后
7 前 前 前 前 前 前 前 后 后 后
8 前 前 前 前 前 前 前 后 后 后
计算A[5,8]的地址就等于计算在 A[5,8]之前（“前”）保存的所有变量的地址偏移量 。
（（7*8+5）-1）*3 = 180

12.将数据元素2,4,6,8, 10, 12, 14, 16, 18,20, 22依次存放于一个一维数组中，然后采用折半查找方法查找数组元素16,被比较过的数组元素的轨迹依次为（）

• 正确答案: A
  A 12,18,14,16
  B 12,14, 18,16
  C 6,9,7,8
  D 6,7,9,8

解析：一维数组str[]：
下标 0 1 2 3 4 5 6 7 8 9 10
值 2 4 6 8 10 12 14 16 18 20 22
折半查找的实现过程：先确定查找的所在范围，然后逐渐缩小这个范围，直到找到该记录或查找失败（查无该记录）为止
设指针low，high分别指向查找范围的上界和下界，指针mid指向查找范围的中间位置，即 mid = (low + high) / 2
Step 1：low = 0, high = 10, mid = (low + high) / 2 = 5, 被比较过的数组元素为 str[5] = 12
key = 16 > 12, low = mid + 1 = 6, high = 10
Step 2：mid = (low + high) / 2 = 8, 被比较过的数组元素为str[8] = 18
key = 16 < 18, low = 6, high = mid - 1 = 7
Step 3：mid = (low + high) / 2 = 6, 被比较过的数组元素为str[6] = 14
key = 16 > 14, low = mid + 1 = 7, high = 7
Step 4：mid = (low + high) / 2 = 7, 被比较过的数组元素为str[7] = 16
key = 16, 查找成功
被比较过的数组元素的轨迹依次为 12，18，14，16

13.假设 8 行 10 列的二维数组a[1…8 ， 1…10] 分别以行序为主序和以列序为主序顺序存储时，其首地址相同，那么以行序为主序时元素 a[3 ， 5] 的地址与以列序为主序时() 元素相同。注意：第一个元素为a[1][1]

• 正确答案: D
  A a[7，3]
  B a[8，3]
  C a[3，4]
  D ABC都不对

解析：
假设以行存储和以列存储的首地址都是1，由于行和列的下标都是从1开始的：
所以a[3,5]以行存储的地址为：(3-1)10+5=25;// （i-1)10+j
要是以列存储，那么其地址表达式为：i+(j-1)8
A 选项带入得到：7+28=23；
B：8+28=24；
C：3+38=27；
所以根本没有答案，选D，要选的话应该是a[1,4]//1+（4-1）*8=25

14.若有说明：int a[10];，则对数组元素的正确引用是（ ）。

• 正确答案: D
  A a[10]
  B a[3,5]
  C a(5)
  D a[10-10]

解析：
A题目说的是数组元素，只有0-9，所以没有a[10] ，范围太大，无法确定是某一个数组元素，越界了
B中逗号表达式为最后一个，但是数组里面不适用
C不是数组的引用方式
D中a[10-10]相当于a[0],可以

15.有一个用数组C[1…m]表示的环形队列，m为数组的长度。假设f为队头元素在数组中的位置，r为队尾元素的后一位置（按顺时针方向）。若队列非空，则计算队列中元素个数的公式应为？

• 正确答案: A
  A (m+r-f)mod m
  B r-f
  C (m-r+f) mod m
  D (m-r-f) mod m
  E (r-f) mod m
  F 需要判断边界

解析：

1. 若f<r<=m, 则有r-f <m，即队尾没有超出边界，则为r-f;
2. 若r<f<=m, r-f < 0, 即队尾超出边界m，那么应为m+r -f;

综合两种情况，得到答案 (m+r-f) mod m

16.关于下面代码 int[] x=new int[25]; 描述正确的是（）

正确答案: C
A x[25]存放了数据“\0”。
B x[24] 存放了数据“\0”。
C 若访问x[25]，程序将抛出异常。
D x[1]访问此数组的第一个元素。

解析：
A:不存在x[25] 索引从0开始到length-1
B:x[24] 存的是默认值0(java中没有’\0’这一说)
C:超出内存 正确
D:第二元素

17.若有定义：byte[]x={11,22,33,﹣66}；其中0≤k≤3，则对x数组元素错误的引用是（）

• 正确答案: C
  A x[5-3]
  B x[k]
  C x[k+5]
  D x[0]

解析：下标越界问题：数组中有4个元素，小标范围为0~3
A: x[5-3]，小标为2 √
B: x[k], k的范围0~3 √
C: x[k+5], 小标范围为5~8 越界×
D: x[0], 小标为0 √

18.java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（）

• 正确答案: A
  A 正确
  B 错误

19.下列说法正确的有（）

• 正确答案: A
  A 数组是一种对象
  B 数组属于一种原生类
  C int number=[]={31,23,33,43,35,63}
  D 数组的大小可以任意改变

解析：原生类是指Java中，数据类型分为基本数据类型（或叫做原生类、内置类型）和引用数据类型。

20.关于java中的数组，下面的一些描述，哪些描述是准确的：（）

• 正确答案: A C F
  A 数组是一个对象，不同类型的数组具有不同的类
  B 数组长度是可以动态调整的
  C 数组是一个连续的存储结构
  D 一个固定长度的数组可类似这样定义：int array[100]
  E 两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
  F java中不存在 int * a这样的东西做数组的形参

解析：.
1.数组其实也是一个对象，在一个数组中，所有的数组元素都具有相同的数据类型。当然，由于java是面向对象的语言，而类与类支持继承关系，这样可能在父类类型的数组里存放了不同的子类类型元素。
2.定义一个一维数组的方式是：type[] arrayname或者type arrayname[];
3.一维数组的初始化：
（1）静态初始化
1）int[] arr = new int[]{1, 2, 3}
2）int[] arr = {1, 2, 3}
（2）动态初始化
int[] arr = new int[3];
4.没有***数组
如果从数组底形的运行机制来看，数组其实是一个引用，这个引用指向真实的数组内存。数组元素的类型也可以是引用，把之前的type换成int[]，那么上面的定义数组的语法就是int [][] arrName,这样似乎就是定义了二维数组。但他的实质还是一维数组，只是数组元素也是引用。

21.已知int a[]=new int[10]，则下列对数组元素的访问不正确的是（）

• 正确答案: D
  A a[0]
  B a[1]
  C a[9]
  D a[10]

解析：数组的角标是从0开始的。从arr[0]到arr[arr.length-1]。

22.关于Java中的数组，下面的一些描述，哪些描述是准确的：（ ）

• 正确答案: A C F
  A、数组是一个对象，不同类型的数组具有不同的类
  B、数组长度是可以动态调整的
  C、数组是一个连续的存储结构
  D、一个固定长度的数组可类似这样定义: int array[100]
  E、两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
  F、可以二维数组，且可以有多维数组，都是在Java中合法的

解析：
数组是在堆内存中存储，称之为是一个数组对象，对象是有类决定的；
当数组一旦定义出来，其长度不可变，存储空间的内容是可变的；
int[] array=new int [100]; int array[]=new int [100];//正确的定义
查看源码可以知道数组的equals方法是object的equals，比较的是内存地址。

Java选择题练习：运算符（牛客网）

1.下面的程序 编译运行后，在屏幕上显示的结果是（）

public class test {

public static void main(String args[]) {

int x,y;

x=5>>2;

y=x>>>2;

System.out.println(y);
}
}

正确答案: A
A、0
B、2
C、5
D、80

解析：
5的二进制是0101。
x=5>>2 （>>带符号右移）
将0101右移2位，为：0001。
y=x>>>2（>>>无符号右移，左边空缺补充为0）
将0001右移2位，补0。
结果为：0000。
所以得出答案0

2.有如下代码：请写出程序的输出结果。

public class Test
{
    public static void main(String[] args)
    {
        int x = 0;
        int y = 0;
        int k = 0;
        for (int z = 0; z < 5; z++) {
            if ((++x > 2) && (++y > 2) && (k++ > 2))
            {
                x++;
                ++y;
                k++;
            }
        }
        System.out.println(x + ”” +y + ”” +k);
    }
}

正确答案: B
A 432
B 531
C 421
D 523

解析：
z=0时候，执行++x > 2，不成立，&&后面就不执行了，此时 x=1，y=0,k=0;
z=1时候，执行++x > 2，还不成立 ，&&后面就不执行了，此时 x=2，y=0,k=0;
z=2时候， 执行++x > 2，成立，继续执行 ++y > 2， 不成立 , &&后面就不执行了, 此时 x=3，y=1,k=0;
z=3时候，执行++x > 2，成立，继续执行++y > 2，不成立 , &&后面就不执行了, 此时 x=4，y=2,k=0;
z=4 时候，执行++x > 2，成立，继续执行 ++y > 2， 成立 , 继续执行k++>2 ,不成立，此时仍没有进入for循环的语句中， 但此时 x=5，y=3,k=1;
z=5时候，不满足条件了，整个循环结束，所以最好打印时候： x=5，y=3,k=1;

3.下面语句正确的是（）

正确答案: D
A x+1=5
B i++=1
C a++b=1
D x+=1

解析：D：x+=1，既x=x+1。

4.下面代码运行结果是？

public class Test{
static{
   int x=5;
}
static int x,y;
public static void main(String args[]){
   x--;
   myMethod( );
   System.out.println(x+y+ ++x);
}
public static void myMethod( ){
  y=x++ + ++x;
 }
}

正确答案: D
A compiletime error
B prints:1
C prints:2
D prints:3
E prints:7
F prints:8

解析：
D.1.JVM加载class文件时，就会执行静态代码块，静态代码块中初始化了一个变量x并初始化为5，由于该变量是个局部变量，静态代码快执行完后变被释放。
2.申明了两个静态成员变量x，y，并没有赋初值，会有默认出值，int类型为0，
3.执行x–操作，变量单独进行自增或自减操作x–和--x的效果一样，此时x变为了-1
4.调用MyMethod()方法，在该方法中对x和y进行计算，由于x和y都是静态成员变量，所以在整个类的生命周期内的x和y都是同一个
5.y=x++ + ++x可以看成是y=(x++)+(++x)，当++或者–和其它变量进行运算时，x++表示先运算，再自增，++x表示先自增再参与运算
所以就时x为-1参与运算，然后自增，x此时为0，++x后x为1，然后参与运算，那么y=-1+1就为0，此时x为1
6.执行并打印x+y + ++x运算方式和第5步相同，最后计算结果就为3.

5.设int x=1,float y=2,则表达式x/y的值是：（）

正确答案: D
A 0
B 1
C 2
D 以上都不是

解析：
本题的意义在于两点，明白这两点之后题会不会本身就不重要了：①float x = 1；与float x = 1.0f，这两种对于float类型的变量来说定义的方式都是正确的，也是比较常见的笔试题里面考察类型转换的例子，当第一种情况时，是将低精度int向上转型到float，是由于java的特性导致而不需要进行强制转换，而第二种情况则是比较正式的对于float变量的定义，由于这种类型本身在工作项目中并不常见，常用的带小数的数字我们一般都直接使用double类型，而double类型直接定义是没有问题的：double x = 1.0。而由于float的精度没有double类型高，因此必须对其进行显示的格式书写，如果没有这个f，就默认是double类型了。当然double x = 1.0d也是正确的命名，不信你可以尝试，虽然这是一个令人窒息的操作。②当多个精度的数字同时进行运算时，最终结果以最高精度为准。在多数情况下，整数和小数的各级混合运算中，一般结果都是double类型的。但就本题而言，结果是float类型的，因为x，y两个数字精度最高的就是float，所以最终结果是0.5，并且这个0.5是float类型的。为什么说不是double类型呢，当然如果你这样处理：double m = x/y，当然m是double类型的，也不会报错，而如果你写成int m = x/y，编译器报错提示的时候就会让你转换成float或者进行强制转换成int，他是不会提示你转换成double的，尽管这么写并没有报错，原因就是①
中所说的向上强转。float转换成double不需要任何提示。

6.下列语句序列执行后，输出结果是（）

public class ex{
	public static void main(String[]args){
		int a=13;
		a=a/5；
		System.out.println(a);
	}
}

正确答案: B 你的答案: B (正确)
A 1
B 2
C 3
D 4

解析：13/5取商为2，然后再赋值给a,所有输出a=2。

7.如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）

int i=0;
int j=0;
if((++i>0)||(++j>0))
{
//打印出i和j的值。
}

正确答案: D
A i=0;j=0
B i=1;j=1
C i=0;j=1
D i=1;j=0

解析：++i先自增再运算，i++先运算在自增，所以i=1。||短路前一部分不正确就不会继续执行，所以j=0.

8.以下代码段执行后的输出结果为

public class Test {
	public static void main(String args[]) {
		int i = -5;
		i =  ++(i++);
		System.out.println(i);
	}
}

正确答案: C
A -7
B -3
C 编译错误
D -5

解析：
这题编译错误在于这一句： i = ++(i++);
++（ ） 括号里面必须是一个变量，而 i ++ 是一个字面量。

9.关于下面程序 ThisTest .java 运行结果 说法正确的是 ： ( )

public class ThisTest {
    		public static void main(String args[]) {
        		String x="7";       
    	int y = 2;
        		int z=2;              
        System.out.println(x+y+z); 
    		}  
}

正确答案: B 你的答案: A (错误)
A 11
B 722
C 22
D 程序有编译错误

解析：

10.（）运算符和（）运算符分别把一个值的位向左和向右移动

正确答案: A B
A <<
B >>
C &&
D ||

11.（）运算符把其操作数中所有值为0和所有值为1的位分别在结果的相应中设置1和0

正确答案: D
A &
B |
C ！
D ~

解析：
&与操作；
|或操作；
！非操作；
~取反操作；

12.下面是findSum（int m.int n）方法的定义，方法调用findSum（1，5）的返回结果是( )

int findSum（int m, int n）{
    int sum=0；
    for（int i=m；i<=n；i++）{
        sum+=i；
    }
    return sum；
}

正确答案: D
A 1
B 5
C 10
D 15

解析：for(i=1;i<=5;i++) 这样理解就好了，sum是1+2+3+4+5；

13.下列代码的执行结果是：（ ）

public class Test3{
 public static void main(String args[]){
    System.out.println(100%3);
    System.out.println(100%3.0);
 }
}

正确答案: B
A、1和1
B、1和1.0
C、1.0和1
D、1.0和1.0

解析：大数据类型与小数据类型做数值运算时——

• 小的数据类型会自动转为大数据类型，无无需强转。 （小转大——类型声明）
• 大的数据类型转为小的数据类型，必须强转，但是可能会丢失内容 （大转小——强转）

第一个，没有牵扯到不同类型之间的运算，所以还是 1；
第二个，int对double取余，自动会转换为double类型，所以是 1.0。

14.以下表达式的类型和值是什么？（注意整数除法）（）

-5 + 1/4 + 2*-3 + 5.0

正确答案: D
A、int -3
B、int -4
C、double -5.5
D、double -6.0

解析：Java中 / 是取整，在Java中5.0是double类型,所以结果的数据类型为double。因为1/4结果为0，所以结果为-6.0

15.以下JAVA程序代码的输出是

public static void main(String args[]) {
    System.out.println(17^5);
}

正确答案: C
A、12
B、22
C、20
D、1419857

解析：位异或运算符号。
运算规则是：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。
17：0001 0001
5： 0000 0101
结果：0001 0100 转10进制：20

Java选择题练习：常量变量（牛客网）

1.在jdk1.5之后，下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

正确答案: B
A true,false
B true,true
C false,true
D false,false
E 对于不同的环境结果不同
F 程序无法执行

解析：
本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上），下面的讨论都不针对新开辟对象的情况：
1、基本型和基本型封装型进行“”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

2.可以将布尔值与整数进行比较吗 ？

正确答案: B
A 可以
B 不可以

解析：不是一个类型

3.以下哪几种是java的基本数据类型

正确答案: B C
A String
B int
C boolean
D Double

解析：Double在java.lang包，是double的一个包装类，不是基本数据类型

4.枚举（enum）属于原始数据类型（primitive type）。

正确答案: B
A 正确
B 错误

解析：在Java中，变量有两种类型，一种是原始类型，一种是引用类型。
原始类型一共有8种，它们分别是char,boolean,byte,short,int,long,float,double。在Java API中，有它们对应的包装类，分别是(首字母大写)Character,Boolean,Byte,Short,Integer,Long,Float,Double(char,int的变化稍微大点)。

JAVA JVM对于不同的原始类型会分配不同的存储空间，具体分配如下：

• byte : 1个字节 8位 最大值: 127 (有符号)

• short : 2个字节 16位 32767

• int : 4个字节 32位 2147483647

• long: 8个字节 64位 9223372036854775807

• float: 4个字节 32位 3.4028235E38

• double:8个字节 64位 1.7976931348623157E308

枚举（enum）类型是Java 5新增的特性，它是一种新的类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示，是特殊的类，可以拥有成员变量和方法。

5.程序中常采用变量表示数据，变量具有名、地址、值、作用域、生存期等属性。关于变量的叙述，（）是正确的。

正确答案: A C D
A 根据作用域规则，在函数中定义的变量只能在函数中引用
B 在函数中定义的变量，其生存期为整个程序执行期间
C 在函数中定义的变量不能与其所在函数的形参同名
D 在函数中定义的变量，其存储单元在内存的栈区

解析：说明D为什么是对的
首先说明栈内存和堆内存里存放的是什么

• 栈内存中存放函数中定义的一些基本类型的变量和对象的引用变量；
• 堆内存中存放new创建的对象和数组。

简单的来说，堆主要是用来存放对象的，栈主要是用来执行程序的 这么做是因为

• 栈的存取速度快，栈数据可以共享，但是栈中的数据大小和生存期必须确定，缺乏灵活性中存放一些基本类型的对象和对象句柄
• 堆是操作系统分配给自己内存，由于从操作系统管理的内存分配，所以再分配和销毁时都需要占用时间，因此用堆的效率非常低，但是优点在于编译器不需要指导从堆里分配多少存储控件，也不需要知道存储的数据要再堆里停留多长事件，因此用堆保存数据时会得到更大的灵活性

6.Consider the following code:

Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);

Which test would return true?

正确答案: C D E
A (s == u)
B (s == t)
C (s.equals(t))
D (s.equals(9))
E (s.equals(new Integer(9))

解析：

• int和int之间，用==比较，肯定为true。基本数据类型没有equals方法

• int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true

• int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true

• Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new
  Integer。

• 当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false

• 当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true

• Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer. 所以
  Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer
  进行equals比较的话，肯定为true

• new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true 原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同

• 装箱过程是通过调用包装器的valueOf方法实现的

• 拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）

• 总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
  而Float和Double则不相等， Boolean的值总是相等的

7.Java类Demo中存在方法func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )

public class Demo{

　　float func1()
　　{
　　　　int i=1;
　　　　return;
　　}
　　float func2()
　　{
　　　　short i=2;
　　　　return i;
　　}
　　float func3()
　　{
　　　　long i=3;
　　　　return i;
　　}
　　float func4()
　　{
　　　　double i=4;
　　　　return i;
　　}
}

正确答案: A D
A func1
B func2
C func3
D func4

解析：
这道题考的是数据类型转换问题。由大到小需要强制转换，由小到大不需要。
A：return; 没有返回值，错误
B：short → float 无须强制转换，正确
C：long → float 无须强制转换（这个最选项容易出错），正确。
float占4个字节为什么比long占8个字节大呢，因为底层的实现方式不同。
浮点数的32位并不是简单直接表示大小，而是按照一定标准分配的。
第1位，符号位，即S
接下来8位，指数域，即E。
剩下23位，小数域，即M，取值范围为[1 ,2 ) 或[0 , 1)
然后按照公式： V=(-1)^s * M * 2^E
也就是说浮点数在内存中的32位不是简单地转换为十进制，而是通过公式来计算而来，通过这个公式虽然，只有4个字节，但浮点数最大值要比长整型的范围要大。
D：double → float 没有强制转换，错误。

8.以下程序段的输出结果为：

public class EqualsMethod {
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    } }

正确答案: B
A false，false
B false，true
C true，false
D true，true

解析：使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。
使用Integer a = new Integer(1); 时，无论值是多少，都作为对象。

9.以下表达式中，正确的是（）

正确答案: C D
A byte i=128
B boolean i=null
C long i=0xfffL
D double i=0.9239d

解析：
A、byte：-128~127。直接给个128，编译器会认为是int值，这个时候需要强转成byte。
B、boolean：这可是基本数据类型啊，只有false，true。默认值是false。一旦是包装类Boolean，那默认值是null。ojbk
C、十六进制没毛病
D、double这个东西本来就可以写成有d的形式。

10.int，String，*point，union哪些不是 Java 的数据类型？

正确答案: C D 你的答案: C (错误)
A、int
B、String
C、*point
D、union

解析：
*point是指针，java中没有这种类型
union是C系的类型，java中没有

Java选择题练习：循环（牛客网）

1.以下代码的循环次数是

public class Test {
public static void main(String args[]) {
int i = 7;
do {
System.out.println(--i);
--i;
} while (i != 0);
System.out.println(i);
}
}

正确答案: D
A 0
B 1
C 7
D 无限次

解析：
执行1次，5
执行2次，3
执行3次，1
执行4次，-1
永远执行不到0

2.以下程序的输出结果是

public class Print{
	static boolean out(char c){
		System.out.println(c);
		return true;
	}
	public static void main(String[] argv){
		int i = 0;
		for(out('A');out('B') && (i<2);out('C')){
			i++;
			out('D');
		}
	}
}

正确答案: A
A 、ABDCBDCB
B、 BCDABCD
C、 编译错误
D、 运行错误

解析：
for循环执行开始
首先执行out(‘A’) 输出A；
然后执行out(‘B’)&&(i<2)此时输出B，i=0，判断条件为真，执行for循环的循环体；
执行i++，out(‘D’)，输出D i=1；
执行out(‘C’),输出C
然后执行out(‘B’)&&(i<2) 此时输出B，i=1 判断条件为真 ，执行for循环的循环体；
执行i++，out(‘D’)，输出D i=2；
执行out(‘C’),输出C
然后执行out(‘B’)&&(i<2) 此时输出B，i=2，不满足i<2 判断条件为假 ，跳出循环；
所以结果为ABDCBDCB

3.给定代码：

public class SwitchTest{//1
	public static void main(String[] args) {//2
		System.out.println("value="+switchit(4));//3
	}//4
	public static int switchit(int x) {
		int j=1;
		switch (x) {
		case 1:j++;
		case 2:j++;
		case 3:j++;
		case 4:j++;
		case 5:j++;
		default:j++;
		}
		return j+x;
	}
}

第三行将输出什么？

正确答案: B
A value=6
B value=8
C value=3
D value=5
E value=4

解析：没有break，从case 4开始一直执行到最后，j自加3次变成了4,结果返回8

4.关于下面程序，哪些描述是正确的: ( )

public class While {
	public void loop() {
		int x= 10;
		while ( x )  {
			System.out.print("x minus one is " + (x - 1));
			x -= 1;
		}	
	}
}

正确答案: B
A 行1有语法错误
B 行4有语法错误
C 行5有语法错误
D 行6有语法错误
E 行2有语法错误,loop是关键字
F 程序能够正常编译和运行

解析：这个题主要考while（）中表达式的判断，在C语言中大于0的int值都会被认为是true，而java中没有这个机制，必须是boolean类型的。

5.下列关于while循环、do-while循环和for循环说法错误的是

正确答案: B C
A while循环先执行条件判断，do-while循环执行循环体
B do-while循环结束的条件是关键字while后的条件表达式成立
C for循环结构中的3个表达式缺一不可
D while循环能够实现的操作，for循环也能实现

解析：
A.while只有在满足条件时执行 而do-while会先执行一次 再看条件是否满足 满足再次循环 不满足跳出
所以B也就错了 应该是 do-while循环结束的条件是关键字while后的条件表达式不成立
C. 三个都为空也是可以的 最简洁形式：for(;;; )
D. 我们使用while 就是为了他的循环次数的不一定的 而for循环一般限定了循环次数

Java选择题练习：函数（牛客网）

1.如下的Java程序

public class Test { 
     public static void main(String[] args) { 
     System.out.println(args[0]); 
     } 
} 

若采用命令行“java Test one two three”调用，则程序输出的结果为：

正确答案: B
A Test
B one
C two
D java

解析：
采用命令行“ java Test one two three ”调用
其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；
System.out.println(args[0]);表示输出第一个元素，故为one；

2.区分类中重载方法的依据是( )。

正确答案: C
A 不同的形参名称
B 不同的返回值类型
C 不同的形参列表
D 不同的访问权限

解析：方法重写严格把握五点：
三同、一大、一小。具体内容以及与方法重载的区别见下：
方法重写
参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
方法名相同；
以上为三同；

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

此为一大；

父类的成员方法只能被它的子类重写。 声明为final的方法不能被重写。 声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

此为一小；

构造方法不能被重写。 如果不能继承一个方法，则不能重写这个方法。 方法重载 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型； 被重载的方法可以改变访问修饰符； 被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。 无法以返回值类型作为重载函数的区分标准。

3.下列方法定义中 ， 正确 的是 （）

正确答案: A
A int x( ){ char ch=’a’; return (int)ch; }
B void x( ){ …return true; }
C int x( ){ …return true; }
D int x( int a, b){ return a+b; }

解析：
A.Java中涉及到byte、short和char类型都可以强制转化为int，符合返回类型 A正确
B.方法中定义为void 应该没有返回值，但返回值为boolean类型 B错
C. 方法中类型为int，应该返回int类型值，但是 返回值为boolean类型 C错
D.方法应该定义为int(int a,int b)，所以D错

4.A,B,C,D 中哪些是 setvar的重载？

public class methodover {
    public void setVar(int a, int b, float c) {} 
}

正确答案: A C D
A、private void setVar(int a， float c， int b){}
B、protected void setVar(int a， int b， float c){}
C、public int setVar(int a， float c， int b){return a;}
D、public int setVar(int a， float c){return a;}

解析：只和形式参数的数据类型有关（数量，排列组合）