C/C++程序找错

1.下面的代码输出是什么，为什么？
2.对下列代码进行评价
3.设有以下说明和定义：
4.说出程序最后输出什么
5.使出毕生所学吐槽一下这段代码 (功能是字符串颠倒)
6.请问下面程序会出现什么情况?
7.以下 3 个有什么区别
7.写出结果
8.写出输出结果
9.以下表达式
10.交换两个变量，不要第三个变量tmp
11.(void *)ptr 和 (*(void**))ptr 的结果是否相同？
12.输出多少？并分析过程
13.分析下面的程序：
14.char a[10],strlen(a)为什么等于 15？运行的结果
15.数组指针和指针数组的区别
16.求结构体大小
17.求结果：long a=0x801010;a+5=?
18.逆天题目
19.求函数返回值，输入 x=9999; 求结果？
20.分析：输出为什么是 4，1，-1，-4 ，ffffffff
21.分析以下代码
22.在对齐为4的情况下 分析下面程序的结果







C/C++程序找错

1.下面的代码输出是什么，为什么？



void foo(void)
{
    unsigned int a = 6; 
    int b = -20;
    (a + b > 6) ? puts("> 6") : puts("<= 6");
}
这无符号整型问题的答案是输出是">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。



2.对下列代码进行评价



unsigned int zero = 0; /*1's complement of zero */
unsigned int compzero = 0xFFFF; 

对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下： 
unsigned int compzero = ~0; 

为什么啊？
unsigned int compzero = 0xFFFF; 
只写了2个字节，16位的才符合 
32位的可以写： 
unsigned int compzero = 0xFFFFFFFF; 
但unsigned int compzero = ~0;更安全，不管有多少位，直接取反，把所有的0都变成1了



3.设有以下说明和定义：



typedef union 
{
    long i; 
    int k[5];
    char c;
} uni;
struct data
{
    int cat; 
    uni cow;
    double dog;
}DATE;
uni max;

则语句 printf("%d",sizeof(struct date)+sizeof(max));的执行结果是？
sizeof(max) = 20
sizeof(struct date) = 8 + 8 + 8



4.说出程序最后输出什么



#include<stdio.h> 
int inc(int a)
{
    return(++a);
}
int multi(int*a, int*b, int*c)
{
    return(*c = *a**b);
}

typedef int(FUNC1)(int in);
typedef int(FUNC2)(int*, int*, int*);

void show(FUNC2 fun, int arg1, int*arg2)
{
    int temp = arg1; 
    fun(&temp, &arg1, arg2); 
    printf("%d\n", *arg2);
}
main()
{
    int a;
    show(multi, 10, &a);
    return 0;
}
//程序最终输出100



5.使出毕生所学吐槽一下这段代码 (功能是字符串颠倒)



#include"string.h" 
int main()
{
    char*src = "hello,world"; 
    char* dest = NULL;
    int len = strlen(src); 
    dest = (char*)malloc(len);  //要为\0分配内存空间
    char* d = dest;
    char* s = src[len];         //&src[len - 1]指向最后一个字符 
    while(len--!=0)
        d++ = s--;              //*d++ = *s--
    printf("%s",dest);          //*d = 0;尾部要加上\0
    return 0;                   //尾部要加\0最后要内存释放
}



6.请问下面程序会出现什么情况?



#define Max_CB 500
void LmiQueryCSmd()
{
    unsigned char ucCmdNum;
    ......
    for(ucCmdNum=0;ucCmdNum<Max_CB;ucCmdNum++)
    {
        ......;
    }
}
//无限循环，因为Max_CB的值是500，而ucCmdNum最大的值是255（0~255）,当ucCmdNum超过255就会溢出，变成0，所以ucCmdNum永远都不会大于Max_CB



7.以下 3 个有什么区别



char * const p; //常量指针，p 的值不可以修改
char const * p；//指向常量的指针，指向的常量值不可以改
const char * p；//和 char const *p一样



7.写出结果



