零、观前提示此文章为网上转载收集而成，非原创文章，请尊重别人的劳动成果，让分享成为一种美德，欢迎转载。另外，文章在表述和代码方面如有不妥之处，欢迎批评指正。原文链接：http://www.soaspx.com/dotnet/csharp/csharp_20120104_8511.html参考：https://www.cnblogs.com/jintianhu/archive/2010/11/19/1881494.html收集整合xiaoxiaoUnity@163.com
---转载收集整合 小小Unity
通过本篇博客，我会和大家一起学习《C#Lock的使用》，希望本篇博客能为大家的工作过程中带来一些帮助与启发。如果觉得本篇博客对您有帮助，可以扫码添加以下公众号，公众号会推送一些与Unity相关的精品文档与精品专栏以及一些资源一、Lock定义lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。在多线程中，每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是几个线程同时执行一个函数，导致数据的混乱，产生不可预料的结果，因此我们必须避免这种情况的发生。而在.NET中最好了解一下进程、应用域和线程的概念，因为Lock是针对线程一级的，而在.NET中应用域是否会对Lock起隔离作用，我的猜想是，即不在同一应用域中的线程无法通过Lock来中断；另外也最好能了解一下数据段、代码段、堆、栈等概念。在C# lock关键字定义如下：lock（expression） statement_block，其中expression代表你希望跟踪的对象，通常是对象引用。如果你想保护一个类的实例，一般地，你可以使用this；如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可以了。而statement_block就是互斥段的代码，这段代码在一个时刻内只可能被一个线程执行。二、简单解释一下执行过程先来看看执行过程，代码示例如下：private static object ojb = new object();
lock ( obj )
{
/* 锁定运行的代码段 */
}
假设线程A先执行，线程B稍微慢一点。线程A执行到lock语句，判断obj是否已申请了互斥锁，判断依据是逐个与已存在的锁进行object.ReferenceEquals比较(此处未加证实)，如果不存在，则申请一个新的互斥锁，这时线程A进入lock里面了。这时假设线程B启动了，而线程A还未执行完lock里面的代码。线程B执行到lock语句，检查到obj已经申请了互斥锁，于是等待;直到线程A执行完毕，释放互斥锁，线程B才能申请新的互斥锁并执行lock里面的代码。三、Lock的对象选择问题接下来说一些lock应该锁定什么对象。1、为什么不能lock值类型比如lock(1)呢?lock本质上Monitor.Enter，Monitor.Enter会使值类型装箱，每次lock的是装箱后的对象。lock其实是类似编译器的语法糖，因此编译器直接限制住不能lock值类型。退一万步说，就算能编译器允许你lock(1)，但是object.ReferenceEquals(1,1)始终返回false(因为每次装箱后都是不同对象),也就是说每次都会判断成未申请互斥锁，这样在同一时间，别的线程照样能够访问里面的代码，达不到同步的效果。同理lock((object)1)也不行。2、为什么不能Lock字符串那么lock(“xxx”)字符串呢?MSDN上的原话是：锁定字符串尤其危险，因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例，就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。因此，只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁，就将锁定应用程序中该字符串的所有实例。3、MSDN推荐的Lock对象通常，最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如，如果该实例可以被公开访问，则 lock(this) 可能会有问题，因为不受控制的代码也可能会锁定该对象。这可能导致死锁，即两个或更多个线程等待释放同一对象。出于同样的原因，锁定公共数据类型(相比于对象)也可能导致问题。而且lock(this)只对当前对象有效，如果多个对象之间就达不到同步的效果。而自定义类推荐用私有的只读静态对象，比如：private static readonly object obj = new object();
为什么要设置成只读的呢?这时因为如果在lock代码段中改变obj的值，其它线程就畅通无阻了，因为互斥锁的对象变了，object.ReferenceEquals必然返回false。4、lock(typeof(Class))与锁定字符串一样，范围太广了。四、特殊问题：Lock（this）等的详细解释在以前编程中遇到lock问题总是使用lock(this)一锁了之，出问题后翻看MSDN突然发现下面几行字：
通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。常见的结构 lock (this)、lock (typeof (MyType)) 和 lock (“myLock”) 违反此准则：如果实例可以被公共访问，将出现C# lock this问题。如果 MyType 可以被公共访问，将出现 lock (typeof (MyType)) 问题。由于进程中使用同一字符串的任何其他代码将共享同一个锁，所以出现 lock(“myLock”) 问题。
来看看C# lock this问题:如果有一个类Class1，该类有一个方法用lock(this)来实现互斥：public void Method2()
{
lock ( this )
{
System.Windows.Forms.MessageBox.Show( "Method2End" );
}
}
如果在同一个Class1的实例中,该Method2能够互斥的执行。但是如果是2个Class1的实例分别来执行Method2,是没有互斥效果的。因为这里的lock,只是对当前的实例对象进行了加锁。Lock(typeof(MyType))锁定住的对象范围更为广泛，由于一个类的所有实例都只有一个类型对象（该对象是typeof的返回结果），锁定它，就锁定了该对象的所有实例，微软现在建议，不要使用lock(typeof(MyType)),因为锁定类型对象是个很缓慢的过程，并且类中的其他线程、甚至在同一个应用程序域中运行的其他程序都可以访问该类型对象，因此，它们就有可能代替您锁定类型对象，完全阻止您的执行，从而导致你自己的代码的挂起。锁住一个字符串更为神奇，只要字符串内容相同，就能引起程序挂起。原因是在.NET中，字符串会被暂时存放，如果两个变量的字符串内容相同的话，.NET会把暂存的字符串对象分配给该变量。所以如果有两个地方都在使用lock(“my lock”)的话，它们实际锁住的是同一个对象。到此，微软给出了个lock的建议用法：锁定一个私有的static 成员变量。.NET在一些集合类中（比如ArrayList,HashTable，Queue，Stack）已经提供了一个供lock使用的对象SyncRoot，用Reflector工具查看了SyncRoot属性的代码，在Array中，该属性只有一句话:return this,这样和lock array的当前实例是一样的。ArrayList中的SyncRoot有所不同get{ if ( this._syncRoot == null )
{
Interlocked.CompareExchange( refthis._syncRoot, newobject(), null );
}
returnthis._syncRoot; }
其中Interlocked类是专门为多个线程共享的变量提供原子操作（如果你想锁定的对象是基本数据类型，那么请使用这个类），CompareExchange方法将当前syncRoot和null做比较，如果相等，就替换成new object()，这样做是为了保证多个线程在使用syncRoot时是线程安全的。集合类中还有一个方法是和同步相关的：Synchronized，该方法返回一个对应的集合类的wrapper类，该类是线程安全的，因为他的大部分方法都用lock来进行了同步处理，比如Add方法：publicoverridevoidAdd( objectkey, objectvalue )
{
lock ( this._table.SyncRoot )
{ this._table.Add( key, value );}
}
这里要特别注意的是MSDN提到：
从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。即使一个集合已进行同步，其他线程仍可以修改该集合，这将导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合：
QueuemyCollection = newQueue();
lock ( myCollection.SyncRoot )
{
foreach ( ObjectiteminmyCollection )
{
/* Insertyourcodehere. */
}
}
最后注意：应避免锁定 public 类型，否则实例将超出代码的控制范围。常见的结构 lock (this)、lock (typeof (MyType)) 和 lock (“myLock”) 违反此准则： .1.如果实例可以被公共访问，将出现 lock (this) 问题；2.如果 MyType 可以被公共访问，将出现 lock (typeof (MyType)) 问题；3.由于进程中使用同一字符串的任何其他代码将共享同一个锁，所以出现 lock(“myLock”) 问题；最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。

