文章目录
2021-01-14
解析：
a<b true
!取反 false
解析：
Applet 是一种在 Web 环境下，运行于客户端的Java程序组件。Applet 必须运行于某个特定的“容器”，这个容器可以是浏览器本身，也可以是通过各种插件，或者包括支持 Applet 的移动设备在内的其他各种程序来运行。与一般的Java应用程序不同，Applet 不是通过 main 方法来运行的。Applet运行之前，先调用 Init() 方法，然后调用 start() 方法，最后调用 paint() 方法。**init()方法是初始化，自然只有一次。**
解析：
java public void destroy()
Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法，这 4 种方法都是 Applet 类的成员，可以继承这些方法，也可以重写这些方法，覆盖原来定义的这些方法。
destroy()方法收回 Applet 程序的所有资源，即释放已分配给它的所有资源。在 Applet 程序中，系统总是先调用 stop() 方法，后调用 destroy() 方法。
解析：
当编写一个java源代码文件时，此文件通常被称为编译单元（有时也被称为转译单元）。每个编译单元都必须有一个后缀名.java，而在编译单元内则可以有一个public类，该类的名称必须与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，这是因为它们不是public类，而且它们主要用来为主public类提供支持。 --《Java 编程思想》
解析：
这题我醉了
解析：
Float是类，float不是类.
查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.
解析：
application对象是共享的，多个用户共享一个，以此实现数据共享和通信
解析：
Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。
在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。
10.以下程序的输出结果是（）
public class ClassTest{
String str = new String("hello");
char[] ch = {'a','b','c'};
public void fun(String str, char ch[]){
str="world";
ch[0]='d';
}
public static void main(String[] args) {
ClassTest test1 = new ClassTest();
test1.fun(test1.str,test1.ch);
System.out.print(test1.str + " and ");
System.out.print(test1.ch);
}
}
解析：
String类型一旦赋值不能更改
11.以下程序的输出结果是（）
java.util.HashMap map=new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.size());
解析：
HashMap可以插入null的key或value，插入的时候，检查是否已经存在相同的key，如果不存在，则直接插入，如果存在，则用新的value替换旧的value，在本题中，第一条put语句，会将key/value对插入HashMap，而第二条put，因为已经存在一个key为name的项，所以会用新的value替换旧的vaue，因此，两条put之后，HashMap中只有一个key/value键值对。那就是（name，jack）。所以，size为1.
解析：
A：不能使用this调用本类的类方法（即静态方法）
B: 正确
C:在静态方法中，不只可以调用本类的静态方法，也可以使用【类名.静态方法名】调用其他类的静态方法
D:可以调用实例方法，使用【new 类名().实例方法名】调用
解析：
Collection主要的子接口:
List:可以存放重复内容
Set:不能存放重复内容,所有重复的内容靠hashCode()和equals()两个方法区分
Queue:队列接口
SortedSet:可以对集合中的数据进行排序
14.执行如下程序，输出结果是（ ）
class Test
{
private int data;
int result = 0;
public void m()
{
result += 2;
data += 2;
System.out.print(result + " " + data);
}
}
class ThreadExample extends Thread
{
private Test mv;
public ThreadExample(Test mv)
{
this.mv = mv;
}
public void run()
{
synchronized(mv)
{
mv.m();
}
}
}
class ThreadTest
{
public static void main(String args[])
{
Test mv = new Test();
Thread t1 = new ThreadExample(mv);
Thread t2 = new ThreadExample(mv);
Thread t3 = new ThreadExample(mv);
t1.start();
t2.start();
t3.start();
}
}
解析：
Test mv =newTest()声明并初始化对data赋默认值
使用synchronized关键字加同步锁线程依次操作m()
t1.start();使得result=2,data=2,输出即为2 2
t2.start();使得result=4,data=4,输出即为4 4
t3.start();使得result=6,data=6,输出即为6 6
System.out.print(result +" "+ data);是print()方法不会换行,输出结果为2 24 46 6
解析：
1.Java三大注解分别是@Override @Deprecated @Suppresswarnings
2.@Override 注解表名子类中覆盖了超类中的某个方法，如果写错了覆盖形式，编译器会报错
3.@Deprecated 表明不希望别人在以后使用这个类，方法，变量等等
4.@Suppresswarnings 达到抑制编译器产生警告的目的，但是不建议使用，因为后期编码人员看不懂编译器提示的警告，不能更好的选择更好的类去完成任务
解析：
RuntimeException是那些在Java虚拟机正常运行期间可以抛出的异常的超类
方法不需要声明抛出的条款的任何子类RuntimeExeption执行期间可能抛出的方法而不是被一个RuntimeException的子类Throwable表明严重的问题
合理的应用程序不应该试图抓住
NullPointerException是一种运行时异常
解析：
switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。
解析：
A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。
B、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。
C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
D、ASCII码包含一些特殊空字符
解析：
四个选项都是Swing组件。JTextField输入单行文本，JTextArea输入多行文本，JButton显示按钮，JLebel提示信息（但和显示信息有区别吧？？？？？）
解析：
一个一个的算了只有：
（3+x）*(4+x)=2x^2+4
.....x=8或-1
。。。。好巧
解析：
Applet显示相关的方法主要有3个。
1. paint(Graphicsg)方法，具体执行Applet的绘制。
2. update(Graphicsg)()方法，主要用于更新Applet的显示。
3. repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新。
解析：
Java中标识符有字母、数字、美元符号$、下划线4种，不能以数字开头，不能用保留字和关键字
解析：
c是面向过程，c++面向对象，JAVA面向对象，汇编是面向机器
解析：
finally语句定义一个总是执行的代码，而不考虑异常是否被捕获。
解析：
Lanbda表达式的主要作用就是代替匿名内部类的繁琐语法， 它由三部分组成：
1. 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
2. 箭头（→）。必须通过英文中画线和大于符号组成。
3. 代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么那条语句就不要用花括号表示语句结束。
解析：
A： 抽象方法只可以被public 和 protected修饰；
B：final可以修饰类、方法、变量，分别表示：该类不可继承、该方法不能重写、该变量是常量
C：static final 可以表达在一起来修饰方法，表示是该方法是静态的不可重写的方法
D：private 修饰方法（这太常见的）表示私有方法，本类可以访问，外界不能访问
27.如果编译并运行这个类，哪两条语句为真*
public class NameList
{
private List names = new ArrayList();
public synchronized void add(String name)
{
names.add(name);
}
public synchronized void printAll() {
for (int i = 0; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public static void main(String[]args)
{
final NameList sl = new NameList();
for (int i = 0; i < 2; i++)
{
new Thread()
{
public void run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}
解析：
在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。
而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。
E答案相当于线程1顺序执行完然后线程2顺序执行完。
G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC
输出加起来即为ABCAABCABC。
解析：
Java程序的种类有：
（a）内嵌于Web文件中，由浏览器来观看的_Applet
（b）可独立运行的 Application
（c）服务器端的 Servlets
解析：
java不允许单独的方法，过程或函数存在,需要隶属于某一类中。——AB错
java语言中的方法属于对象的成员,而不是类的成员。不过，其中静态方法属于类的成员。——C错
D问的是java调用方法和C调用过程,C+ + 的函数一样？肯定不一样。错
解析：
搞不懂，尴尬
2021-01-18
1.请给出最终输出内容。
int i = 3;
String result = new String();
switch (i) {
case 1:
result = result + "him ";
case 2:
result = result + "her ";
case 3:
result = result + "it ";
default:
result = result + "me ";
}
System.out.println(result);
解析：
根据switch()括号里的值，进行匹配，走相应的case。case没有break就继续往下走
解析：
D等效于x=x+1
解析：
三目运算符 真取前面假取后面
解析：
Java规范中 强制规定， 类名使用首字母大写的驼峰形式，方法名、参数名、成员变量、局部变量都统一使用首字母小写的驼峰形式。
解析：
考验英语翻译。。。
解析：
run方法线程执行体.start方法开启多线程
解析：
1.构造方法也是类的方法，可以在创建对象时为成员变量赋值
2.构造方法可以进行重载，但是参数列表必须不相同，不以返回值和访问级别进行区分
3.构造方法没有返回值
4.构造方法一定要与定义为public的类同名
8.执行下列程序的输出结果为（ ）
public class Test {
public static void main(String[] args) {
String s1 = "HelloWorld";
String s2 = new String("HelloWorld");
if (s1 == s2) {
System.out.println("s1 == s2");
} else {
System.out.println("s1 != s2");
}
if (s1.equals(s2)) {
System.out.println("s1 equals s2");
} else {
System.out.println("s1 not equals s2");
}
}
}
解析：
==
如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
如果作用于引用类型的变量，则比较的是所指向的对象的地址
Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。
解析:
暂时搞不懂
解析：
ERROR是不可捕捉的，很明显那就是Exception
解析：
前三个都至少需要先读取，再操作
解析：
A、静态方法属于类本身，可以使用类名调用。
B、静态块只执行一次。
C、static块和方法不能出现this和super
D、可以的，实例对象也可以调用静态方法。
解析：
一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性
14.如下代码的 结果是什么 ?
class Base {
Base() {
System.out.print("Base");
}
}
public class Alpha extends Base {
public static void main( String[] args ) {
new Alpha();
//调用父类无参的构造方法
new Base();
}
}
解析：
没学过，先收藏，之后补充
解析：
A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它
B，Hibernate是一个java的数据持久化框架，方便数据库的访问
C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能
D，JDBC是java database connector，也就是java访问数据库的驱动
16.以下程序输出（）
public static void main(String[] args) {
int num = 2;
switch (num) {
case 1:
++num;
case 2:
++num;
case 3:
++num;
default:
++num;
break;
}
System.out.println(num);
}
}
解析：
遇到break才跳出
17.当编译并运行下面程序时会发生什么结果（）
public class Bground extends Thread{
public static void main(String argv[]){
Bground b = new Bground();
b.run();
}
public void start(){
for(int i=0;i<10;i++){
System.out.println("Value of i = "+i);
}
}
}
解析：
看评论看不懂，先收藏
18.在jdk1.5之后，下列 java 程序输出结果为______。
int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));
解析：
i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。
j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真。
19.What is displayed when the following is executed;
double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));
解析：
ceil：大于等于 x，并且与它最接近的整数。
floor：小于等于 x，且与 x 最接近的整数。
解析：
没学过，看不懂评论啊
21.以下代码将打印出
public static void main (String[] args) {
String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
System.out.println(classFile);
}
解析：
由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么久要写成"\." 服了！！！！！！！！！
解析：
在根类Object中包含一下方法：
clone();
equals();
finalize();
getClass();
notify(),notifyAll();
hashCode();
toString();
wait();
23.哪个测试将返回true？
Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
解析：
( s== u ) ，因为， s 是 Integer 类型， u 是 Long 类型，两个不同类型的引用不能进行 == 比较
(s== t) ， s 是指向一个 9 的引用，而 t 也是一个指向 9 的引用，虽然都是指向 9 ，但却是指向不同的 9 ，即是两个不同的引用。因此 == 比较返回的是假。
是 Integer 的实例且 value 值也相等的情况下返回真，其他返回假。
在这里， s 和 t 都是 Integer 类型且值都为 9 ，因此结果为真。
(s.equals(9)) , 在进行 equals 比较之前，会对 9 调用 Integer.valueOf 方法，进行自动装箱 , 由于 IntegerCache 中已经存在 9 ，所以，直接返回其引用，引用相同， equals 就自然相同了。所以结果为真。
(s.equals( new Integer(9)) ，直接创建了一个新的 Integer 实例，但且值也为 9 ，所以，满足条件，返回真
24.A,B,C,D 中哪些是 setvar的重载？
public class methodover
{
public void setVar(int a, int b, float c) {}
}
解析：
重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关
解析：
标识符由数字、字母、下划线(_)、美元符号($)或人民币(¥)组成，首位不能是数字。并且Java关键字不能作为标识符。
解析：
JSP内置对象（隐式对象）：
1.request
2.response
3.out
4.session
5.application
6.config
7.pageContext
8.page
9.exception
解析：
没学过C++啊
解析：
1.session用来表示用户会话，session对象在服务端维护，一般tomcat设定session生命周期为30分钟，超时将失效，也可以主动设置无效；
2.cookie存放在客户端，可以分为内存cookie和磁盘cookie。内存cookie在浏览器关闭后消失，磁盘cookie超时后消失。当浏览器发送请求时，将自动发送对应cookie信息，前提是请求url满足cookie路径；
3.可以将sessionId存放在cookie中，也可以通过重写url将sessionId拼接在url。因此可以查看浏览器cookie或地址栏url看到sessionId；
4.请求到服务端时，将根据请求中的sessionId查找session，如果可以获取到则返回，否则返回null或者返回新构建的session，老的session依旧存在，请参考API。
转载牛客大佬
解析：
评论看不懂，先收藏
解析：
A，“任何对象”锁定，太绝对了，你能锁住你没有权限访问的对象吗？
B，前半句话讲的是创建线程的方式，后半句讲的是锁定
2021-01-22
解析：
java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
java.lang： 提供java编成语言的程序设计的基础类
java.io： 包含提供多种输出输入功能的类，
java.net： 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
java.applet： 包含java小应用程序的类
java.util： 包含一些实用性的类
2.输出结果是？
public void complicatedexpression_r(){
int x=20, y=30;
boolean b;
b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;
System.out.println(b);
}
解析：
优先级排序是：’>’，’<’，’&&’，’||’。
3.假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）
public class A
{
public int i;
static String s;
void method1(){}
static void method2(){}
}
解析：
类名无法直接调用非静态方法
4.类 ABC 定义如下：
将以下哪个方法插入行 3 是不合法的。（ ）。
public class ABC{
public int max( int a, int b) { }
}
解析：
ava的方法重载，就是在同一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数个数哥不同定义，调用方法时通过传递给它们的不同参数个数和类型来决定具体使用哪个方法。当方法同名时，至少需要下面之一不同: 1.参数个数不同 2.对应位置上的参数类型不同
解析：
垃圾回收机制，没有任何对象指向时回收
解析：
老子永远在最后
解析：
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’
8.java中下面哪个能创建并启动线程（）
public class MyRunnable implements Runnable {
public void run() {
//some code here
}
}
解析：
start为线程启动函数，排除B；
MyRunnable类必须实例化，排除A；
必须新建一个Thread类来启动线程。
9.下面的程序将来打印什么?（）
public class TestIncr {
public static void main(String args[]) {
int i = 0;
i = i++ + i;
System.out.println("I =" +i);
}
}
解析：
i++的值为0 然后值+1 即 i = 0 +1; 选A
解析：
inputStream是字节流输入流；而inputStreamReader是对字符流的处理，inputStreamReader将字符流处理成字节流，题目要求是用于处理字符输入
解析：
A抽象类不一定含有抽象方法，接口中的方法都是抽象方法。
接口中的方法默认修饰符有public abstract。
B一个类只能继承一个一个抽象类，但可以实现多个接口；一个接口可以继承多个接口。
Java里类是单继承的，接口是可以多继承的，用关键字extends。
C抽象类和接口中的方法都没有方法体。
抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。
D抽象类可以含有私有成员变量，接口不含有私有成员变量。
接口中的成员变量都是public static final的，一般用作常量。
解析：
Thread.sleep()会抛出InterruptedException，这个属于checked exception，也就是编译时异常，我们必须显式的捕获异常而不能继续上外层抛出，因为这个异常需要该线程自己来解决。
解析：
位<字节<字<双字
14.以下代码的输出的正确结果是
public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}
解析：
字符串长度
解析：
A. 软件分为系统软件和应用软件，操作系统属于系统软件，不应该分开讲，而且它也不是必须的
B. Java程序源代码需要编译后在Java虚拟机上运行
D. 写Java不一定要用到集成开发环境，而且有推荐新手先不要用IDE
16. i 的最终结果是？
int i, sum=0;
for(i=0;i<10;++i,sum+=i);
解析：
++i就是先赋值 再计算 当到9的时候直接+1超过了10直接输出
解析：
A： java中"包"的引入的主要原因是java本身跨平台特性的需求。实现跨平台的是JVM。
B： package语句是Java源文件的第一条语句。（若缺省该语句，则指定为无名包。），如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入。
D：java中并无#include关键字， 如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入。
解析：
List 是一个有序集合，可以存放重复的数据 (有序：存进是什么顺序，取出时还是什么顺序)
(1).ArrayList 底层是数组适合查询，不适合增删元素。
(2).LiskedList 底层是双向链表适合增删元素，不适合查询操作。
19.What is the result?
public class Test
{
static boolean foo(char c)
{
System.out.print(c);
return true;
}
public static void main( String[] argv )
{
int i = 0;
for ( foo('A'); foo('B') && (i < 2); foo('C'))
{
i++ ;
foo('D');
}
}
}
解析：
for(条件1;条件2;条件3) {
//语句
}
执行顺序是条件1->条件2->语句->条件3->条件2->语句->条件3->条件2…
如果条件2为true，则一直执行。如果条件2位false，则for循环结束
解析：
java,exe是java虚拟机
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof,exe是剖析工具
解析：
直接初始化数组大小为20，不扩容
22.类Parent和Child定义如下：
将以下哪种方法插入行5是不合法的
class Parent{
public float aFun(float a, float b) { }
}
class Child extends Parent{
}
解析：
同上面一道题一样
23.对于如下代码段,可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是
class A{
public A foo(){return this;}
}
class B extends A{
public A foo(){
return this;
}
}
class C extends B
{
_______
}
解析：
C方法名相同，返回值（无所谓），而参数列表与父类不相同，那么是重载
24.Which statement is true?
void waitForSignal()
{
Object obj = new Object();
synchronized(Thread.currentThread())
{
obj.wait();
obj.notify();
}
}
解析：
不会，先收藏
解析：
前台线程:所有显示创建的线程默认为前台线程,前台线程全部执行完成之后,程序终止!
后台线程:又称为守护线程,一般是为前台线程服务的线程,比如 gc(),垃圾回收线程就是后台线程,后台线程的运行状态不能左右进程的状态.
解析：
A.class类是Object的派生类
B.每个类都使用Object类作为超类，而final修饰的类不能被继承
27.针对以下代码，哪些选项执行后是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选项：x == f1[0] ，x是long类型，与float类型对比属于低精度，所以x要向高精度的float类型转型再比较，故相等；
C选项：f1 == f3，f3没有new创建，而是由f1赋值，所以f3地址是指向f1的，f1值改变，相当于改变f3值，所以相等。
解析：
数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组。
解析：
+=会自动强转
byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。
解析：
A 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节。
B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：
将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。
C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符
D 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。
2021-01-26
解析：
final修饰变量的本质就是：修饰的变量值(地址或内容)无法改变。
解析：
Java中类之间的六种关系：
第一种：继承关系，例如：子类继承父类，子接口继承父接口。
第二种：实现关系，例如：类实现接口。
第三种：依赖关系，例如：一个类作为另一个类中方法的参数存在，这种关系具有偶然性和临时性。
第四种：关联关系，例如：一个类作为另一个类中的成员变量存在，它是一种强依赖关系。
第五种：聚合关系，例如：整体和部分之间，他们是可以分离的拥有各自的生命周期，并且部分是相同的。像鸟群和鸟。
第六种：组合关系，它是一种强聚合，并且整体和部分之间不可分离，具有相同的生命周期，整体包含该部分，也包含其他部分，其他部分和该部分是不相同的，像cpu和计算机，计算机除了包括cpu还有键盘和显示器等。
解析：
在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，呼吁很久的String支持也终于被加上了。
解析：
在Java中5.0是double类型,所以结果的数据类型为double。因为1/4结果为0，所以结果为-6.0
解析：
在类内部可以用户可以使用关键字this.构造方法名()调用（参数决定调用的是本类对应的构造方法）
在子类中用户可以通过关键字super.父类构造方法名()调用（参数决定调用的是父类对应的构造方法。）
反射机制对于任意一个类，都能够知道这个类的所有属性和方法，包括类的构造方法。
解析：
解析：
java.lang包是java语言包，是自动导入的。
java.util包是java的工具包，需要手动导入。
java.sql包，JDBC接口类，需要手动导入。
java.io;各种输入输入流，需要手动导入。
解析：
A错误，类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用
B错误，当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用
C错误，子类具体的实例方法对父类是不可见的，所以无法直接调用， 只能通过创建子类的一个实例对象，再进行调用
final不能被子类覆盖，但是基类的private方法，只有非private方法才能被覆盖。子类虽然继承了基类的所有内容，但是private和构造器等对子类是不可见的，不能直接访问，但是可以调用基类的非parivate方法从而访问基类的private方法，也会引起很多问题。
class Shape {
private Shape wf;
protected Shape() {
wf = this;
}
private int length() {
return 0;
}
private int width() {
return 0;
}
public int getArea() {
return wf.length()*wf.width();
}
}
public class OverridingShape extends Shape {
public int length() {
return 10;
}
//@Override 不是覆盖，基类该方法是private，子类不可见
public int width() {
return 10;
}
public static void main(String[] args) {
Shape s=new OverridingShape();
System.out.println(s.getArea());
//结果是0而不是100 调用的是父类的方法,然后访问的是父类的private方法
}
}
解析：
见注释
public class While {
public void loop() {
int x= 10;
while ( x ) {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}
解析：
while()括号里参数必须是布尔类型，要么true要么false
解析：
总页数=总记录数/每页显示的条数（每页显示的条数是人为规定的）
因此总页数要根据总记录数确定，因此要首先获取总记录数
解析：
System.arraycopy>clone>Arrays.copyOf>for循环
System类源码中给出了arraycopy的方法，是native方法，也就是本地方法，肯定是最快的。
而Arrays.copyOf(注意是Arrays类，不是Array)的实现，在源码中是调用System.copyOf的，多了一个步骤，肯定就不是最快的
解析：
java是自动管理内存的，通常情况下程序运行到稳定状态，内存大小也达到一个 基本稳定的值
但是内存泄露导致Gc不能回收泄露的垃圾，内存不断变大.
最终超出内存界限，抛出OutOfMemoryExpection
解析：
解析：
它的通信机制实质就是xml数据交换;
解析：
Python是解释执行的，其他语言都需要先编译
解析：
java多态有两种情况：重载和覆写
在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法
解析：
servlet是运行在服务器端的小应用程序，是接收网络服务的请求和产生响应的一种方式。
servlet的功能：接受http请求，产生动态http响应。
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;
}
}
解析：
main方法中：
执行x–后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3
解析：
解析：
三个基本元素：封装，继承，多态。
五个基本原则：单一职责原则，开放封闭原则，里氏替换原则，依赖倒置原则，接口隔离原则
解析：
ArrayList插入和现有项的删除开销很大
解析：
jdk1.8后接口中用static或default修饰的方法可以有方法体
解析：
解析：
封装是为了隐藏细节，限制可访问的权限； 继承是为了代码的复用； 但实质上二者都是为多态服务的，所以也可以说多态的特点是隐藏细节，扩展代码！
解析：
A错，调用Base这个构造方法应该这样 new Base(a,b)
B错，和C相比应该是分号不是逗号，帅的一塌糊涂
解析：
看不明白，等学了再来
解析：
一种多选的感觉，然后就强行多选了一个
2021-01-29
解析：
在Java语言的异常处理中，finally块的作用就是为了保证无论出现什么情况，finally块里的代码一定会执行。
解析：
生成字符串的两个类String和StringBuffer中，前者生成的字符串是不变字符串，不能直接对它的内容进行修改，而后者生成的字符串是可变的，可以对其内容进行修改
解析：
数组的角标是从0开始的。从arr[0]到arr[arr.length-1]。
解析：
解析：
public class Test{
static int cnt = 6;
static{
cnt += 9;
}
public static void main(String[] args）{
System.out.println（“cnt =” + cnt);
}
static{
cnt /=3;
};
}
解析：
解析：
解析：
解析：
public class Test
{
public static int aMethod(int i)throws Exception
{
try{
return i / 10;
}
catch (Exception ex)
{
throw new Exception("exception in a Method");
} finally{
System.out.printf("finally");
}
}
public static void main(String [] args)
{
try
{
aMethod(0);
}
catch (Exception ex)
{
System.out.printf("exception in main");
}
System.out.printf("finished");
}
}
解析：
class Parent {
private int data;
public Parent(int d){ data = d; }
}
class Child extends Parent{
String name;
public Child(String s, int d){
___________________
name = s;
}
}
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
解析：
2021-02-02
1.#include <stdio.h>
main()
{
int sum, pad,pAd;
sum = pad = 5;
pAd = ++sum,pAd++, ++pad;
printf("%d\n",pad );
}
程序的输出结果是（）
正确答案: B 你的答案: C (错误)
A.5
B.6
C.7
8.D
解析：
由于赋值运算符优先级>逗号运算符优先级，所以
pAd = ++sum,pAd++, ++pad; 等价于 (pAd = ++sum),pAd++, ++pad; 执行完上面语句后，sum=6,pAd=7,pad=6
2.int c = 23;
printf(“%d\n”, c&c);
请问执行结果是：
正确答案: C 你的答案: C (正确)
A.0
B.46
C.23
D.以上都不对
解析：
printf输出的结果是将c&c后的结果，&是位运算符，将前后两个操作数对应为相与。而任何数与其自身相与，得到的结果不变 1&1=1 0&0=0，所以c&c 等于 c 等于 23 所以，输出结果 23
3.在下列流类中，可以用于处理文件的是（）。
正确答案: D 你的答案: B (错误)
A.ios
B.iostream
C.strstream
D.fstream
解析：
对文件的操作是通过stream的子类fstream(file stream)来实现的
4.程序运行后的输出结果是（ ）。
正确答案: C 你的答案: D (错误)
A.10234
B.12345
C.12334
D.12234
解析：
最后一项:i=2，则a[3]=a[2]=3,然后就结束了
5.设有如下定义:struct jan{int a;float b;}c2, * p;若有p=&c2;则对c2中的成员a的正确引用是:（ ）
正确答案: B 你的答案: A (错误)
A.(*p).c2.a
B.(*p).a
C.p->c2.a
D.p.c2.a
解析：
p是指向结构体对象c2的指针，指针引用对象用->符号。
6.以下程序运行后的输出结果是（ ）
int main()
{
int a=1,b=2,m=0,n=0,k;
k=(n=b<a)&&(m=a) ;
printf("%d,%d\n",k,m)；
return 0;
}
正确答案: A 你的答案: A
A.0,0
B.0,1
C.1,0
D.1,1
解析：
先执行判断语句、为0，然后&&后面的不执行了 结果也为0
7.程序运行后的输出结果是?
正确答案: B 你的答案: B (正确)
A.k=5 a=15
B.k=4 a=12
C.k=6 a=11
D.k=3 a=14
解析：
k=0, s[k+1] = ‘2’, k++(k=1), a = 0+(‘2’-‘0’)=2;
k=1, s[k+1] = ‘1’, k++(k=2), a = 2+(‘1’-‘0’+1)= 4;
k=2, s[k+1] = ‘3’, k++(k=3), a = 4+(‘3’-‘0’)=7;
k=3, s[k+1] = ‘4’, k++(k=4), a = 7+(‘4’-‘0’+1)= 12;
k=4, s[k+1] = ‘\0’, 结束
8.下面的程序执行输出几个hello？
#include<stdio.h>
#include <unistd.h>
int main( ) {
fork( );
fork( );
fork( );
printf(“hello\n”);
return 0;
}
正确答案: D 你的答案: C (错误)
A.3
B.4
C.6
D.8
解析：fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。
fork(); //2个进程
fork(); //4个进程
fork(); //8个进程
9.const char * str = “123456”; sizeof(str)和strlen(str)的结果分别时多少？（）
正确答案: D 你的答案: A (错误)
A.7,6
B.7,7
C.6,7
D.都不对
解析：
64位系统 输出值为 8，6 32位系统 输出值为 4， 6
10.下列哪种情况会调用拷贝构造函数（）
正确答案: A C D 你的答案: D (错误)
A用派生类的对象去初始化基类对象时
B将类的一个对象赋值给该类的另一个对象时
C函数的形参是类的对象，调用函数进行形参和实参结合时
D函数的返回值是类的对象，函数执行返回调用时
解析：
定义一个对象时，以本类另一个对象作为初始值，发生复制构造；
如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生复制构造；
如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化一个临时无名对象，传递给主调函数，此时发生复制构造。
2021-02-06
1. 要交换变量A和B的值,应使用的语句组( )
正确答案: B 你的答案: D (错误)
A.A=B;B=C;C=A
B.C=A;A=B;B=C
C.A=B;B=A
D.C=A;B=A;B=C
解析：
通过第三个变量来将两个元素替换时，简记：同一个变量不会在等号的某一边重复出现两次
2. C语言中double 类型数据占字节数为（）
正确答案: B 你的答案: B (正确)
A.4
B.8
C.12
D.16
解析：
double 型数据在内存中占 8 个字节 ,float 型数据占 4 个字节 ,int 型数据占 2 个字节 ,char 型数据占 1 个字节
3. 下面关于虚函数和函数重载的叙述不正确的是
正确答案: A 你的答案: C (错误)
A.虚函数不是类的成员函数
B.虚函数实现了C++的多态性
C.函数重载允许非成员函数，而虚函数则不行
D.函数重载的调用根据参数的个数、序列来确定，而虚函数依据对象确定
解析：
虚函数也是类的成员函数，A说法是不正确的；
虚函数和函数重载都实现了C+=的多态性，但表现形式不一样，函数重载调用根据参数个数、参数类型等进行区分，而虚函数则是根据动态联编来确定调用什么，故BD说法正确
函数重载可以是类的成员函数也可以是非成员函数，比如:
int fun(int a);
int fun(int a, int b);
4.以下逗号表达式的值为（ ）。
(x=45, x5), x+25
正确答案: D 你的答案: D (正确)
A.25
B.20
C.100
D.45
解析：
逗号表达式值为逗号右边的值，先算括号里的x=20，括号内的逗号表达式的值为100，但整个表达式的值是20+25=45
5.若已有定义：int a=2，b=3，c=4；则表达式！（a+b）-c+1||c+b/2的值是（ ）
正确答案: D 你的答案: D (正确)
A.-2
B.-1
C.0
D.1
解析：
（a+b）结果为0，（0-c+1）=-3不为0，即前半部分（||左边）结果为1，右半部分事实上不用计算。
6.定义char dog[]=“wang\0miao”;那么sizeof(dog)与strlen(dog)分别是多少：
正确答案: A 你的答案: D (错误)
A.10,4
B.4,4
C.9,9
D.9,4
解析：
sizeof返回数组所占的字节数，‘wang’ ‘miao’共占8字节，显式’\0’占1字节，字符串末尾隐式’\0’占1字节，共10字节。
strlen返回字符串的长度，以遇到’\0’结束符为准，因此为4。
7.int i, * p=&i;是正确的 C 说明。请问这句话的说法是正确的吗？
正确答案: A 你的答案: B (错误)
A.正确
B.错误
解析：
声明语句中逗号的意义。
int A=10, B=20; 等价于 int A= 10; int B = 20;
同理。这里等价于
int i;
int * p = & i;
8.已知函数的调用形式：fread (buffer,size,count,fp)；其中buffer代表的是（）。
正确答案: C 你的答案: C (正确)
一个整数，代表要读入的数据项总数
一个文件指针，指向要读的文件
一个指针，指向要读入数据的存放地址
一个存储区，存放要读的数据项
解析：
fread函数的功能就是从fp所代表的文件中读取count*size个字节的数据存放
到指针buffer所指向的内存块中。
9.表达式 100！= 90 的值是（）
正确答案: B 你的答案: B (正确)
A.0
B.1
C.TRUE
D.非零值
解析：
false => 0
10.下面程序的输出是
#include <stdio.h>
void main()
{
int x=023;
printf("%d\n",–x);
}
正确答案: A 你的答案: C (错误)
A.18
B.19
C.22
D.23
解析：
int x=023是八进制数，转为十进制为19；故结果为18
2021-02-11
1.要调用数学处理函数时，在#include命令行中应包含（ ）。
正确答案: C 你的答案: A (错误)
A."stdio.h"
B."string.h'
C." math.h"
D." ctype.h"
解析 ：
a头文件
b字符串函数
c数学函数
d字符函数
2. 对二维数组 a 来说,由于 a+1与(a+1)的值相等,因此二者的含义是一样的。请问这句话的说法是正确的吗？
正确答案: B 你的答案: B (正确)*
A.正确
B.错误
解析：
两者的值是相等的！是相同的地址值，但是含义不一样：a+1是第二维数组的地址，*(a+1)是第二维数组第一个元素的地址。所以值是相等的，但是意义不一样
3.下列程序的输出结果是（ ）
main( )
{ int a=7,b=5;
printf("%d\n",b=b/a);
}
正确答案: C 你的答案: D (错误)
A.5
B.1
C.0
D.不确定值
解析：
两个整数相除叫整除，不采用四舍五入，而是截断小数只取整数部分。
4.在C语言中，若有定义：int a[4] [10] (其中0<=i<4,0<=j<10);则下列选项中对数组元素a[i][j]引用错误的是（）
正确答案: A 你的答案: B (错误)
A.*(a+i)+j
B.*(&a[0][0]+10*i+j)
C.*(a[i]+j)
D.*(*(a+i)+j)
解析：
A是a[i][j]的地址
D是A再取 * 则是a[i][j]的值
C正确，a[i]为第i行第0个元素的地址，加j后为a[i][j]地址，再取就是a[i][j]
B正确，a[0][0]取地址是数组第一个元素的地址，加上10i为第i行第0个元素的地址，在加j是a[i][j]地址，再取*是a[i][j]的值
5.a - (b * c + d) / e的后缀表达式是（）
正确答案: C 你的答案: C (正确)
A.abcde-*+/
B.abcd*+e/-
C.abc*d+e/-
D.abc*de+/-
解析：
后缀表达式：先写运算对象再写符号，一般格式：{运算对象}{运算对象}{操作符}
bc*
bcd+
bcd+e/
abc*d+e/-
6.正确答案: B 你的答案: D (错误)
A.4
B.8
C.9
D.6
解析：
执行NUM=(N+1+1)*N+1/2=8,取整数部分
7.int ( * p)[3] p的含义是什么?
正确答案: B 你的答案: D (错误)
A.一个指向int元素大小为3的指针数组
B.一个指向元素个数为3的int数组的指针
C.不合法
D.以上说法都不正确
解析：
首先先看小括号（因为小括号优先级最高），(*p)说明p首先肯定是一个指针。
然后再往后看[3]，说应这个指针指向了一个数组，这个数组有三个元素。
再看最前面int，说明这个数组是整型的。
综合起来，是一个指向元素个数为3的整型数组的指针。
1、int(*p)[3];------ptr为指向含3个元素的一维整形数组的指针变量（是指针）
2、int *p[3];-------定义指针数组p，它由3个指向整型数据的指针元素组成（是数组）
3、int( * )[3];--------实际上可以看作是一种数据类型。也就是第一个（int(*p)[3];）
8.unsigned int a= 0x1234; unsigned char b= * (unsigned char * )&a; 在32位大端模式处理器上变量b等于()?
正确答案: A 你的答案: B (错误)
A.0x00
B.0x12
C.0x34
D.0x1234
解析：
unsigned int a= 0x1234的32位完全表示是0x00001234，在大端（低地址存储高位）处理器上的存储方式为：
由低地址到高地址依次为（假设低地址为0x4000）：
0x4000 0x4001 0x4002 0x4003
00 00 12 34
则&a的值为0x4000， char占一个字节，即b最终所取的值为0x4000地址内存储的内容，故为0x00。
9.在c语言中，一个函数不写返回值类型，默认的返回类型是以下哪个？
正确答案: A 你的答案: B (错误)
A.int
B.char
C.void
D.都不是
解析：
C语言中，如果不写返回值，返回值类型默认为 int
10.下列关于C语言中指针的说法错误的是：___
正确答案: B C 你的答案: B D (错误)
A.指针的值是一个地址
B.非法指针是指该指针的值不是一个已经分配的内存地址
C.两个指向同类型地址的指针之间做减法一般是没有意义的
D.指针的指针占用的内存空间和其他指针占用的内存空间相同
解析：
B非法指针并不只是未分配的内存，而包括所有已经不能访问的内存，例如，指向已经返回的函数局部变量，越过数组边界的地址等。
C两个同类型指针相减有意义，这就是求差，但相加没有意义。
比如，两个数组元素一一对应，当我们已知A的X元素，而要找B中与之对应的Y时，就可以使用。
B + (X - A) 其中X - A就是同类型指针相减，这是有效也是唯一的作法。
2021-02-15
1.以下叙述中正确的是（）
正确答案: B 你的答案: C (错误)
A.用户自己定义的函数只能调用库函数
B.实用的C语言源程序总是由一个或多个函数组成
C.不同函数的形式参数不能使用相同名称的标识符
D.在C语言的函数内部，可以定义局部嵌套函数
解析 ：
A 选项中， " 用户自己定义的函数只能调用库函数 " 描述是不正确的，也可以调用自定义函数；
C 选项中，对于不同函数的形式参数可以使用相同名称的标识符；
D 选项中，关于函数的定义不可以嵌套 , 但函数的调用可以嵌套。
因此 B 选项正确。
2. 通过return语句，函数可以带回一个或一个以上的返回值。（）
正确答案: B 你的答案: A (错误)
A.正确
B.错误
解析：
只能有一个返回值.但是这个返回值可以是一个结构体或者是一个类,而结构体和类中可以容纳很多信息.也可以参考函数参数的方式来实现返回你所需要的信息,可以是多个
3.如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）
正确答案: D 你的答案: B (错误)
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.
4.下面的程序中， int32-t 表示一个有符号的 32 位整数，程序的入口是 main 函数，问最终 res 的结果是多少？
正确答案: D 你的答案: A (错误)
A.–(2^31+2^30+…+2^2+2^1+2^0)
B.0
C.-1
D.程序会死循环
解析：
以char为例
f(1,0):
a=2 b=-1
a=3 b=-2
…
a=127 b=-126
a=128 b=-127 溢出–>a=-128 b=-127 char范围:-128~127
return a+b:-128-127实际上是1(char范围)，继续循环
而原例为int_32t,临界情况 a+b: -232+(-232+1)=1,也继续循环。
因此死循环。
5.若整型变量a、b、c、d中的值依次为：1、4、3、2。则条件表达式a<b?a:c<d?c:d的值 ( ) 。
正确答案: A 你的答案: A (正确)
A.1
B.2
C.3
D.4
解析：
先判断
后面c<d?c:d;
因为c=3 d=2 所以 c<d?c:d;返回的值是2;
再判断
a<b?a:2;
因为a=1b=4 所以 最后返回的值是a ,也就是1
即最后的结果为1`
6.以下正确的表达式是（ ）。
正确答案: B 你的答案: B (正确)
A.s="computer";
B.*s="computer";
C.**s="computer";
D.*s='c';
解析：
s的类型是char**
s的类型是char
*s的类型是char
字符串字面量的类型是char
字符常量的类型是char。
假设s和s已经指向正确的位置，那么 A：char**和char不能隐式转换。 B：两边均为char型。正确。 C：char和char不能隐式转换。 D：char*和char不能隐式转换。 故正确答案是B。
7.语言中哪一种形式声明了一个指向char类型变量的指针p，p的值不可修改，但p指向的变量值可修改？
正确答案: C 你的答案: B (错误)
A.const char *p
B.char const *p
C.char*const p
D.const char *const p
解析：
const出现在 * 左边，如const char * p，表示p所指向的变量内容不可变，指针指向可以改变；
const出现在 * 右边，如char * const p，表示p是个常量指针，即不能指向其他变量，而指向的变量内容可变；
const出现在 * 左边和右边，如const char * const p，表示p的指向不能改变，指向的变量内容也不能改变。
8.下列定义数组的语句中正确的是（）。
正确答案: A 你的答案: A (正确)
A.#define size 10
char str1[size],str2[size+2];
B.char str[];
C.int num['10'];
D.int n=5; int a[n][n+2];
解析：
C的错误是单引号里面有2个字符.
D的错误在于，n是一个变量，若将 int n=5；改为const int n=5;则该选项将正确
9.正确答案: C 你的答案: C (正确)
A.3
B.4
C.5
D.以上都不是
解析：
指针按值传递
10.若执行fopen函数时发生错误，则函数的返回值是（）。
正确答案: B 你的答案: B (正确)
A.地址值
B.0
C.1
D.EOF
解析：
执行fopen函数时，如果文件打开成功，则返回该文件结构体的指针，如果打开失败（例如，读打开时文件不存在，写打开时文件不能创建），则返NULL（即0）。
2021-02-19
1. 假定有语句“ int b[10], ✳pb; ”，则不正确的赋值为 （ ）。
正确答案: B 你的答案: A (错误)
A.pb=b
B.pb=b[5]
C.pb=b+2
D.pb=&b[0]
解析：
pb是一个地址，b[5]是一个整型变量，明显不匹配
b[5]=*(b+5)
2. 以下叙述中正确的是（）
正确答案: D 你的答案: D (正确)
A.结构体类型中各个成分的类型必须是一致的
B.结构体类型中的成分只能是C语言中预先定义的基本数据类型
C.在定义结构体类型时，编译程序就为它分配了内存空间
D.一个结构体类型可以由多个称为成员（或域) 的成分组成
解析：
本题考查结构体类型，结构体类型中的成分可以是结构体，所以 B 选项错误，定义结构体时编译程序并不会给它分配内存空间，所以 C 选项错误，结构体中各个成分的类型可以是不一样的，所以 A 选项错误。
3. 函数strlen(“ASDFG\n”)的值是7。
你的答案: B (正确)
解析：
strlen()是计算字符串的长度，以\0’为字符串结束标记（故不计算\0）。
sizeof是关键字，计算的则是分配的数组str[] 所占的内存空间的大小，不受里面存储的内容影响（也就是会计算\0）
4.下面程序的运行结果是（）。
#include <stdio.h>
void main()
{
int a=1,b=10；
do
{b-=a；a++；}while (b–<0);
printf(“a=%d,b=%d\n”,a,b)；
}
正确答案: B 你的答案: B (正确)
A.a=3,b=11
B.a=2,b=8
C.a=1,b=-1
D.a=4,b=9
解析：
因a、b的初始值分别为1和10，进入循环体后，b的值为10-1，即为9,a增1变为2，再对while后面的表达式进行检测，此时先判断b<0为假，循环结束，再将b减1，即b变为8。故正确答案为B。
5.以下能正确定义一维数组的选项是 ( )
正确答案: D 你的答案: A (错误)
A.int a[5］={0,1,2,3,4,5}
B.char a={′A′,′B′,′C′}
C.int a[5]="0123"
D.char a[]={′0′,′1′,′2′,′3′,′4′,′5′,′＼0′}
解析：
A 定义了 5 个元素的数组，但是赋值的时候越界了
B 定义了 char 变量，用数组赋值
C 有争议，因为 C++ 中存在隐式转换，用 char 赋值给 int 会发生隐式转换， 取 char 的 ASCII 码进行赋值
D 就是定义字符串
6.以下叙述中正确的是（）
正确答案: C 你的答案: D (错误)
A.结构体数组名不能作为实参传给函数
B.结构体变量的地址不能作为实参传给函数
C.结构体中可以含有指向本结构体的指针成员
D.即使是同类型的结构体变量，也不能进行整体赋值
解析：
参考链表的链表结点的实现，会有一个指向下一个结点的指针。
7.若有 C 语言表达式 2+3*4+7/3, 以下选项中叙述正确的执行顺序是（ ）。
正确答案: B 你的答案: B (正确)
A.先执行3*4得12，再执行7/3得2.5，最后执行2+12+2.5得16.5
B.先执行3*4得12，再执行2+12得14，再执行7/3得2，最后执行14+2得16
C.先执行7/3得2，再执行3*4得12，再执行12+2得14，最后执行2+14得16
D.先执行2+3得5，再执行5*4得20，再执行20+7得27，最后执行27/3得9
解析：
这道题实际上考查了数据结构栈的实际应用----表达式求值
就此题而言，从左到右以此计算压栈，运算过程中应用到（运算符栈为OPTR，操作数为OPND，运算起止符#，#运算优先级小于一切操作符）:
你以为他考得是优先级，其实主要考的是数据结构。
表达式求值是数据结构中栈的经典应用，通过栈将中缀表达式转换成后缀表达式进行计算。因为中缀表达式不仅依赖于运算符的优先级，而且还要处理括号，而后缀表达式的运算符在操作符后，在后缀表达式中已考虑了运算符优先级，没有括号，只有操作数和运算符。
上表中描述了计算机中缀转后缀并同时计算的实际情况，了解了这个原理和过程后，就可以手动将题中的2+34+7/3手动转成后缀形式。
括号法：
1.按照优先级加括号 ((2+(34))+(7/3))
2.然后将括号中的操作符写在括号后((2(34*)+)(73/)+)
3.去掉括号234*+73/+ ，见数字就压栈，见操作符就弹出两个数然后把结果压入栈，以此类推，即可全部求解。
写在后面：
括号法将中缀转后缀然后结合栈计算只是理论上的表达式求解过程。计算机不可能先扫描一遍将中缀转后缀，然后再扫描后缀一遍求解。计算机实际处理过程是上表中所示，扫描中缀的同时利用后缀思想计算，一遍扫描后即得结果。
一个好的面试题是可以梯度的区分出面试者的能力水平。比如说这个题我改写一下。
写一个简单的程序求解2+3*4+7/3，你应该怎么写？
良：利用栈中缀转后缀，存后缀表达式，然后再扫描后缀表达式，求解。(为什么是良？对表达式求值的理解停留在PPT上，且没仔细看过书。)
优：一遍扫描，利用后缀思想边转换边计算
8.以下程序的输出的结果是（8）。
Int a=3；
main ()
{
int
s=0;
{ int a=5;s +=a++; }
s += a++; printf ("%d\n",s);
}
解析：
复合语句中有int a=5，这表明复合语句范围内重新定义了一个a，因此没有使用全局变量的a。
9.void main(void) {
char ✳s = “1314520”;
int v1 = 0, v2 = 0, v3 = 0, v4 =0;
for (int i = 0; s[i]; i++) {
switch(s[i]) {
default: v4++;e
case ‘1’: v1++;
case ‘2’: v2++;
case ‘3’: v3++;
}
}
printf("%d, %d, %d, %d", v4,v1,v2,v3)
}
正确答案: A 你的答案: C (错误)
A.3,5,6,7
B.7,7,7,7
C.7,2,1,1
D.0,2,1,1
解析：
char*s = “1314520”;
v1 = 0, v2 = 0, v3 = 0, v4 =0;
第一次循环：
i = 0，s[0]=1，switch(1)，进入case’1’: v1++,v1=1;因为没有break，所以继续执行，case’2’: v2++,v2=1; case’3’: v3++,v3=1; 执行i++，i=1;
第二次循环：
i = 1，s[1]=3，switch(3)，进入case’3’: v3++,v3=2; 执行i++，i=2;
第三次循环：
i = 2，s[2]=1， switch(1)，进入case’1’: v1++,v1=2;因为没有break，所以继续执行，case’2’: v2++,v2=2; case’3’: v3++,v3=3; 执行i++，i=4;
第四次循环：
i = 3，s[3]=4， switch(4)，进入default: v4++;v4=1；因为没有break，所以继续执行， case’1’: v1++,v1=3; case’2’: v2++,v2=3;
case’3’: v3++,v3=4;执行i++，i=4;
第五次循环：
i = 4，s[4]=5， switch(5)， 进入default: v4++;v4=2；因为没有break，所以继续执行，case’1’: v1++,v1=4;case’2’: v2++,v2=4;
case’3’: v3++,v3=5;执行i++，i=5;
第六次循环：
i = 5，s[5]=2， switch(2)， 进入case’2’: v2++,v2=5;因为没有break，所以继续执行， case’3’: v3++,v3=6; 执行i++，i=6;
第七次循环：
i = 6，s[6]=0，switch(0)，进入default: v4++;v4=3；因为没有break，所以继续执行case’1’: v1++,v1=5;case’2’: v2++,v2=6;
case’2’: v3++,v3=7; 执行i++，i=7; 跳出循环，打印v4,v1,v2,v3
10.下列关于内存分配和释放的函数及其区别描述正确的有？
正确答案: C D 你的答案: C (错误)
A.C++语言的标准内存分配函数：malloc，calloc，realloc，free等。
B.C中为new/delete函数。
C.malloc和calloc的区别是1块与n块的区别和初始化
D.realloc调用形式为(类型*)realloc(*ptr，size)：将ptr内存大小增大到size.
解析：
- malloc，calloc，realloc，free属于C函数库，而new/delete则是C++函数库；
- 多个-alloc的比较：
alloc：唯一在栈上申请内存的，无需释放；
malloc：在堆上申请内存，最常用；
calloc：malloc+初始化为0；
realloc：将原本申请的内存区域扩容，参数size大小即为扩容后大小，因此此函数要求size大小必须大于ptr内存大小。
2021-02-25
解析：
super关键字在子类内部使用，代表父类对象。 访问父类的属性 super.属性名 访问父类的方法 super.方法名() 子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()
解析：
synchronized 关键字 : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。
解析：
A a；声明 a ＝new A( )；实例化
解析：
public static void main()
解析：
'a’是个常数，不能赋值
解析：
数组长度在创建时就确定了，要改变数组长度只能重新创建新的数组，将原有数组复制到新的数组之中。这也是ArrayList扩容时候的效率低于LinkedList的原因。
解析：
Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char
解析：
jvm堆分为：新生代（一般是一个Eden区，两个Survivor区），老年代（old区）。
常量池属于 PermGen（方法区）
解析：
A.this指的是当前对象，类方法依附于类而不是对象this会编译出错
C.类方法中也可以调用其他类的类方法。同时可以通过创建对象来调用普通方法
D.类方法中可以创建对象，所以可以调用实例方法
public class Threads4{
public static void main(String[] args){
new Threads4().go();
}
public void go(){
Runnable r=new Runnable(){
public void run(){
System.out.print("foo");
}
};
Thread t=new Thread(r);
t.start();
}
}
解析：
A、ConcurrentHashMap实际上时 HashTable的升级版，使用segment来分段和管理锁，并不是synchronized;
B、 HashMap实现的接口有：Serializable, Cloneable, Map<K,V> ,没有实现Cllectio
C、Arrays.asList()方法返回的列表是Arrays.ArrayList类型的，并不是java.util.ArrayList；
public class Person{
private String name = "Person";
int age=0;
}
public class Child extends Person{
public String grade;
public static void main(String[] args){
Person p = new Child();
System.out.println(p.name);
}
}
解析：
一个java文件里，public 的类只能出现一个
public class Demo {
public static String sRet = "";
public static void func(int i)
{
try
{
if (i%2==0)
{
throw new Exception();
}
}
catch (Exception e)
{
sRet += "0";
return;
}
finally
{
sRet += "1";
}
sRet += "2";
}
public static void main(String[] args)
{
func(1);
func(2);
System.out.println(sRet);
}
}
解析：
public class SystemUtil{
public static boolean isAdmin(String userId){
return userId.toLowerCase()=="admin";
}
public static void main(String[] args){
System.out.println(isAdmin("Admin"));
}
}
解析：
equals和==的区别 ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
class Person {
String name = "No name";
public Person(String nm) {
name = nm;
}
}
class Employee extends Person {
String empID = "0000";
public Employee(String id) {
empID = id;
}
}
public class Test {
public static void main(String args[]) {
Employee e = new Employee("123");
System.out.println(e.empID);
}
}
解析：
JVM 内存可简单分为三个区：
1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）
2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）
3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）
Java 的垃圾回收器（GC）主要针对堆区
解析：
集合中线程安全的类有：vector，stack，hashtable，enumeration，除此之外均是非线程安全的类与接口
解析：
数组有length属性，字符串只有length()方法
解析：
解析：
局部内部类定义在一个方法或者一个作用域里，它类似方法中局部变量，不能有public、protected、private以及static修饰符
2021-03-09
解析：
在Java语言的异常处理中，finally块的作用就是为了保证无论出现什么情况，finally块里的代码一定会执行。
解析：
生成字符串的两个类String和StringBuffer中，前者生成的字符串是不变字符串，不能直接对它的内容进行修改，而后者生成的字符串是可变的，可以对其内容进行修改
解析：
数组的角标是从0开始的。从arr[0]到arr[arr.length-1]。
解析：
比较两个类是否相等，只有这两个类是由同一个类加载器加载才有意义。否则，即使这两个类是来源于同一个Class文件，只要加载它们的类加载器不同，那么这两个类必定不相等
解析：
extends表继承父类
implements表是实现接口
public class Test{
static int cnt = 6;
static{
cnt += 9;
}
public static void main(String[] args）{
System.out.println（“cnt =” + cnt);
}
static{
cnt /=3;
};
}
解析：
在JVM调用mian方法之前先用进行静态内容的初始化。顺序为：父类的静态变量， 父类的静态代码块 ，子类的静态变量，子类的静态代码块。
解析：
A选项应该说成父类的引用直接指向子类的对象，即向上转型；当子类的引用直接指向父类的对象时，则需要强制转换。
解析：
this()和super()都是构造器，this()调用本类构造器，super()调用父类构造器
解析：
数组定义后，默认元素为0
public class Test
{
public static int aMethod(int i)throws Exception
{
try{
return i / 10;
}
catch (Exception ex)
{
throw new Exception("exception in a Method");
} finally{
System.out.printf("finally");
}
}
public static void main(String [] args)
{
try
{
aMethod(0);
}
catch (Exception ex)
{
System.out.printf("exception in main");
}
System.out.printf("finished");
}
}
解析：
1、finally块一定会执行，无论是否try…catch。
2、finally前有return，会先执行return语句，并保存下来，再执行finally块，最后return。
3、finally前有return、finally块中也有return，先执行前面的return，保存下来，再执行finally的return，覆盖之前的结果，并返回。
class Parent {
private int data;
public Parent(int d){ data = d; }
}
class Child extends Parent{
String name;
public Child(String s, int d){
___________________
name = s;
}
}
解析：
子父类存在同名成员时，子类中默认访问子类的成员，可通过super指定访问父类的成员，格式：super.xx (注：xx是成员名)；
解析：
重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同 也可以不相同。 无法以 返回型别 作为重载函数的区分标准。而且编译的时候只有返回值不同，会报错。及使不报错，运行时无法区分调用哪个方法
解析：
看不懂。。。
解析：
short类型转为byte类型出错
a1*a2结果为int类型，转为byte类型出错
解析：
两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。
解析：
RandomAccessFile 可以通过 seek(long pos) 方法去移动文件指针进行追加更新写入.
OutputStream() 是一个抽象类 不能直接实例化去写入
DataOutputStream() 也无法追加写入
解析：
DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的
解析：
优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=“exlicit” 避免查处所有对象
7.消除大表，使用二级缓存
解析：
先进后出
解析：
解析：
Servlet过滤器的配置包括两部分：
第一部分是过滤器在Web应用中的定义，由元素表示，包括和两个必需的子元素
第二部分是过滤器映射的定义，由元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL。
解析：
“abc”保存在常量池，str引用的对象保存在堆里
解析：
看不懂。。。
解析：
二维数组定义，一维长度必须定义，二维可以后续定义
解析：
A、java中类的加载有5个过程，加载、验证、准备、解析、初始化；这便是类加载的5个过程，而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种类加载器，引导（Bootstrap）类加载器、扩展（Extension）类加载器、系统（System）类加载器（也称应用类加载器）。A正确
B、一个类，由不同的类加载器实例加载的话，会在方法区产生两个不同的类，彼此不可见，并且在堆中生成不同Class实例。所以B前面部分是正确的，后面接口的部分真的没有尝试过，等一个大佬的讲解吧；
C、类加载器是肯定要保证线程安全的；C正确
D、装载一个不存在的类的时候，因为采用的双亲加载模式，所以强制加载会直接报错，D错误
java.lang.SecurityException: Prohibited package name: java.lang
E、双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，所以默认是父装载，E正确
F、自定义类加载器实现 继承ClassLoader后重写了findClass方法加载指定路径上的class，F错误
解析：
A：静态方法是一个属于类而不属于对象(实例)的方法。（√）
B：静态方法只能访问静态数据。无法访问非静态数据(实例变量)。（√）
C：静态方法只能调用其他静态方法，不能从中调用非静态方法。（√）
D：静态方法不能通过类名直接访问，也不需要任何对象。（×） 静态方法可以直接用类名访问
解析：
JAVA的初始化顺序：
父类的静态成员初始化>父类的静态代码块>子类的静态成员初始化>子类的静态代码块>父类的代码块>父类的构造方法>子类的代码块>子类的构造方法
解析：
字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同；字符流和字节流都有缓冲流
2021-03-17
解析：
in进入，out出去，err错误，exit退出
解析：
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。
解析：
Java文件经过JVM编译成字节码文件，即.class文件，将字节码文件在不同的操作系统中运行时，操作系统再将字节码文件编译成机器码文件。
解析：
自动类型转换遵循下面的规则：
1.若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。
2.转换按数据长度增加的方向进行，以保证精度不降低。例如int型和long型运算时，先把int量转成long型后再进行运算。
3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
4.char型和short型参与运算时，必须先转换成int型。
5.在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型将转换为左边变量的类型。如果右边表达式的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度。
解析：
转载 秀秀秀！！！！！
以前我是堆，你是栈
你总是能精准的找到我，给我指明出路
后来有一天我明白了
我变成了栈，你却隐身堆海
我却找不到你了，空指针了
我不愿意如此，在下一轮full gc前
我找到了object家的finalize
又找到了你，这次我不会放手
在世界重启前，一边躲着full gc一边老去
解析：
字节型 ： 0 -27—-27-1 byte b=10;
字符型 ： ‘ \u0000′ 0—-2^16-1 char c=’c’ ;
short : 0 -215—-215-1 short s=10;
int : 0 -231—-231-1 int i=10;
long : 0 -263—-263-1 long o=10L;
float : 0.0f -231—-231-1 float f=10.0F
double : 0.0d -263—-263-1 double d=10.0;
boolean: false true\false boolean flag=true;
解析：
没学到这，先放着
解析：
synchronized: 具有原子性，有序性和可见性；（三个都有）
volatile：具有有序性和可见性（缺一个原子性）
解析：
weblogic中开发消息Bean时的persistent与non-persisten的差别：
persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来。
non－persistent方式的消息将被丢弃。
解析：
运行时只会抛出一个异常
解析：
对于同一个父类方法，不同的子类会有不同的实现方式
解析：
1：String获取长度用的是length（）方法，而数组类型我们直接用属性length获取长度，所以String[]数组类型我们应该用length获取长度；
2：总结来说，因为原字符串不包含分隔符，所以直接返回原字符串，分割出来只有一个空的字符串数组，所以结果是1.
解析：
是避免数据覆盖的可能，而不是数据覆盖类型
解析：
先放着
解析：
1、boolean类型只有两个直接量值:true和false.
2、除成员变量会有默认初始值外，其他变量必须在第一次使用之前初始化
解析：
内存引用地址，是指栈中存放的地址，来指向堆中的某个位置。
int 是基本类型，数据直接存放在栈中，不存在内存引用地址的说法
解析：
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态
2021-03-25
解析：
java为单继承，但可以实现多个接口
解析：
接口的方法都是 public abstract 变量都是public static final的
解析：
Vector是实现了List接口，是一个线程安全的List
解析：
包含抽象方法的类必须定义为抽象类； 抽象类不一定包含抽象方法，也可以包含普通方法； 抽象类有构造方法，但是不能new一个对象； 抽象类只支持单继承。
解析：
finally子句一般是用来清理这些资源的。
解析：
init 初始化，start启动运行，paint 窗口最小化等时候需要暂停，stop 停止，destory 销毁;
解析：
HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
解析：
return i++, 先返回i，然后i+1；
第一次调用getNext()方法时，返回的是1，但此时i=2；
第二次调用 getNext()方法时，返回的是2，但此时i=3；
第三次调用 getNext()方法时，返回的是3，但此时i=4；
解析：
Java程序初始化顺序：
父类的静态代码块
子类的静态代码块
父类的普通代码块
父类的构造方法
子类的普通代码块
子类的构造方法
解析：
Vector & ArrayList 的主要区别
1） 同步性:Vector是线程安全的，也就是说是同步的 ，而ArrayList 是线程序不安全的，不是同步的 数2。
2）数据增长:当需要增长时,Vector默认增长为原来一倍 ，而ArrayList却是原来的50% ，这样,ArrayList就有利于节约内存空间。
如果涉及到堆栈，队列等操作，应该考虑用Vector，如果需要快速随机访问元素，应该使用ArrayList 。
解析：
解析：
Ant 没有生命周期，必须定义目标和目标之间的依赖
解析：
子类可以访问父类的静态，但不能调用
解析：
private方法是可以继承的，只是不能调用
解析：
当isErrorPage ="false"时，用errorPage=“error.jsp”(isErrorPage默认是false)
当isErrorPage ="true"时,页面会直接使用exception
解析：
Servlet生命周期分成3个阶段：
1）初始化阶段：调用init方法
2）响应客户请求：调用service
3）终止：调用destory方法
解析：
A Class类在java.lang包
B 动态代理技术可以动态创建一个代理对象，反射不行
C 反射访问私有成员时，Field调用setAccessible可解除访问符限制
D CGLIB实现了字节码修改，反射不行
E 反射会动态创建额外的对象，比如每个成员方法只有一个Method对象作为root，他不胡直接暴露给用户。调用时会返回一个Method的包装类
F 反射带来的效率问题主要是动态解析类，JVM没法对反射代码优化。
解析：
等我学了再来
2021-04-06
解析：
不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。
解析：
1如果是本类使用，可以直接就用静态变量名。2如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。3如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名。
解析：
等学了后再来看
解析：
java中没有include关键字，导包用import
由于代码中使用了printWriter 类，所以要导入此类Import java.io.PrintWriter;
解析：
解析：
采用命令行“ java Test one two three ”调用
其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；
System.out.println(args[0]);表示输出第一个元素，故为one；
解析：
Servlet是线程不安全的，在Servlet类中可能会定义共享的类变量，这样在并发的多线程访问的情况下，不同的线程对成员变量的修改会引发错误。
解析：
static为成员变量或函数，在类初始化是加载完成，可以被成员函数调用或访问
解析：
完全没学过。。。
解析：
java.util.*，只能读取其目录下的类，不能读取其子目录下的类。
因为其根目录和子目录下可能有同名类，若都能读取，则会混淆。
解析：
补码为1000 0011
解析：
JDK 1.8时，抽象类的方法默认访问权限变为default
解析：
重载的概念是：
方法名称相同，参数个数、次序、类型不同
因此重载对返回值没有要求，可以相同，也可以不同
但是如果参数的个数、类型、次序都相同，方法名也相同，仅返回值不同，则无法构成重载
解析：
线程安全的类有hashtable concurrentHashMap synchronizedMap
解析：
解析：
1.sleep会使当前线程睡眠指定时间，不释放锁
2.yield会使当前线程重回到可执行状态，等待cpu的调度，不释放锁
3.wait会使当前线程回到线程池中等待，释放锁，当被其他线程使用notify，notifyAll唤醒时进入可执行状态
4.当前线程调用 某线程.join（）时会使当前线程等待某线程执行完毕再结束，底层调用了wait，释放锁
109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