char str1[] = "abc"; 
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc"; 
const char *str5 = "abc"; 
const char *str6 = "abc"; 
char *str7 = "abc";
char *str8 = "abc";
cout << (str1 == str2) << endl; //false
cout << (str3 == str4) << endl; //false
cout << (str5 == str6) << endl; //true
cout << (str7 == str8) << endl; //true
//str1,str2,str3,str4  是数组变量,它们有各自的内存空间。 
//str5,str6,str7,str8  是指针,它们指向相同的常量区域。
//结果是：0 0 1 1



8.写出输出结果



main()
{
    int a[5]={1,2,3,4,5};
    int *ptr=(int *)(&a+1); 
    printf("%d,%d",*(a+1),*(ptr-1));
}
/*
*(a+1）就是 a[1]，*(ptr-1)就是 a[4],执行结果是 2，5
&a+1 不是首地址+1，系统会认为加一个 a 数组的偏移，是偏移了一 个数组的大小（本 例是 5 个 int）
int *ptr=(int *)(&a+1);则 ptr 实际是&(a[5]),也就是 a+5
原因如下：
    &a 是数组指针，其类型为int(*)[5];而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同。a 是长度为 5 的 int 数组指针，所以要加 5*sizeof(int)。所以ptr实际是a[5]。但是 prt 与(&a+1)类型是不一样的(这点很重要)。所以prt-1只会减去sizeof(int*)。a,&a的地址是一样的，但意思不一样，a  是数组首地址，也就是 a[0] 的地址，&a 是对象（数组）首地址，a+1是数组下一元素的地址，即 a[1],&a+1 是下一个对象的地址，即 a[5]。
*/



9.以下表达式



int a=248; b=4;
int const c=21; 
const int *d=&a; 
int *const e=&b;
const int const *f =&a;

*c=32;  //err
d=&b;   //ok
*d=43;  //err
*e=34;   //ok
e=&a;   //err
f=0x321f;   //err



10.交换两个变量，不要第三个变量tmp



a ^= b;-----+
b ^= a;     +------->a ^= b ^= a;
a ^= b;-----+
(只能对 int,char,实型变量（double,float,long double）不参与位运算)
=======================
a = a + b;
b = a - b;
a = a - b;
=======================



11.(void *)ptr 和 (*(void**))ptr 的结果是否相同？


  

  
ptr 为同一个指针。
  




12.输出多少？并分析过程



unsigned short A = 10;
printf("~A = %u\n", ~A); //输出的是 uint
// A:0000 0000 0000 1010
//~A:‭1111 1111 1111 1111 1111 1111 1111 0101‬--->～A ＝0xfffffff5
//4294967285

char c=128; 
printf("c=%d\n",c);
//-128



13.分析下面的程序：



void GetMemory(char **p, int num)
{
    *p = (char *)malloc(num);
}
int main()
{
    char *str = NULL; 
    GetMemory(&str, 100); 
    strcpy(str, "hello"); 
    free(str); 
    if (str != NULL)
    {
        strcpy(str, "world");
    }
    printf("\n str is %s", str);
    getchar();
}
/*
答：输出 str is world。free只是释放的str指向的内存空间,它本身的值还是存在的。所以free之后，有一个好的习惯就是将str=NULL.此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,尽管这段程序确实是存在大大的问题，但是通常会打印出world来。这是因为进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的。
*/



14.char a[10],strlen(a)为什么等于 15？运行的结果



#include "stdio.h"
#include "string.h" 
void main()
{
    char aa[10]; 
    printf("%d",strlen(aa));
}
//sizeof()和初不初始化，没有关系
//strlen()和初始化有关



15.数组指针和指针数组的区别


  

  
char (*str)[20]; 

  
str 是一个数组指针，即指向数组的指针
  
char *str[20]; 

  
str 是一个指针数组，其元素为指针型数据
  




16.求结构体大小



struct A
{
    char t:4;------------->4位
    char k:4;------------->4位
    unsigned short i:8;--->8位
    unsigned long m;------>4个字节
};
1 + 1 + 4 = 6个字节，偏移 2 字节保证 4 字节对齐
sizeof(A) = 8



17.求结果：long a=0x801010;a+5=?


  

  
0x801010 用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进制的值为 8392720，再加上 5 就是 8392725
  