1.在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为A.隐藏B.重写C.重载D.Java不支持此特性 方法重写：在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。
方法重载能改变返回值类型，因为它和返回值类型无关。
Override：方法重写
Overload：方法重载
所以C 2.覆盖与重载的关系是A.覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中B.覆盖方法和重载方法都可以不同名，也可以同名C.final修饰的方法可以被覆盖，但不能被重载D.覆盖与重载是同一回事在同名的前提下才有重载和覆写，不重名就是两个方法了final修饰的方法可以被继承，不可以覆写。重载与final没有关系重写与重载两个不同A3.有以下程序片段且Interesting不是内部类，下列哪个选项不能插入到行11.
2.public class Interesting{
3. // 省略代码
4.}
A.import java.awt.*;B.package mypackage;C.class OtherClass{ }D.public class MyClass{ }在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public classD4.在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的A.管道B.消息队列C.高速缓存数据库D.套接字要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工，虽然可以双向，但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解A5.以下哪项陈述是正确的？A.垃圾回收线程的优先级很高，以保证不再 使用的内存将被及时回收B.垃圾收集允许程序开发者明确指定释放 哪一个对象C.垃圾回收机制保证了JAVA程序不会出现 内存溢出D.进入”Dead”状态的线程将被垃圾回收器回收E.以上都不对垃圾回收在jvm中优先级相当相当低垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出进入DEAD的线程，它还可以恢复，GC不会回收所以E6.given the following code,what will be the outputclass Value{
public int i=15;
}
public class Test{
public static void main(String argv[]){
Test t=new Test( );
t.first( );
}
public void first( ){
int i=5;
Value v=new Value( );
v.i=25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value( );
v = val;
System.out.println(v.i+" "+i);
}
}
A.15 0 20B.15 0 15C.20 0 20D.0 15 207.假定str0,…,str4后序代码都是只读引用。Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为static String str0="0123456789";
static String str1="0123456789";
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;
A.5B.10C.15D.20方法区：主要存储结构信息的地方，比如方法体，同时也是存储静态变量，以及静态代码块的区域，构造函数，常量池，接口初始化等等方法区物理上还是在堆中，是在堆的持久代里面。堆有年轻代 (由一个Eden区和俩个survivor区组成)，老年代，持久代。新创建的对象都在年轻代的Eden区，经过一次JC收集后，存活下来的会被复制到survivor区(一个满了，就全部移动到另外一个大的中，但要保证其中一个survivor为空)，经过多次JC后，还存活的对象就被移到老年代了。持久代就是经常说的方法区里面存放类信息，常量池，方法等static String str1=“0123456789”;是放在方法区里。也就是持久代，题目中已经说了，不包含持久代，所以剩余空间为5+5+5=15C8.Java 多线程有几种实现方法？A.继承Thread类B.实现Runnable接口C.实现Thread接口D.以上都不正确AB外还有一种方法实现Callable接口9.下列说法正确的是（）A.我们直接调用Thread对象的run方法会报异常，所以我们应该使用start方法来开启一个线程B.一个进程是一个独立的运行环境，可以被看做一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源C.synchronized可以解决可见性问题，volatile可以解决原子性问题D.ThreadLocal用于创建线程的本地变量，该变量是线程之间不共享的volatile与synchronized的区别
volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.volatile仅能实现变量的修改可见性,但不具备原子特性,而synchronized则可以保证变量的修改可见性和原子性.volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞.volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化.BD10.下列哪个选项是错误的A.一个文件中只能有一个public class。B.一个文件中可以有多个类。C.一个类中可以有两个main方法。D.若类中只含一个main方法，则必须是public的外部类为public，还可以有public的内部类 A错BC对AD错11.final方法等同于private方法A.对B.错private方法只可以在类的内部使用，在类外根本访问不到而final方法可以在类外访问，但是不可以重写该方法，就是说可以使用该方法的功能但是不可以改变其功能，这就是private方法和final方法的最大区别B12.以下对继承的描述错误的是A.Java中的继承允许一个子类继承多个父类B.父类更具有通用性，子类更具体C.Java中的继承存在着传递性D.当实例化子类时会递归调用父类中的构造方法java类只能单继承 但可以实现多个接口接口可以继承多个A错13.在java中，无论在何处调用，使用静态属性必须以类名做前缀A.正确B.错误如果是本类使用，可以直接就用静态变量名如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名B14.Java是从（）语言改进重新设计A.AdaB.C++C.PascalD.BASICB15.关于以下application,说法正确是什么？public class Test {
static int x=10;
static {x+=5;}
public static void main(String[] args) //4
{
System.out.println("x="+x);
}
static{x/=3;};
}//9
A.4行与9行不能通过编译，因为缺少方法名和返回类型B.编译通过，执行结果是：x=5C.编译通过，执行结果是：x=3D.9行不能通过编译，因为只能有一个静态初始化器首先初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化然后初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化其次初始化父类的普通成员变量和代码块，再执行父类的构造方法最后初始化子类的普通成员变量和代码块，再执行子类的构造方法对象初始化时，先给对象的属性赋默认值，然后调用构造方法B16.指出以下程序运行的结果是public class Example{
String str=new String("good");
char[]ch={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
str="test ok";
ch[0]='g';
}
}
A.good and abcB.good and gbcC.test ok and abcD.test ok and gbc值传递所以B17.在Java中，关于HashMap类的描述，以下错误的是A.HashMap使用键/值得形式保存数据B.HashMap 能够保证其中元素的顺序C.HashMap允许将null用作键D.HashMap允许将null用作值ACD对HashMap不能保证元素的顺序HashMap线程不安全，Hashtable线程安全18.以下代码执行后输出结果为public class Test
{
public static Test t1 = new Test();
{
System.out.println("blockA");
}
static
{
System.out.println("blockB");
}
public static void main(String[] args)
{
Test t2 = new Test();
}
}
A.blockAblockBblockAB.blockAblockAblockBC.blockBblockBblockAD.blockBblockAblockB静态块：用static申明，JVM加载类时执行，仅执行一次构造块：类中直接用{}定义，每一次创建对象时执行执行顺序优先级：静态块>main()>构造块>构造方法静态块按照申明顺序执行，先执行Test t1 = new Test()调用了构造块所有先输出blockA，然后执行静态块，输出blockB，最后执行main方法中的Test t2 = new Test();输出blockA19.下面为true的是Integer i = 42;
Long l = 42l;
Double d = 42.0;
A.(i == l)B.(i == d)C.(l == d)D.i.equals(d)E.d.equals(l)F.i.equals(l)G.l.equals(42L)G20.关于 访问权限说法正确 的是A.类定义前面可以修饰public,protected和privateB.内部类前面可以修饰public,protected和privateC.局部内部类前面可以修饰public,protected和privateD.以上说法都不正确这题不严谨…具体看我的内部类的博客21.以下二维数组声明合法的是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]int [][] table = new int[2][2];
int [][] table = new int[2][];
int [] table [] = new int[2][2];
int [] table [] = new int[2][];
//都是正确的 new int[2][];
C22.关于抽象类叙述正确的是？A.抽象类不能实现接口B.抽象类必须有“abstract class”修饰C.抽象类必须包含抽象方法D.抽象类也有类的特性，可以被实例化抽象类是可以实现接口的，而且抽象类也可以继承自抽象类抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含抽象类和接口都是不能被实例化的，只有具体的类才可以被实例化B23.若所用变量都已正确定义，以下选项中，非法的表达式是A.a!= 4
b==1
B.’a’ % 3
C.’a’ = 1/3
D.’A’ + 32
'a’是个常数，不能赋值 所以C24.下列哪些语句关于内存回收的说明是正确的?A.程序员必须创建一个线程来释放内存B.内存回收程序负责释放无用内存C.内存回收程序允许程序员直接释放内存D.内存回收程序可以在指定的时间释放内存对象JVM一旦启动，就会创建一个守护线程来监测是否需要有对象内存被释放内存回收程序无法直接释放不可以指定时间，System.gc()，只是提醒JVM可以进行一次Full GC，但是什么时候真正执行，还是不知道的B对25.指出下列程序运行的结果public class Example{
String str=new String("tarena");
char[]ch={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
str="test ok";
ch[0]='g';
}
}
A.tarena and abcB.tarena and gbcC.test ok and abcD.test ok and gbcjava中只有值传递 所以B26.下面代码的运行结果是public static void main(String[] args){
String s;
System.out.println("s="+s);
}
A.代码编程成功，并输出”s=”B.代码编译成功，并输出”s=null”C.由于String s没有初始化，代码不能编译通过。D.代码编译成功，但捕获到NullPointException异常局部变量没有默认值 s没有初始化 所以C27.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有package NowCoder;
class Test {
public static void hello() {
System.out.println("hello");
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}
A.能编译通过，并正确运行B.因为使用了未初始化的变量，所以不能编译通过C.以错误的方式访问了静态方法D.能编译通过，但因变量为null，不能正常运行因为Test类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法所以A28.对于JVM内存配置参数-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
其最小内存值和Survivor区总大小分别是（）A.5120m，1024mB.5120m，2048mC.10240m，1024mD.10240m，2048m-Xmx：最大堆大小-Xms：初始堆大小-Xmn:年轻代大小-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。-Xms初始堆大小即最小内存值为10240m所以D29.在java中，下列对继承的说法，正确的是A.子类能继承父类的所有成员B.子类继承父类的非私有方法和状态C.子类只能继承父类的public方法和状态D.子类只能继承父类的方法子类从其父类继承所有成员（字段，方法和嵌套类）。 构造函数不是成员，所以它们不被子类继承，但是可以从子类调用超类的构造函数A30.给定以下JAVA代码，这段代码运行后输出的结果是public class Test
{
public static int aMethod(int i)throws Exception
{
try{
return i/10;
}
catch (Exception ex)
{
throw new Exception("exception in a aMethod");
}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");
}
}
A.exception in main finishedB.finally finishedC.exception in main finallyD.finally exception in main finally进入main方法->try->aMethod(0)->return 0/10;这里注意并没有出现异常所以执行finally打印finally，返回的时候也并没有异常，所以不会打印exception in main然后按照顺序执行然后打印finished所以B31.设有下面一段代码class
Student
extends
Person {
long
id;
// 身份证号
int
score;
// 入学总分
String
name;
// 姓名
int
getScore(){
return
score;
}
}
问：类 Person 和类 Student 的关系是（ ）A.包含关系B.继承关系C.关联关系D.无关系，上述类定义有语法错误B32.关于以下程序代码的说明正确的是public class HasStatic {// 1
private static int x = 100;// 2
public static void main(String args[]) {// 3
HasStatic hsl = new HasStatic();// 4
hsl.x++;// 5
HasStatic hs2 = new HasStatic();// 6
hs2.x++;// 7
hsl = new HasStatic();// 8
hsl.x++;// 9
HasStatic.x--;// 10
System.out.println(" x=" + x);// 11
}
}
A.程序通过编译，输出结果为:x=102B.程序通过编译，输出结果为:x=103C.10行不能通过编译.因为x星私有静态变量D.5行不能通过编译.因为引用了私有静态变量同一个类内，private变量可以访问，所以CD错。由于x是static的，存贮在类内，而不是对象内，所以++、–操作的是同一个变量所以A33.下列关于计算机系统和Java编程语言的说法，正确的是A.计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。B.Java语言编写的程序源代码可以不需要编译直接在硬件上运行。C.在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。D.Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。计算机系统由硬件系统和软件系统组成C34.如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？A.protected void setColor() { …}B.void setColor() { …}C.public void setColor() { …}D.以上语句都可以用在类BlueGlass中JAVA 子类重写继承的方法时,不可以降低方法的访问权限 所以C35.在Java图形用户界面编程中，如果需要显示信息，一般是使用__________类的对象来实现A.JLabelB.JButtonC.JTextAreaD.JtextField从上到下分别是标签 按钮 文本(多行文本) 文本(单行文本)所以A36.下列哪项不属于jdk1.6垃圾收集器A.Serial收集器B.parNew收集器C.CMS收集器D.G1收集器D37.下面有关struts1和struts2的区别，描述错误的是？A.Struts1要求Action类继承一个抽象基类。Struts 2 Action类可以实现一个Action接口B.Struts1 Action对象为每一个请求产生一个实例。Struts2 Action是单例模式并且必须是线程安全的C.Struts1 Action 依赖于Servlet API，Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试D.Struts1 整合了JSTL，Struts2可以使用JSTL，但是也支持OGNLservlet是单例的 但是Struts2是多例的 所以B38.下面哪一项不属于优化Hibernate所鼓励的？A.使用单向一对多关联，不使用双向一对多B.不用一对一，用多对一取代C.配置对象缓存，不使用集合缓存D.继承类使用显式多态Hibernate鼓励使用双向一对多关联，不使用单向一对多关联。单向一对多关联映射是在one端维护关系的，必须先保存many端后才可以保存one端，所以在保存many端时该端不知道one端是否存在相应的数据，所以只能将维护的关系字段设置为null，如果为非空则无法保存。因为是one端维护关系，所以在保存one端时，会发出多余的update语句维护many端的外键关系A39.面向对象的程序设计语言具有（）等共同特性A.封装性B.多态性C.简单性D.复杂性E.继承性ADE40.下面关于Applet的说法是正确的是A.Applet可以在带有Java解释器的浏览器中运行B.Applet类必须继承java.applet.AppletC.Applet可以访问本地文件D.Applet是Object类的子类ABCD 过时的知识 了41.有这么一段程序public class Test{
public String name="abc";
public static void main(String[] args){
Test test=new Test();
Test testB=new Test();
System.out.println(test.equals(testB)+","+test.name.equals(testB.name));
}
}
请问以上程序执行的结果是A.true,trueB.true,falseC.false,trueD.false,falseequals没重写时候和==一样，比较的是对象的地址而Test没重写 而String是重写了的所以C42.下列外部类定义中，不正确的是A.class x { … }B.class x extends y { … }C.static class x implements y1,y2 { … }D.public class x extends Applet { … }内部类可以是静态static的，也可用public，default，protected和private修饰外部类的修饰符只能是public，abstract，final所以C43.下列哪种异常是检查型异常，需要在编写程序时声明A.NullPointerExceptionB.ClassCastExceptionC.FileNotFoundExceptionD.IndexOutOfBoundsException粉红色的是受检查的异常(checked exceptions),其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.受检查的异常必须在编译时被捕捉处理,命名为 Checked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守.绿色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如 空指针,被0除而声明为Error的，则属于严重错误，如系统崩溃、虚拟机错误、动态链接失败等，这些错误无法恢复或者不可能捕捉，将导致应用程序中断，Error不需要捕捉。所以C44.下列代码的输出结果是_____boolean b=true?false:true==true?false:true;
System.out.println(b);
A.trueB.falseC.nullD.空字符串B45.以下哪项不属于java类加载过程A.生成java.lang.Class对象B.int类型对象成员变量赋予默认值C.执行static块代码D.类方法解析类的加载包括：加载，验证，准备，解析，初始化生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员C这个会调用。可以用反射试验类方法解析发生在解析过程B46.It is an important feature of the Java language that it always provides a default constructor to a class.A.对B.错总是为一个类提供了一个默认的构造函数是Java语言的一个重要特性B(只有在不显示声明构造方法时，系统才提供默认无参构造方法)47.Java数据库连接库JDBC用到哪种设计模式?A.生成器B.桥接模式C.抽象工厂D.单例模式桥接模式
定义 ：将抽象部分与它的实现部分分离，使它们都可以独立地变化意图 ：将抽象与实现解耦JDBC连接 数据库 的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不动，原因就是JDBC提供了统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了48.下面代码将输出什么内容public class SystemUtil{
public static boolean isAdmin(String userId){
return userId.toLowerCase()=="admin";
}
public static void main(String[] args){
System.out.println(isAdmin("Admin"));
}
}
A.trueB.falseC.1D.编译错误在源码中 toLowerCase 是重新 new String()而==对于引用类型来说 比较的是地址B49.在程序代码中写的注释太多，会使编译后的程序尺寸变大A.对B.错注释是给人看的，不是给机器看的 B50.下面几个关于Java里queue的说法哪些是正确的（）？A.LinkedBlockingQueue是一个可选有界队列，不允许null值B.PriorityQueue，LinkedBlockingQueue都是线程不安全的C.PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）D.PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列，该队列的元素遵循FIFO原则AC51.面向对象程序设计语言的三个基本特征是封装、继承、多态A.正确B.错误A52.下列程序段执行后t3的结果是（）int t1=2, t2=3, t3;
t3=t1<t2?t1:(t2+t1);
A.2B.4C.5D.6三目运算符 A53.以下程序运行的结果为（）public class Example extends Thread{
@Override
public void run(){
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.print("run");
}
public static void main(String[] args){
Example example=new Example();
example.run();
System.out.print("main");
}
}
A.run mainB.main runC.mainD.runE.不能确定这个类虽然继承了Thread类，但是并没有真正创建一个线程。创建一个线程需要覆盖Thread类的run方法，然后调用Thread类的start()方法启动这里直接调用run()方法并没有创建线程，跟普通方法调用一样，是顺序执行的所以A54.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');
}
}
}
A.ABDCBDCBB.ABCDABCDC.Compilation fails.D.An exception is thrown at runtime.for(条件1;条件2;条件3) {
//语句
}
执行顺序是条件1->条件2->语句->条件3->条件2->语句->条件3->条件2........
如果条件2为true，则一直执行。如果条件2位false，则for循环结束
A55.如果要建立一个java.scut.computer的包，叙述正确的是？A.只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行B.只需在代码中加入“package java.scut;”一个语句C.必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句D.在代码中，不一定是第一句，只要是类定义前，加入package语句即可A56.下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是A.实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。B.局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值C.类变量指的是用static修饰的属性D.final变量指的是用final 修饰的变量局部变量必须有初始值57.URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。A.http://www.123.comB.””C.nullD.抛出异常不管网址是否存在，最后都会返回该网址的一个连接，打印出来就是该网址所以A58.final、finally和finalize的区别中，下述说法正确的有A.final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。B.finally是异常处理语句结构的一部分，表示总是执行。C.finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。D.引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。AB使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的finalize方法，这个选项错就错在，这个方法一个对象只能执行一次，只能在第一次进入被回收的队列，而且对象所属于的类重写了finalize方法才会被执行。第二次进入回收队列的时候，不会再执行其finalize方法，而是直接被二次标记，在下一次GC的时候被GC59.以下哪些类是线程安全的（）A.VectorB.HashMapC.ArrayListD.StringBufferE.PropertiesADEVector相当于一个线程安全的ListHashMap是非线程安全的，其对应的线程安全类是HashTableArraylist是非线程安全的，其对应的线程安全类是VectorStringBuffer是线程安全的，相当于一个线程安全的StringBuilderProperties实现了Map接口，是线程安全的60.下列说法错误的有（ ）A.Java面向对象语言容许单独的过程与函数存在B.Java面向对象语言容许单独的方法存在C.Java语言中的非静态方法属于类中的成员（member）D.Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同ABCD61.下列说法正确的有（ ）A.class中的constructor不可省略B.constructor必须与class同名，但方法不能与class同名C.constructor可在一个对象被new时执行D.一个class只能定义一个constructorC62.执行如下代码后输出结果为（ ）public class Test {
public static void main(String[] args) {
System.out.println("return value of getValue(): " + getValue());
}
public static int getValue() {
int i = 1;
try {
i = 4;
} finally{
i++;
return i;
}
}
}
A.return value of getValue(): 1B.return value of getValue(): 4C.return value of getValue(): 5D.其他几项都不对C63.关于Float，下列说法错误的是()A.Float是一个类B.Float在java.lang包中C.Float a=1.0是正确的赋值方法D.Float a= new Float(1.0)是正确的赋值方法Float f=1.0f 才是对的 所以C错Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.64.下面不属于Object类中方法的是:A.hashCode()B.finally()C.wait()D.toString()B(finalize才是)65.下列循环语句序列执行完成后，i的值是int i;
for(i=2;i<=10;i++){
System.out.println(i);
}
A.2B.10C.11D.不确定C66.下面代码运行结果是public class Test{
public int add(int a,int b){
try {
return a+b;
}
catch (Exception e) {
System.out.println("catch语句块");
}
finally{
System.out.println("finally语句块");
}
return 0;
}
public static void main(String argv[]){
Test test =new Test();
System.out.println("和是："+test.add(9, 34));
}
}
A.catch语句块和是：43B.编译异常C.finally语句块和是：43D.和是：43finally语句块public abstract class Test {
public static void main(String[] args) {
System.out.println(beforeFinally());
}
public static int beforeFinally(){
int a = 0;
try{
a = 1;
return a;
}finally{
a = 2;
}
}
}
/*
1
*/
当程序执行到try{}语句中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally{}中的程序， 在执行a = 2时，程序仅仅是覆盖了a的值，但不会去更新临时栈中的那个要返回的值 。执行完之后，就会通知主程序“finally的程序执行完毕，可以请求返回了”，这时，就会将临时栈中的值取出来返回。这下应该清楚了，要返回的值是保存至临时栈中的public abstract class Test {
public static void main(String[] args) {
System.out.println(beforeFinally());
}
public static int beforeFinally(){
int a = 0;
try{
a = 1;
return a;
}finally{
a = 2;
return a;
}
}
}
/*
2
*/
在这里，finally{}里也有一个return，那么在执行这个return时，就会更新临时栈中的值。同样，在执行完finally之后，就会通知主程序请求返回了，即将临时栈中的值取出来返回。故返回值是2所以C67.以下代码执行的结果显示是多少（ ）？public class Demo { class Super{
int flag=1;
Super(){
test();
}
void test(){
System.out.println("Super.test() flag="+flag);
}
} class Sub extends Super{
Sub(int i){
flag=i;
System.out.println("Sub.Sub()flag="+flag);
}
void test(){
System.out.println("Sub.test()flag="+flag);
}
}
public static void main(String[] args) {
new Demo().new Sub(5);
}
}
A.Sub.test() flag=1Sub.Sub() flag=5B.Sub.Sub() flag=5Sub.test() flag=5C.Sub.test() flag=0Sub.Sub() flag=5D.Super.test() flag=1Sub.Sub() flag=5A68.关于继承的说法正确的是A.子类将继承父类所有的数据域和方法。B.子类将继承父类的其可见的数据域和方法。C.子类只继承父类public方法和数据域D.子类只继承父类的方法，而不继承数据域A父类的静态方法可以继承，但是不能重写。父类的私有方法可以继承，只是不能调用69.servlet周期包含哪些：A.初始化B.销毁C.请求处理D.开始ABCinit()
--> 初始化
service()
-->
处理请求
destory () --> 销毁（停止）
70.下面代码在main()方法中第八行后可以正常使用的是（ ）public class Test
{
private int a=10;
int b=20;
static int c=1;
public static void main(String arg[])
{
Test t = new Test();
}
}
A.t.aB.this.cC.Test.bD.Test.c静态变量没得this说法,所以B排除AD