18.逆天题目



#include<iostream.h>
#include <string.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h> 
typedef struct AA
{
    int b1:5; 
    int b2:2;
}AA;
void main()
{
    AA aa;
    char cc[100]; 
    strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz"); memcpy(&aa,cc,sizeof(AA));
    cout << aa.b1 <<endl; 
    cout << aa.b2 <<endl; 
}
aa中的四个字节所存放的是0，1，2，3的ASCII码，即00110000,00110001,00110010,00110011
int b1:5 = 10000----->11111--->-16
int b2:2 = 01
int 是有正负之分的



19.求函数返回值，输入 x=9999; 求结果？



int func (int x)
{
    int countx = 0; 
    while (x)
    {
        countx++; 
        x = x & (x - 1);
    }
    return countx;
}
//该函数是计算 9999 的二进制数值中有多少个 1 的函数
9999＝9×1024＋512＋256＋15
9×1024 中含有 1 的个数为 2；
512 中含有 1 的个数为 1；
256 中含有 1 的个数为 1；
15  中含有 1  的个数为 4；
故共有 1 的个数为 8，结果为 8。
1000 - 1 = 0111，正好是原数取反。这就是原理。用这种方法来求1的个数是很效率很高的。不必去一个一个地移位。循环次数最少。



20.分析：输出为什么是 4，1，-1，-4 ，ffffffff



struct bit
{
    int a : 3;
    int b : 2;
    int c : 3;
};
int main()
{
    bit s;
    char *c = (char*)&s;
    cout << sizeof(bit) << endl;//4
    *c = 0x99;//10011001
    cout << s.a << endl << s.b << endl << s.c << endl;
    //s.a = 100
    //s.b = 11
    //s.c = 001
    int a = -1;
    printf("%x", a);//ff ff ff ff
    return 0;
}
答：因为 0x99 在内存中表示为 100 11 001 , a = 001, b = 11, c = 100。当 c 为有符号数时, c = 100,    最高 1 为表示 c 为负数，负数在计算机用 补码表示，所以 c = -4;同理 b = -1;当 c 为有符合数时, c = 100,即 c = 4,同理 b = 3。 



21.分析以下代码



struct s1
{
    int i : 8;
    int j : 4;
    int a : 3; 
    double b;
};
struct s2
{
    int i : 8;
    int j : 4; 
    double b; 
    int a : 3;
};
printf("sizeof(s1)= %d\n", sizeof(s1));
printf("sizeof(s2)= %d\n", sizeof(s2)); 
result: 16, 24
答：第一个 struct s1 理论上是这样的，首先是 i 在相对 0 的位置，占 8  位一个字节，然后，j 就在相对一个字节的位置，由于一个位置的字节数是 4 位的倍数， 因此不用对齐， 就放在那里了，然后是 a，要在 3 位的倍数关系的位置上，因此要移一位，在 15 位的位置上放下，目前总共是 18 位，折算过来是 2 字节 2 位的样子，由于 double 是 8 字节的，因此要在相对 0 要是 8 个字节的位置上放下，因此从 18 位开始到 8 个字节之间 的位置被忽略，直接放在 8 字节的位置了，因此，总共是 16 字节。（个人觉得这个解释有误） 

第二个最后会对照是不是结构体内最大数据 的倍数，不是的话，会补成是最大数据的倍数。

1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：   
struct bs  
{  
unsigned a:4  
unsigned :0 /*空域*/  
unsigned b:4 /*从下一单元开始存放*/  
unsigned c:4  
}  
在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。
2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位
3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如： 
struct k  
{  
int a:1  
int :2 /*该2位不能使用*/  
int b:3  
int c:2  
};  
从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的

点击查看此题的经典解释



22.在对齐为4的情况下 分析下面程序的结果



struct BBB  
{  
    long num；  
    char *name;  
    short int data;  
    char ha;  
    short ba[5];  
}*p;  
p=0x1000000;  
p+0x200=____;  
(Ulong)p+0x200=____;  
(char*)p+0x200=____;  

剖析：
假设在32位CPU上，
sizeof(long) = 4 bytes
sizeof(char *) = 4 bytes
sizeof(short int) = sizeof(short) = 2 bytes
sizeof(char) = 1 bytes

由于是4字节对齐，
sizeof(struct BBB) = sizeof(*p)
= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)

p=0x1000000;
p+0x200=____;
= 0x1000000 + 0x200*24   指针加法，加出来的是指针类型的字节长度的整倍数。就是p偏移sizeof(p) *0x200.

(Ulong)p+0x200=____;
= 0x1000000 + 0x200   经过ulong后，这已经不再是指针加法，而变成一个数值加法了

(char*)p+0x200=____;
= 0x1000000 + 0x200*1  结果类型是char*，这儿的1是char的数据类型是1字节

选择题
1、下列代码的运行结果为：C



2、下列代码运行的结果是（） B



3、下列语句的执行结果为（） D



4、下面这段程序的执行结果为： C



5、已知如下代码，则位置（1）处正确的方法调用代码为？ A



6、已知方法的定义形式如下：public void plus(int a,int b){}

下列选项中哪两个是合法的重载方法？(多选) AC



7、下列代码，前者与后者是重载关系的是： A



8、以下代码的输出结果是什么？ D



9、以下代码的输出结果是什么？ D



10、关于可变参数列表的描述正确的是 C


编程题

public class DisCountDemo {
	//根据商品总价输出折后总价
	public double discount(double total) {
		if (total < 100) {
			total *= 1;
		} else if (total < 200) {
			total *= 0.95;
		} else {
			total *= 0.85;
		}
		return total;
	}
	public static void main(String[] args) {
		//定义对象
		DisCountDemo disCountDemo = new DisCountDemo();
		//定义商品总价存放到变量中
		double total = 221;
		//调用方法，输出折后商品总价
		System.out.println("折后商品总价:" + disCountDemo.discount(total));//187.85
	}
}


public class AverageDemo {
	//求数组元素的平均值
	public float average(float[] arr) {
		float sum = 0F;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum / arr.length;
	}
	public static void main(String[] args) {
		//定义对象
		AverageDemo averageDemo = new AverageDemo();
		//创建float类型的数组并初始化
		float arr[] = {1.2F, 3.4F, 5.6F, 7.8F};
		//调用方法求平均值并打印输出
		System.out.println("数组平均值：" + averageDemo.average(arr));//4.5
	}
}


public class AreaDemo {
	//求圆形面积
	public double area(double r) {
		return Math.PI * r * r;
	}
	//求长方形面积
	public double area(double w, double l) {
		return w * l;
	}
	public static void main(String[] args) {
		//定义对象
		AreaDemo areaDemo = new AreaDemo();
		//定义一个double类型的变量存放半径，并初始化
		double r = 1;
		//定义两个变量存放长和宽，并初始化
		double w = 2, l = 3;
		//调用方法，求圆的面积并打印输出
		System.out.println("圆的面积：" + areaDemo.area(r));//3.141592653589793
		//调用方法，求长方形面积并打印输出
		System.out.println("长方形面积：" + areaDemo.area(w, l));//6.0
	}
}

选择
1、下列代码的运行结果为：C



2、下列代码运行的结果是（）	B



3、下列语句的执行结果为（）	D



4、下面这段程序的执行结果为：	C



5、已知如下代码，则位置（1）处正确的方法调用代码为？	A



6、已知方法的定义形式如下：public void plus(int a,int b){}

下列选项中哪两个是合法的重载方法？(多选)		AC



7、下列代码，前者与后者是重载关系的是：		A



8、以下代码的输出结果是什么？	D



9、以下代码的输出结果是什么？	D



10、关于可变参数列表的描述正确的是		C


编程

public class DisCountDemo {
	//根据商品总价输出折后总价
	public double discount(double total) {
		if (total < 100) {
			total *= 1;
		} else if (total < 200) {
			total *= 0.95;
		} else {
			total *= 0.85;
		}
		return total;
	}
	public static void main(String[] args) {
		//定义对象
		DisCountDemo disCountDemo = new DisCountDemo();
		//定义商品总价存放到变量中
		double total = 221;
		//调用方法，输出折后商品总价
		System.out.println("折后商品总价:" + disCountDemo.discount(total));//187.85
	}
}


public class AverageDemo {
	//求数组元素的平均值
	public float average(float[] arr) {
		float sum = 0F;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum / arr.length;
	}
	public static void main(String[] args) {
		//定义对象
		AverageDemo averageDemo = new AverageDemo();
		//创建float类型的数组并初始化
		float arr[] = {1.2F, 3.4F, 5.6F, 7.8F};
		//调用方法求平均值并打印输出
		System.out.println("数组平均值：" + averageDemo.average(arr));//4.5
	}
}


public class AreaDemo {
	//求圆形面积
	public double area(double r) {
		return Math.PI * r * r;
	}
	//求长方形面积
	public double area(double w, double l) {
		return w * l;
	}
	public static void main(String[] args) {
		//定义对象
		AreaDemo areaDemo = new AreaDemo();
		//定义一个double类型的变量存放半径，并初始化
		double r = 1;
		//定义两个变量存放长和宽，并初始化
		double w = 2, l = 3;
		//调用方法，求圆的面积并打印输出
		System.out.println("圆的面积：" + areaDemo.area(r));//3.141592653589793
		//调用方法，求长方形面积并打印输出
		System.out.println("长方形面积：" + areaDemo.area(w, l));//6.0
	}
}

目录

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

java语言的下面几种数组复制方法中，哪个效率最高？

在 myjsp.jsp 中，关于下面的代码说法错误的是： (  )   

下面代码的输出是什么？

关于ThreadLocal类 以下说法正确的是

下面程序的输出是:()

使用mvc模式设计的web应用程序具有以下优点,除了？

Java数据库连接库JDBC用到哪种设计模式?

关于Java和C/C++的比较，下列哪个描述是错误的？

关于volatile关键字，下列描述不正确的是？

JVM内存不包含如下哪个部分( )

以下哪些继承自 Collection 接口（）

事务隔离级别是由谁实现的？

计算机所能处理的最小的数据项称为（）

顺序执行下列程序语句后，则b的值是（）

下面有关forward和redirect的描述，正确的是() ？

下列那些方法是线程安全的(所调用的方法都存在)

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

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

正确答案: D   你的答案: D (正确)

-1

2

1

-2


来源：https://www.nowcoder.com/questionTerminal/7b4ec6887dc04af992ce10dadfb532bb

Y(被除数) % X(除数) 

当除数与被除数的符号相同时，取余和取模的结果是完全相同的； 当除数与被除数的符号不相同时，结果不同。

具体说，取余结果的符号与被除数相同；取模结果的符号与除数相同。

1.取余 　　 rem(3,2)=1 　　 rem(-3,-2)=-1 　　 rem(3,-2)=1 　　 rem(-3,2)=-1 　　

2.取模 　　 mod(3,2)=1 　　 mod(-3,-2)=-1 　　 mod(3,-2)=-1 　　 mod(-3,2)=1


 

java语言的下面几种数组复制方法中，哪个效率最高？

正确答案: B   你的答案: D (错误)

for 循环逐一复制

System.arraycopy

Array.copyOf

使用clone方法


来源：https://www.nowcoder.com/questionTerminal/e7c2d52c9cf0476bbba6aae6713dd303



总结： 

（1）从速度上看：System.arraycopy > clone > Arrays.copyOf > for 
（2）for的速度之所以最慢是因为下标表示法每次都从起点开始寻位到指定下标处（现代编译器应该对其有进行优化，改为指针），另外就是它每一次循环都要判断一次是否达到数组最大长度和进行一次额外的记录下标值的加法运算。 
（3）查看Arrays.copyOf的源码可以发现，它其实本质上是调用了System.arraycopy。之所以时间差距比较大，是因为很大一部分开销全花在了Math.min函数上了。

public static byte[] copyOf(byte[] original, int newLength) { 
    byte[] copy = new byte[newLength];
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); 
    return copy;
}

（4）查看System.arraycopy的源码，可以发现它实质上是通过Jni调用本地方法，及c/c++已经编译成机器码的方法，所以快。

public static native void arraycopy(Object src, int srcPos,
                                    Object dest, int destPos, int length);

（5）native方法，但并未手写，需要JNI转换。


 

在 myjsp.jsp 中，关于下面的代码说法错误的是： (  )   

<%@ page language="java" import="java.util.*" errorPage="error.jsp" isErrorPage="false" %> 

正确答案: A   你的答案: C (错误)

该页面可以使用 exception 对象

该页面发生异常会转向 error.jsp

存在 errorPage 属性时，isErrorPage 是默认为 false

error.jsp 页面一定要有isErrorPage 属性且值为 true


来源：https://www.nowcoder.com/questionTerminal/b07dfbf3f5d7428aacb7387f48084030

exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。

只有当页面是错误处理页面时，即isErroePage为 true时，该对象才可以使用。

对于C项，errorPage的实质就是JSP的异常处理机制,发生异常时才会跳转到 errorPage指定的页面，没必要给errorPage再设置一个errorPage。

所以当errorPage属性存在时， isErrorPage属性值为false


 

下面代码的输出是什么？

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }

    public void callName()
    {
        System. out. println(baseName);
    }

    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

正确答案: A   你的答案: B (错误)

null

sub

base


来源：https://www.nowcoder.com/questionTerminal/c2bfb1512dfa4a7eab773a5871a52402

 new Sub()；在创造派生类的过程中首先创建基类对象，然后才能创建派生类。

创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null

 

《Thinking in JAVA》201页提到，如果不需要内部类对象与其外部类对象之间有联系，那么可以将内部类声明为static，

对于这种说法，我尝试着在A包下面建了一个类X，并在其内部声明了一个静态内部类Y（也叫嵌套类），然后同样是在A包下面，我新建了一个类B，然后在这个类中引用前面那个类Y，发现可以直接引用，说明X与Y的确没有联系（虽然引用的时候需要用X.Y的方式引用，不过貌似好像就这点联系了。）

如果Y没有声明为static，那么是无法在B中引用Y的。其实说了这么多，总结来讲，就是static的作用是相当于建立了2个类，在工作目录下的确也是生成了2个class文件，既然是2个类，那么这两个类的关系就是单纯的继承关系了。


 

关于ThreadLocal类 以下说法正确的是

正确答案: D E   你的答案: A B C D E (错误)

ThreadLocal继承自Thread

ThreadLocal实现了Runnable接口

ThreadLocal重要作用在于多线程间的数据共享

ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本

ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏


来源：https://www.nowcoder.com/questionTerminal/b82e4a85a66e4dc488a5ab49094976e9

1、ThreadLocal的类声明：

public class ThreadLocal<T>

可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。

2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。

所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。

由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，

变量被彻底封闭在每个访问的线程中。所以E对。

3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本：

 static class ThreadLocalMap {

 

        static class Entry extends WeakReference<ThreadLocal> {

            /** The value associated with this ThreadLocal. */

            Object value;

 

            Entry(ThreadLocal k, Object v) {

                super(k);

                value = v;

            }

        }

 

        /**

         * The table, resized as necessary.

         * table.length MUST always be a power of two.

         */

        private Entry[] table;

}

所以D对。


 

下面程序的输出是:()

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

正确答案: D   你的答案: D (正确)

FmNwxy

fmnwxy

wxyfmn

Fmnwxy


来源：https://www.nowcoder.com/questionTerminal/caa9ea2063624a04afc91df682bb4729

String x="fmn";  “fmn”是在常量池里的不可变对象。

x.toUpperCase();   在堆中new一个"FMN"对象，但无任何引用指向它。

String y=x.replace('f','F'); 在堆中 new一个"Fmn"对象，y指向它。

y=y+"wxy"; 在堆中 重新new一个"Fmnwxy"对象， 修改y指向，现在y指向它。


 

使用mvc模式设计的web应用程序具有以下优点,除了？

正确答案: D   你的答案: C (错误)

可维护行强

可扩展性强

代码重复少

大大减少代码量


来源：https://www.nowcoder.com/questionTerminal/940d9dd9a582442090b42443f8883f5e



MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。

MVC只是将分管不同功能的逻辑代码进行了隔离，增强了可维护和可扩展性，增强代码复用性，因此可以减少代码重复。但是不保证减少代码量，多层次的调用模式还有可能增加代码量


 

Java数据库连接库JDBC用到哪种设计模式?

正确答案: B   你的答案: A (错误)

生成器

桥接模式

抽象工厂

单例模式


来源：https://www.nowcoder.com/questionTerminal/134a62da02d34bc6a7ff309af3fbb76f

JDBC提供两套接口，一个面向数据库厂商，一个面向JDBC使用者。

桥接模式：

定义 ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

意图 ：将抽象与实现解耦。

桥接模式所涉及的角色

1.  Abstraction ：定义抽象接口，拥有一个Implementor类型的对象引用

2.  RefinedAbstraction ：扩展Abstraction中的接口定义

3.  Implementor ：是具体实现的接口，Implementor和RefinedAbstraction接口并不一定完全一致，实际上这两个接口可以完全不一样Implementor提供具体操作方法，而Abstraction提供更高层次的调用

4.  ConcreteImplementor ：实现Implementor接口，给出具体实现

Jdk中的桥接模式：JDBC

JDBC连接 数据库 的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不动，原因就是JDBC提供了统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了


 

关于Java和C/C++的比较，下列哪个描述是错误的？

正确答案: C D   你的答案: D (错误)

Java不支持指针，C/C++支持

Java程序不需要显式地关心内存释放，而C/C++需要

Java和C++一样，是纯编译型语言，因此它们的class都是在编译时静态联编(static binding)的

Java数组、字符串不可能溢出，C/C++数组、字符串则有可能溢出边界


来源：https://www.nowcoder.com/questionTerminal/b6f55c8749764ed2876f76a84c4c46a4

Java和C++的区别：

1. Java是解释型语言，所谓的解释型语言，就是源码会先经过一次编译，成为中间码，中间码再被解释器解释成机器码。对于Java而言，中间码就是字节码(.class)，而解释器在JVM中内置了。

2. C++是编译型语言，所谓编译型语言，就是源码一次编译，直接在编译的过程中链接了，形成了机器码。

3. C++比Java执行速度快，但是Java可以利用JVM跨平台。

4. Java是纯面向对象的语言，所有代码（包括函数、变量）都必须在类中定义。而C++中还有面向过程的东西，比如是全局变量和全局函数。

5. C++中有指针，Java中没有，但是有引用。

6. C++支持多继承，Java中类都是单继承的。但是继承都有传递性，同时Java中的接口是多继承，类对接口的实现也是多实现。

7. C++中，开发需要自己去管理内存，但是Java中JVM有自己的GC机制，虽然有自己的GC机制，但是也会出现OOM和内存泄漏的问题。C++中有析构函数，Java中Object的finalize方法

8. C++运算符可以重载，但是Java中不可以。同时C++中支持强制自动转型，Java中不行，会出现ClassCastException（类型不匹配）。


 

关于volatile关键字，下列描述不正确的是？

正确答案: B D   你的答案: B C (错误)

用volatile修饰的变量，每次更新对其他线程都是立即可见的。

对volatile变量的操作是原子性的。

对volatile变量的操作不会造成阻塞。

不依赖其他锁机制，多线程环境下的计数器可用volatile实现。


来源：https://www.nowcoder.com/questionTerminal/3f6c5287a9fa4d0baa162e44970a343d

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

volatile只提供了保证访问该变量时，每次都是从内存中读取最新值，并不会使用寄存器缓存该值——每次都会从内存中读取。

而对该变量的修改，volatile并不提供原子性的保证。

由于及时更新，很可能导致另一线程访问最新变量值，无法跳出循环的情况

多线程下计数器必须使用锁保护。

由于有些时候对 volatile的操作，不会被保存，说明不会造成阻塞。不可用与多线程环境下的计数器。


 

JVM内存不包含如下哪个部分( )

正确答案: D   你的答案: C (错误)

Stacks

PC寄存器

Heap

Heap Frame


来源：https://www.nowcoder.com/questionTerminal/04c442aaf1e14bf9819075cc1f29d899

JVM内存五大区域：左边私有，右边共享



 


 

事务隔离级别是由谁实现的？

正确答案: C   你的答案: B (错误)

Java应用程序

Hibernate

数据库系统

JDBC驱动程序


来源：https://www.nowcoder.com/questionTerminal/ce23bb5a36b54849a05f11187eacb23c



A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它

B，Hibernate是一个java的数据持久化框架，方便数据库的访问

C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能

D，JDBC是java database connector，也就是java访问数据库的驱动


 

计算机所能处理的最小的数据项称为（）

正确答案: A   你的答案: B (错误)

位

字节

字

双字


来源：https://www.nowcoder.com/questionTerminal/fd9860e9c28e4b1dbbe024ee1b590671

位<字节<字<双字


 

顺序执行下列程序语句后，则b的值是（）

String a="Hello";

String b=a.substring(0,2);

 

正确答案: C   你的答案: B (错误)

Hello

Hel

He

null


substring    方法将返回一个包含从    start    到最后（不包含  end ）的子字符串的字符串。


 

下面有关forward和redirect的描述，正确的是() ？

正确答案: B C D   你的答案: B C (错误)

forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求

执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址

执行redirect时，服务器端告诉浏览器重新去请求地址

forward是内部重定向，redirect是外部重定向

redirect默认将产生301 Permanently moved的HTTP响应


来源：https://www.nowcoder.com/questionTerminal/e14e58a3d78346be9540a3fbefd62ee3

1.从地址栏显示来说

forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.

redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

 

2.从数据共享来说

forward:转发页面和转发到的页面可以共享request里面的数据.

redirect:不能共享数据.

 

3.从运用地方来说

forward:一般用于用户登陆的时候,根据角色转发到相应的模块.

redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

 

4.从效率来说

forward:高.

redirect:低.


 

下列那些方法是线程安全的(所调用的方法都存在)

正确答案: A C D   你的答案: C D (错误)

A.
public class MyServlet implements Servlet {
    public void service (ServletRequest req, ServletResponse resp) {
        BigInteger I = extractFromRequest(req);
        encodeIntoResponse(resp,factors);
    }
}


B.
public class MyServlet implements Servlet {
    private long count =0;
    public long getCount() {
        return count;
    }
    public void service (ServletRequest req, ServletResponse resp) {
        BigInteger I = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        count ++;
        encodeIntoResponse(resp,factors);
    }
}

C.
public class MyClass {
    private int value;
    public synchronized int get() {
        return value;
    }
    public synchronized void set (int value) {
        this.value = value;
    }
}

D.
public class Factorizer implements Servlet {
    private volatile MyCache cache = new MyCache(null,null);
    public void service(ServletRequest req, ServletResponse resp) {
    BigInteger i = extractFromRequest(req);
    BigInteger[] factors = cache.getFactors(i);
    if (factors == null) {
        factors = factor(i);
        cache = new MyCache(i,factors);
    }
    encodeIntoResponse(resp,factors);
}


来源：https://www.nowcoder.com/questionTerminal/2d312b47ce1b4921a301db97c1eb4caa


这几个类都没有类属性，不存在共享资源，为了满足题目的意思，应该是多线程情况下使用同一个对象，以达到使成员成为共享资源的目的；

A：没有成员（没有共享资源），线程安全；

B：假设存在线程1和线程2，count初始值为0，当线程1执行count++中count+1（此时未写回最终计算值），这时线程2执行count++中读取count，发生数据错误，导致线程1线程2的结果都为1，而不是线程1的结果为1，线程2的结果为2，线程不安全；

C：成员私有，对成员的set get方法都加重量级锁，线程安全；

D：volatile有两个作用：可见性（volatile变量的改变能使其他线程立即可见，但它不是线程安全的，参考B）和禁止重排序；这里是可见性的应用，类中方法对volatile修饰的变量只有赋值，线程安全.