对象声明与初始化
静态成员与非静态成员(必须了解的)
静态上下文中只能访问静态成员
考点说明
static 函数只能访问 static 变量或 static 函数。
考题样例
public class TT
{
private String str1 = "Hello ";
TT()
{
str1 += "china";
}
static
{
str1 += "world";
}
public static void main(String args[])
{
System.out.println(str1);
}
}
关于以上代码，下面说法正确的是：（）
A. 输出Hello china
B. 输出Hello world
C. 有编译错误
D. world Hello china
正确答案：C
数据默认值(必须了解的)
数字类型成员的缺省值是0，布尔型为false，对象引用唯一的缺省值类型是null 考点说明
各种类型的缺省值：
boolean: false
byte: 0
char: '\u0000'
short: 0
int: 0
float:0.0
long: 0
double:0.0
Reference: null
考题样例
public class TT
{
private double d;
private String str;
private boolean bool;
public static void main(String args[])
{
TT tt = new TT();
System.out.println(tt.d + tt.str + tt.bool);
}
}
关于以上代码，说法正确的是：（）
A. 运行时抛异常
B. 输出 "0.0nullfalse"
C. 输出 "\u00000.0null"
D. 输出 "00.0null"
正确答案：B
局部变量没有默认值
考点说明
局部变量在使用之前必须显式赋值才能使用，否则将会有编译错误。由于局部变量使用的是栈内存，由于某些原因（主要是效率）虚拟机不能为栈上的变量设置默认值，所以局部变量需要显式赋初始值。
注：除局部变量以外的所有变量都是使用堆内存，由于在各种现代的机器上都可以很方便、快速地使大块内存初始化为相同的数值，比如可以将它初始化为 0，这个特性使得堆内存都可以由虚拟机赋初始值。由于在调用函数时，栈需要频繁地做出栈、入栈操作，若虚拟机要为各函数中的局部变量赋初始值的话会极大地影响效率，所以局部变量不可以从虚拟机得到这种好处。
考题样例
public static void main(String args[])
{
String str = "String";
int i;
System.out.println(str+i);
}
以上程序，下列说法正确的是：（）
A. 编译错误
B. 运行时抛异常
C. 输出”String0”
D. 输出”String”
正确答案：A
数组(必须了解的)
刚构造的数组中的元素总是设为默认值
考点说明
Java 数组总是存在被设定的默认值。各种数据类型的数组的默认值：boolean: false
byte: 0
char: '\u0000'
short: 0
int: 0
float:0.0
long: 0
double:0.0
Reference: null
考题样例
public class Test
{
public static void main(String args[])
{
final int len = 5;
int array[] =new int[len];
for(int i = 0; i < len - 2; i++)
{
array[i] = i;
}
for(int i = 0; i < array.length; i++)
{
System.out.print(array[i] + ",");
}
}
}
以上代码下列说法正确的是：（）
A. 输出 "0,1,2,0,0,"
B. 输出 "0,1,2,"
C. 运行时抛异常
正确答案：A
声明一个数组变量仅产生了一个数组引用（也可叫指针），但未分配数组的存储空间，一个数组的大小将在数组使用new 关键字真正创建时被给定
考点说明
数组变量本身仅仅是一个引用，数组的内存要用 new 运算符来分配。定义数组变量的时候不能（也不必）指定数组大小，数组的大小是在分配数组内存时才确定的。以下是定义数组的几种方法：
int array1[] = new int[3]; //声明一个大小为3的数组
int array2[] = new int[]{1, 2, 3}; //声明数组同时分配内存
用以下方法定义数组是错误的：
int array3[3] = new int[3]; //数组变量不必指定大小，编译错误int array4[] = new int[3]{1, 2, 3}; //数组大小由初始化列表中元素个数决定，编译错误
考题样例
下面几种声明数组的函数，错误的有（）
A. char chr[] = new char[3]{'A','B','C'};
B. char chr[] = new char[3];
C. char chr[] = {'A','B','C'};
正确答案：A
拷贝数组应当使用 System.arrayCopy() 函数以提高效率
考点说明
相对于用循环来拷贝数组，System.arrayCopy()执行效率更高，这是因为它是一个原生(native)函数，可以直接高效地将”源array” 的数据复制到”目标array”。
考题样例
下面两种数组的拷贝，哪个更有效率？（）
String[] from = new String[10];
String to = new String[10];
A. for (int i = 0, n = from.length; i < n; i++)
{
to[i] = from[i];
}
B. System.arrayCopy(from, 0, to, 0, from.length);
正确答案：B
数据初始化(必须了解的)
一个final 变量的值不能被改变，并且必须在一定的时刻赋值
考点说明
声明为 final 的变量被标识为不可改变的，但该变量引用的对象属性却可以通过访问变量、或调用成员函数改变，当然这要求那些对象提供了“写”数据的接口（String类就没有提供“写”数据的接口，所以字符串的内容不可变）。声明为 final 的成员变量必须在构造对象的过程中完成初始化：
1）其定义处，也就是说在final变量定义时直接给其赋值；
2）或者是在初始化块中；
3）或者是在构造函数中；
4）这三个地方必须（且只能）选其一
5）在以后的引用中只能读取，不能修改。
声明为 final 的静态变量不必在构造函数中初始化，但必须（且只能）在静态上下文中初始化一次（定义时、静态区段均可）。
声明为 final 的局部变量必须（且只能）在使用前初始化一次，不使用的话可不必初始化。。比如可以定义以下变量(编译通过)：
public static void main(String args[])
{
final int a = 0;
final int b;
b = 0;
final int c;
}
考题样例
下面关于final变量说法正确的是:()
A. 声明为final的数组其元素只能赋值一次；
B. 声明为final的整型变量其内容不能被改变；
C. 声明为final的String对象可以通过replace函数改变其内容
正确答案：B
final的基本用法及特点（final类、final函数、final参数）
考点说明
1、final类：
如果一个类被声明为final，意味着它不能再派生新的子类，因此一个类不能同时既被声明为abstract，又被声明为final。
2、final函数：
如果一个函数被声明为final，意味着它不能再被子类覆写，但可以在覆写一个父类函数时将这个函数声明为final。若一个 final 函数不是覆写父类的函数，则意味着编译时就可确定被调用的函数是哪一个函数，这样可以提高运行效率。设计final函数时，可考虑两点：第一，子类需要访问这个函数、但不能让子类覆写这个函数；第二，在第一点的基础上，函数的性能非常重要，在多数情况下，这点比较次要一些。
3、final参数：
类似于final变量，只能引用，不能修改。final 参数仅需声明，不必显式赋值（赋值是通过函数调用传参数完成的），这点和final变量不太一样。
考题样例
class abstract final A
{
public abstract void doSomething() ;
}
class B extends A
{
B()
{
System.out.println("init B…");
}
public void doSomething()
{
System.out.println("doSomething…");
}
public static void main(String argv[])
{
B b = new B();
b.doSomething();
}
}
关于以上代码，下面说明正确的是：（）
A. 编译错误
B. 输出"doSomething…"
C. 输出"init B…"
正确答案：A
常量
考点说明
尽管各种类型数据都可声明为final，但仅有少数数据在编译期间就可获知确定不变的值，这种数据可称为常量。在 java 语法中有一个保留字 const，但这个关键字从来就没有被使用过。除直接用数值表示的常量以外，其它常量都是用final 来声明的，但不是所有的 final 数据都是常量，只有在编译期间能确定数值的才能算是常量，从以下代码可以识别出一些常量（以及一些定义常量的方法，这段代码可以编译通过）：
public class Test
{
final static int STATIC_CONST = 1; //静态常量
final int MEMBER_CONST = 2; //成员常量
//下面这个数据编译期不能确定值，它的值需要运行期才确定，不是常量 final static int staticNoneConst = (int) (Math.random() * 20);
void test(final int noneConst) //final参数，不是常量
{
final int TEMP_CONST = 3; //局部常量
final int TEMP_CONST2 = TEMP_CONST + 1;//常量和常量运算结果也是常量
final int noneConst2 = noneConst + 1; //不是常量
switch(noneConst)
{
case STATIC_CONST:
System.out.println("STATIC_CONST");
break;
case MEMBER_CONST:
System.out.println("MEMBER_CONST");
break;
case TEMP_CONST:
System.out.println("TEMP_CONST");
break;
case TEMP_CONST2:
}
}
}
需要注意的是，一个数据是不是常量跟这个数据是不是static没有关系，比如上例中，成员数据、局部数据都可能是常量，关键只在于数据是在编译期间就可以确定它的值。常量不仅在虚拟机的一次运行期间数值不会变，并且多次重新启动虚拟机反复运行后，它的值还是恒定不变的。从这个意义上说，所有的引用都不是常量，因为引用都是在运行期间才能确定它的值。
考题样例
以下说法正确的是：（）
A. 只要是用 final static int 修饰的数据都恒定不变的，多次重新启动虚拟机反复运行后，它的值还是恒定不变的
B. 只要是用 final static int 修饰的数据都可以用在 switch – case 语句的 case 子句中
C. 只能用 final static 定义常量
D. 保留字 const 不能用来定义常量
正确答案：D
构造函数(必须了解的)
在构造过程中避免调用子类可以覆写的函数
考点说明
有继承关系的类之间的初始化过程，是父类的构造函数先执行，子类的构造函数后执行。如果在父类构造函数中调用了子类可以覆写的函数，一旦子类覆写了父类的函数，由于父类构造函数是先于所有子类构造函数执行，在子类覆写的函数中看到的所有子类数据都是未初始化的，这样做非常危险。
考题样例
以下程序输出什么？
class Parent
{
protected String pStr;
public Parent()
{
invokePrint();
pStr = "parent";
}
protected void invokePrint()
{
System.out.println("Parent print, pStr = " + pStr);
}
}
public class Child extends Parent
{
private String cStr;
public Child()
{
super();
cStr = "child";
}
protected void invokePrint()
{
System.out.println("Child print, pStr = " + pStr + " cStr = " + cStr);
}
public static void main(String[] args)
{
Child c = new Child();
c.invokePrint();
Parent p = new Parent();
p.invokePrint();
}
}
A.
Child print, pStr = null cStr = null
Child print, pStr = parent cStr = child
Parent print, pStr = null
Parent print, pStr = parent
B．
Parent print, pStr = null
Parent print, pStr = parent
Parent print, pStr = null
Parent print, pStr = parent
C.
Child print, pStr = parent cStr = null
Child print, pStr = parent cStr = child
Parent print, pStr = null
Parent print, pStr = parent
D.
Child print, pStr = null cStr = null
Child print, pStr = null cStr = child
Parent print, pStr = parent
Parent print, pStr = parent
正确答案：A
有继承关系的类之间的初始化顺序(必须了解的)
有继承关系的类之间的初始化顺序是先静态后非静态，先父后子
考点说明
初始化分为类的初始化和对象的初始化。
对于类的初始化，其顺序是：
1、若父类未加载，则先执行父类的类初始化过程，然后加载本类
2、给类变量分配存储空间
3、给类变量显式赋值
4、执行static块
在虚拟机一次运行的整个生命周期中，类的初始化一般只做一次（仅在特殊情况下才有可能做多次，比如一个类初始化过程抛出了异常导致类加载失败后，以后再用这个类时，虚拟机会再次尝试加载这个类）。另外如果在类的初始化过程中需要使用其他未加载的类，则对未加载的类也需执行上述过程。
说明：第 2 步“给类变量分配存储空间”时，由于新分配的存储空间都被虚拟机初始化过了，所以自动取得了默认值。虚拟机会通过某些方法（比如调用memset()函数）将一大块内存全部置为默认值，这在java代码中不可见，编译出来的字节码也没有相关的内容，如果没有显式赋初始值则声明变量的地方不能设置断点就是这个原因。
对象的初始化，其顺序是：
1、给对象分配存储空间(自动取得了默认值)
2、若有父类，则执行父类的对象初始化过程
3、给对象变量显式赋值
4、执行构造函数。
只有 https://www.doczj.com/doc/da9631274.html,ng.Object 类无需执行步骤 2 ，在执行父类的对象初始化过程中，具体要调用的构造函数由子类构造函数中的 super() 调用确定，若没有明确的super() 调用，则调用默认构造函数。对象的初始化过程在每次调用 new 运算符时都会被执行，但在对象克隆时不会执行(除非故意在克隆函数中用 new 构造了新对象)。
考题样例:
运行下面程序输出的是：
class Parent
{
protected static String str = getParentMessage();
static
{
str = "static block init";
}
private static String getParentMessage()
{
System.out.println("getParentMessage");
return "getParentMessage";
}
static class InnerClass
{
static
{
str = "inner class static block init";
}
}
}
public class Child extends Parent
{
Child()
{
System.out.println("final str=" + str);
}
public static void main(String args[])
{
new Child();
}
}
A. getParentMessage
final str=static block init
B. getParentMessage
final str=inner class static block init
C. 抛出运行时异常
D. final str=static block init
正确答案：A
运算
赋值运算
将一个对象引用赋值给另一个的一般规则是，你可以对继承树向上赋值但不能向下赋值
将一个对象引用赋值给另一个的一般规则是，可以对继承树向上赋值但不能向下赋值(子类的对象一定是父类的对象，但是父类的对象不一定是子类的对象)。可以这样想，如果将一个子类的实例赋值给基类，Java 知道哪个函数会在子类中。但是一个子类可能有基类没有的额外函数，这时候想调用子类的函数，就必须将该对象强制类型转换成子类的对象。
注：子类对象可以当成父类对象使用，在设计领域就延伸为里氏代换原则。里氏代换原则：如果对每一个类型为T1的对象o1,都有类型为T2的对象o2，使得以T1定义的所有程序P在所有对象o1都换成o2时，程序P的行为没有变化，那么类型T2是T1的子类型，即如果一个软件实体使用的是基类的话那么也一定适用于子类，但反过来的代换不成立。
考题样例
在下面给定的代码中，哪一个会编译失败：
interface IFace{}
class CFace implements IFace{}
class Base{}
public class ObRef extends Base
{
public static void main(String argv[])
{
ObRef ob = new ObRef();
Base b = new Base();
Object o1 = new Object();
IFace o2 = new CFace();
}
}
A. o1=o2;
B. b=ob;
C. ob=b;
D. o1=b;
正确答案：C
数值的默认类型
考点说明
整数的默认类型是int；对于长整型(long)数值，需要加上后缀L，避免溢出。浮点数的默认类型是double，将浮点数赋值给值域比它小的变量时，需要进行强制类型转换；构造单精度浮点数时，可以用后缀f指定。
考题样例
下面哪些可以编译成功：
1） float f = 10f;
2） char c = 10.0;
3） float f = 10.1f;
4） byte b = 10b;
A. 1)和3)
B. 1)和4）
C. 2)和3）
D. 都可以编译成功
正确答案：A
数据类型转换(必须了解的)
数据类型转换的默认规则
值域小的自动向值域大的方向转换,值域大的向值域小的方向转换需要进行强制类型转换
考题样例
下面哪个会编译失败：
A. double d = 10;
B. long l = 10;
C. float f = 10;
D. float f = 10.0f;
int i = f;
正确答案：D
逻辑运算符的短路效应(必须了解的、常错的)
逻辑运算符短路效应的应用场景
考点说明
对于逻辑运算符”&&”来说，如果第一个操作数为假，第二个操作数的值就没有作用了，也不会执行，所有的结果都为假。
对于逻辑运算符”||”来说，如果第一个操作数为真，第二个操作数的值就没有作用了，也不会执行，所有的结果都为真
注意：”&”和”|”既是位运算符也是逻辑运算符，”&”是按位取与，”|”是按位取或，当使用这两个运算符进行逻辑运算时，这两个运算符和逻辑运算的”&&”,”||”是不同的，不能产生短路效应。
考题样例
尝试编译运行以下代码时会发生什么情况？
int outPut=10;
boolean b1 = false;
if((b1==true) && ((outPut +=10)==20))
{
System.out.println("We are equal "+ outPut);
}
else
{
System.out.println("Not equal! "+ outPut);
}
A. 编译错误
B. 输出 "We are equal 10"
C. 输出"Not equal! 20"
D. 输出"Not equal! 10"
正确答案：D
instanceof运算符(必须了解的)
getClass() 函数与 instanceof 运算符的差异
考点说明
getClass()用于获取对象的真实类型，两个有继承关系的类分别调用getClass()获得的类是不同的。
instanceof 用来判断一个对象是否是某种类型的，即IS-A的关系。子类对象是父类对象的实例。
考题样例
以下程序的输出是什么？
class Father{}
public class Child extends Father
{
public static void main(String[] args)
{
Child child = new Child();
Father father = new Father();
System.out.println(child.getClass() == father.getClass());
System.out.println(child instanceof Father);
}
}
A. 输出true,false
B. 输出true,true
C. 输出false,true
D. 输出false,false
正确答案：C
变量为 null 时使用 instanceof 运算符返回值总是 false
考点说明
null 对象不是任何类的实例，所有instanceof运算符返回值总是false
考题样例
以下程序的输出是什么？
System.out.println(null instanceof Object);
A. 输出 Object
B. 输出 true
C. 输出 false
D. 输出 null
正确答案：C
传值与传引用(必须了解的)
对象是通过引用传递的（引用变量通过值传递）
考点说明
所有的变量（基本类型值和对象的引用值）都是值传递。但是这不是全部情况，对象是经常通过Java 的引用变量来操作的。所以也可以说对象是通过引用传递的（引用变量通过值传递）。调用者对基本类型参数（int，char 等）的拷贝在相应参数变化时不会改变。但是，在被调用函数改变相应作为参数传递的对象（引用）字段时，调用者的对象也改变其字段。
考题样例
以下程序输出结果是什么？
public static void main(String[] args)
{
Point p1 = new Point(0, 0);
Point p2 = new Point(0, 0);
modifyPoint(p1, p2);
System.out.println("[" + p1.x + "," + p1.y + "], [" + p2.x + "," + p2.y + "]");
}
private static void modifyPoint(Point p1, Point p2)
{
Point tmpPoint = p1;
p1 = p2;
p2 = tmpPoint;
p1.setLocation(5, 5);
p2 = new Point(5, 5);
}
A. [0,0], [0,0]
B. [5,5], [0,0]
C. [0,0], [5,5]
D. [5,5], [5,5]
正确答案：C
对函数传递基本类型参数，是直接传递值，函数得到它的拷贝，任何修改都不会在外部函数得到反映
考点说明
当你对函数传递基本类型参数，是直接传递值。函数得到它的拷贝，任何修改都不会在外部函数得到反映。
考题样例
以下程序输出结果是什么？
public static void main(String[] args)
{
int i1 = 0;
int i2 = 0;
modifyInt(i1, i2);
System.out.println("[" + i1 + "], [" + i2 + "]");
}
private static void modifyInt(int i1, int i2)
{
i1 = 10;
i2 = 20;
}
A. [0], [0]
B. [0], [10]
C. [10], [20]
D. [10], [0]
正确答案：A
equals() 函数与“==”运算(常错的)
对于对象，“==”运算的语义是用来判断对象是不是同一个对象
考点说明
“==”用来判断两个对象是不是相同的，用C语言的说法就是：两个对象的指针是不是指向相同的地址
考题样例
以下程序输出结果是什么？
String strTest1 = "abc";
String strTest2 = new String("test");
if (strTest1 == "abc")
{
System.out.print("true");
}
else
{
System.out.print("false");
}
if (strTest2 == "test")
{
System.out.print("true");
}
else
{
System.out.print("false");
}
A. truetrue
B. truefalse
C. falsetrue
D. falsefalse
正确答案：B
equals() 函数用来判断对象的内容(或者是属性)是否相同
考点说明
equals()函数可以认为是对象深层次的比较，比较对象的值是否相同。注意：equals()函数不能用于比较数组是否相同，对两个数组用equals()函数比较等同于”==”比较。
考题样例
以下程序输出结果是什么？
String strTest1 = "abc";
String strTest2 = new String("test");
if (strTest1.equals( "abc"))
{
System.out.print("true");
}
else
{
System.out.print("false");
}
if (strTest2.equals("test"))
{
System.out.print("true");
}
else
{
System.out.print("false");
}
A. truetrue
B. truefalse
C. falsetrue
D. falsefalse
正确答案：A
覆写 equals() 的注意事项
考点说明
覆写equals函数要遵循以下约定：
不同类型对象的equals()函数总是返回false
对于任意的非空引用值x,x.equals(null)总是返回false
自反性原则：对象和它自己比较总是返回true
对称性原则：如果x和y比较返回true,那y和x比较也一定返回true
传递性：如果x和y比较返回true，y和z比较返回true，那x和z比较也一定返回true
一致性原则：对于任意的引用值x和y，如果equals比较的对象信息没有改变的话，那么，多次调用euqals()函数返回的结果总是相同的
考题样例
下面哪种说法是正确的?
public class CompObj
{
public int x;
public int y;
public boolean equals(Object o1)
{
CompObj compO1 = (CompObj)o1;
return this.x == compO1.x;
}
}
A. 该equals函数实现错误，没有判断是不是相同类型的对象，并且在o1是null 的时候会抛出异常
B. 该equals函数实现正确
C. 该equals函数实现错误，没有比较y的值
正确答案：A
覆写hashCode()函数的注意事项
考点说明
在每个覆写了equals()函数的类中，必须要改写hashCode()函数
覆写hashCode()函数需要注意以下几点：
在一个应用程序的执行期间，如果一个对象的equals函数比较所用到的对象的信息没有被修改的话，那么对该对象调用多次hashCode(),它必须始终如一的返回同一个整数。
如果两个对象根据equals()函数是相等的，那么调用这两个对象中任意一个对象的hashCode()函数必须产生同样的整数结果。
如果两个对象根据equals()函数是不等的，那么调用这两个对象中任意一个对象的hashCode()函数不要求必须产生相同的结果。
考题样例
下面哪种说法是正确的?
int i = 0;
public int hashCode()
{
return i++;
}
A. 该hashCode函数实现错误，相同的对象调用多次hashCode()返回不同的结果
B. 该hashCode函数实现正确
正确答案：A
克隆与复制(常错的)
为防止对象被意外修改，应当在必要时拷贝对象
考点说明
Object.clone() 函数仅仅实现浅层拷贝（克隆）——只把基本数据类型和引用类型的值复制给新对象。这就意味着新旧对象：
1、各自拥有数值相同的ints、floats和booleans等基本数据类型的值。
2、但是共享数组、HashTable、Vector等此类对象成员。
如果不想让对象的值发生变更时影响到新对象，就要进行深度拷贝(克隆)。
考题样例
以下类哪个是安全拷贝的：（）
class A implements Cloneable
{
private int a = 1;
private boolean b = false;
public Object clone()
{
try
{
return (super.clone());
}
catch(CloneNotSupportedException cnes)
{
throw new InternalError();
}
}
}
class B implements Cloneable
{
private int a = 1;
private boolean b = false;
private HashTable h = new HashTable();
public Object clone()
{
try
{
return (super.clone());
}
catch(CloneNotSupportedException cnes)
{
throw new InternalError();
}
}
}
A. 类A
B. 类B
C. 类A和类B都不是安全拷贝
正确答案：A
如何正确覆写 clone() 函数
考点说明
1、要支持克隆必须实现Cloneable接口
2、实现clone()函数时记得调用super.clone() 函数，实现浅层克隆。
3、如果缺省的浅层克隆不符合要求，再实现深层克隆。
考题样例
下面代码段中深度克隆的实现方式是否正确？
public class MyCloneableClass
{
private Map map = new HashMap();
public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
}
A. 不正确，没有对map进行深度克隆
B. 不正确，既没有实现Cloneable接口，页没有对map进行深度克隆
C. 正确，可以完成深度克隆工作
D. 不正确，没有实现Cloneable接口
正确答案：B
字符串运算(必须了解的、常错的)
String 对象一旦被创建，它就决不能被改变
考点说明
在 java 类库中，String 类被设计成不可变类，它仅提供了“读”String数据的接口，没有提供“写”String数据的接口。
在 String 的 + 运行算中，虚拟机会构造新的 String，原来的 String 保持不变。调用 String 的 replace()、trim() 等函数时，如果结果和原来字符串不同时，也是产生新的String对象，原来的String对象不受影响。
考题样例
以下代码的输出结果是：
String abc = "abc";
abc.replace('b', 'd');
System.out.println(abc);
A. abc
B. adc
C. 答案 A 和 B 都不对
正确答案：A
不要使用new String("some string") 方式构造字符串
考点说明
创建字符串时不要使用new String("some string")，在Java中，"some String"默认就已经创建了一个字符串，如果再用new String("some string")，将会创建出另外一个字符串，造成浪费。
"abc"本身就是一个字符串对象，而在运行时执行String s= new String("abc")时，"abc"这个对象被复制一份到heap中，并且把heap中的对象引用交给s持有。这条语句创建了两个String对象。
考题样例
不考虑上下文，以下代码执行过程中创建了几个对象：
String abc = new String("abc");
A. 1
B. 2
C. 答案 A 和 B 都不对
正确答案：B
从 byte[] 数组构造字符串时，应该使用 new String(byte[]) 构造函数
考点说明
byte[] 数组的 toString() 函数实际上是Object的toString函数，而不是数组的内容。想通过byte[]数组来构造字符串，需要调用 new String(byte[])构造函数。
考题样例
下面程序输出的结果:（）
byte[]a = {49,50,51,52};
System.out.println.( a.toString());
A. "1234"
B. 49
C. 52
D. 以上都不是
正确答案：D
避免大量使用字符串的 + 运算，应当使用StringBuffer 的 append() 函数替代
考点说明
对于循环体内部的字符串连接，使用StringBuffer和append()函数；否则使用String连接符”+”。
String对象是不可变的，实现”+”的工作原理如下：获取加号两边的操作数；如果右边的操作数不是字符串，那么用toString()函数把它变成字符串，然后创建一个新的字符串，该字符串合并了两个待操作的字符串。创建新的临时字符串的过程是新建一个StringBuffer，然后追加其他字符串，最后调用toString。正是由于每次循环过程中，都会创建一个或多个新的对象，原来的旧对象成为垃圾，这样的话一个循环就会产生n个对象，从而造成内存的浪费。
使用StringBuffer对象可以避免创建多余的字符串对象，StringBuffer用来表示内容可变的字符序列，提供一些函数用来修改底部字符序列的内容。
在循环体外进行字符串连接时，建议采用”+”，虽然也存在上述问题，但是更加易于书写和理解。特别是在仅连接两三个字符串的情况下，性能影响不大。考题样例
下面说法错误的是：( )
A. StringBuffer的 append() 效率好于”+”运算;
B. 循环内使用StringBuffer的append()的效率要好于”+”运算;
C. String s = "s1" + "s2"; 和 String s = new
StringBuffer().append("s1").append("s2") 效率一样。
正确答案：A
垃圾收集
当对象不可达的时候，这个对象就成为了可回收的。
考点说明：
在Java虚拟机中使用有向图的方式来存储对象引用，当一个对象不可达时，该对象就成为可回收的了。
如果从线程的栈或者静态变量可以引用到对象，这个对象就是可达的，如果引用不到，这个对象就是不可达的。
在程序运行时，HEAP 中从“Root set of references” 通过直接或间接方式引用到的对象是可达对象(白色)，其它对象是不可达对象(蓝色)，不可达的对象就是垃圾、需要回收，如下图：
图1 可到达和不可到达的对象
Java 的垃圾收集的实现方法有很多种，但都离不开一个最基本的方法，那就是“跟踪收集”算法，这种算法从根集开始沿着引用跟踪，直到检查了所有可到达的对象。可以在程序注册表中、每一个线程堆栈中的（基于堆栈的）局部变量中以及静态变量中找到根。从这个原理上可以看出，静态变量和线程在垃圾收集的过程中扮演了非常重要的角色。
注意，从上图中可以看出，对象是否被引用并不是对象是不是垃圾的判断根据，比如上图中的四个garbage对象中有一个是还被其它garbage对象引用的，但它也是垃圾。
考题样例：
下述代码中，执行完语句1后，b是否会被回收？
class Stack
{
private Object[] elements;
一：选择题 1. 关于以下程序代码的说明正确的是（ D ） 1．class HasStatic{ 2． private static int x=100； 3． public static void main(String args[ ]){ 4． HasStatic hs1=new HasStatic( ); 5． hs1.x++; 6． HasStatic hs2=new HasStatic( ); 7． hs2.x++; 8． hs1=new HasStatic( ); 9． hs1.x++; 10． HasStatic.x- -; 11． System.out.println(“x=”+x); 12． } 13． } A、 5行不能通过编译，因为引用了私有静态变量 B、 10行不能通过编译，因为x是私有静态变量 C、程序通过编译，输出结果为：x=103 D、程序通过编译，输出结果为：x=102 2. 下列关于for循环和while循环的说法中哪个是正确的？（ B ） A．while循环能实现的操作，for循环也都能实现 B．while循环判断条件一般是程序结果，for循环判断条件一般是非程序结果C．两种循环任何时候都可替换 D．两种循环结构中都必须有循环体，循环体不能为空 3. 以下选项中循环结构合法的是（ C ） A、while (int i<7) { i++; System.out.println(“i is “+i); } B、 int j=3; while(j) { System.out.println(“ j is “+j); } C、int j=0; for(int k=0; j + k !=10; j++,k++) { System.out.println(“ j is “+ j + “k is”+ k); } D、 int j=0; do{ System.out.println( “j is “+j++); if (j = = 3) {continue loop;} }while (j<10); 4. 给出下面代码段, 哪行将引起一个编译时错误？（ D ）
1.抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 2.继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。 3.封装： 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。 4. 多态性： 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 5、String是最基本的数据类型吗 基本数据类型包括byte、int、char、long、float、double、boolean和short。 类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类 6、int 和Integer 有什么区别 Java提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int 提供的封装类。Java为每个原始类型提供了封装类。 原始类型封装类 boolean Boolean char Character byte Byte short Short int Integer long Long float Float double Double 引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为null，而原始类型实例变量的缺省值与它们的类型有关。 7、String 和StringBuffer的区别 JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String 类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。 8、运行时异常与一般异常有何异同 异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。 9、说出Servlet的生命周期，并说出Servlet和CGI的区别。 Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求
Java基础方面: 1、作用域public,private,protected,以及不写时的区别 答：区别如下： 作用域当前类同一package 子孙类其他package public √√√√ protected √√√ × friendly √√ × × private √ × × × 不写时默认为friendly 2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口) 答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现 3、Static Nested Class 和 Inner Class的不同 答：Nested Class （一般是C++的说法），Inner Class (一般是JA V A的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注：静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象 4、&和&&的区别 答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and） 5、Collection 和 Collections的区别 答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List. Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作 6、什么时候用assert 答：assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的 7、String s = new String("xyz");创建了几个String Object 答：两个，一个字符对象，一个字符对象引用对象 8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少 答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor 9、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错 答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译） 10、Java有没有goto 答：java中的保留字，现在没有在java中使用 11、数组有没有length()这个方法? String有没有length()这个方法 答：数组没有length()这个方法，有length的属性。String有有length()这个方法 12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
J2E E部分 1、运算符优先级问题，下面代码的结果是多少？（笔试） package test; public class Test { public static void main(String[] args) { int k = 0; int ret = ++k + k++ + ++k + k; // ret的值为多少 } } 2、运算符问题，下面代码分别输出什么？（笔试） package test; public class Test { public static void main(String[] args) { int i1 = 10, i2 = 10; } } 3、下面代码的结果是什么？还是抛出异常？（笔试） package test; public class Test { public void myMethod(String str) { } public void myMethod(Object obj) { } public static void main(String[] args) { Test t = new Test(); t.myMethod(null); } } 4、假设今天是9月8日，下面代码输出什么？（笔试） package test; public class Test { public static void main(String[] args) { Date date = new Date(); } } 5、下面代码的输出结果是什么？ package test; public class Test {
public static void main(String[] args) { double val = 11.5; } } 6、下面代码的结果是什么？ package test; public class Test extends Base { public static void main(String[] args) { Base b = new Test(); b.method(); Test t = new Test(); t.method(); } @Override public void method() { } } class Base { public void method() throws InterruptedException { } } 7、以下代码的结果是什么？ package test; public class Test extends Base { public static void main(String[] args) { new Test().method(); } public void method() { } } class Base { } 8、true or false？ package test; public class Test { public static void main(String[] args) { String str1 = new String("abc"); String str2 = new String("abc"); StringBuffer sb1 = new StringBuffer("abc"); StringBuffer sb2 = new StringBuffer("abc"); } } 9、输出的结果是什么？
1 1、BS与CS的联系与区别。 回答：C/S 是Client/Server 的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、 Sybase、Informix 或SQL Server。客户端需要安装专用的客户端软件。B/S是Brower/Server 的缩写，客户机上只要安装 一个浏览器(Browser),如Netscape Navigator 或Internet Explorer，服务器安装Oracle、Sybase、Informix或SQL Server 等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端 实现。浏览器通过web Server 同数据库进行数据交互。 C/S 与B/S 区别： 1.硬件环境不同: C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务. B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S 更强的适 应范围, 一般只要有****作系统和浏览器就行 2.对安全要求不同 C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通 过B/S 发布部分可公开信息. B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。 3.对程序架构不同 C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑. B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S 有更高的要求B/S 结构的程序架构 是发展的趋势, 从MS 的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的 JavaBean 构件技术等,使B/S更加成熟. 4.软件重用不同 C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好. B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石 头桌子 5.系统维护不同 C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统 B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实 现升级. 6.处理问题不同 C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与****作系统相关. 应该都是相同的系统
java软件工程师面试题集 EJB方面 1、EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别? 答：规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工作。JSP,Servlet,EJB,JNDI,JDBC,JMS..... 2、EJB与JAVA BEAN的区别？ 答:Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java 类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB 必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。 3、EJB的基本架构 答:一个EJB包括三个部分: Remote Interface 接口的代码 package Beans; import javax.ejb.EJBObject; import java.rmi.RemoteException; public interface Add extends EJBObject { //some method declare } Home Interface 接口的代码
1.SpringMVC Framework的理解： 1、它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件。并且和Spring提供的其他基础结构紧密集成 2、不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的) 3、可以任意使用各种视图技术,而不仅仅局限于JSP 4、支持各种请求资源的映射策略 5、它应是易于扩展的 2.简单的谈一下SpringMVC的工作流程？ 流程? 1、用户发送请求至前端控制器DispatcherServlet? 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。? 3、处理器映射器找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。? 4、DispatcherServlet调用HandlerAdapter处理器适配器? 5、HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。? 6、Controller执行完成返回ModelAndView? 7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet? 8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器? 9、ViewReslover解析后返回具体View? 10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。? 11、DispatcherServlet响应用户 3.如何解决POST请求中文乱码问题，GET的又如何处理呢？ 在web.xml中加入： .
15个Java多线程面试题及答案 1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行? 这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。 2)在Java中Lock接口比synchronized块的优势是什么?你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它? lock接口在多线程和并发编程中最大的优势是它们为读和写分别提 供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。芯学苑老师强烈建议在你在面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。 3)在java中wait和sleep方法的不同?
通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。 4)用Java实现阻塞队列。 这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序;第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait()和notify()方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。 5)用Java写代码来解决生产者——消费者问题。 与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。 6)用Java编程一个会导致死锁的程序，你将怎么解决?
Java开发工程师笔试试题 （请不要在试题上留任何痕迹，所有答案均写在答题纸上） 一．编程题（共26分） 1.任意写出一种排序算法。（6分） public void sort(int [] array){ //代码区 } 2.求1+2+3+..n（不能使用乘除法、for 、while 、if 、else 、switch 、case 等关 键字以及条件判断语句）（8分） public int sum(int n){ //代码区 return 0; } 3.完成下面方法，输入一个整数，输出如下指定样式图案。（12分） 输入：3， 输出： 1*2*3 7*8*9 4*5*6
输入：4 输出： 1*2*3*4 9*10*11*12 13*14*15*16 5*6*7*8 public void drawNumPic(int n){ //代码区 } 二．选择题（定项选择每题3分，不定项选择每题4分，共63分） 1.在基本JAVA类型中，如果不明确指定，整数型的默认是__类型，带小数的默认是__类型？( B ) A.int float B.int double C.long float D.long double 2.只有实现了__接口的类，其对象才能序列化( A ) A.Serializable B.Cloneable https://www.doczj.com/doc/da9631274.html,parable
D.Writeable 3.代码System. out. println(10 % 3 * 2)；将打印出？( B ) A.1 B.2 C.4 D.6 4.以下程序运行的结果为( A ) 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"); } }
ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？
14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？
在main(String[] args)方法内是否可以调用一个非静态方法？ 1．不能 同一个文件里是否可以有两个public类？ 2．不能 方法名是否可以与构造器的名字相同？ 3．可以。 public class Test { public Test(String iceboy) { System.out.println(iceboy); } public void Test(String iceboy) { System.out.println(iceboy); } public static void main(String[] args) { Test a = new Test("abc");//输出“abc” a.Test("iceboy");//输出“iceboy” } } 4.初始化了一个没有run()方法的线程类,是否会出错？ 4.不会。 第一种方法：直接继承Thread类。 public class Test { public static void main(String[] args) { ThreadClass t = new ThreadClass(); t.start(); System.out.println("end");//输出“end” } } class ThreadClass extends Thread //Thread类已经实现了空的run()方法。 { } 第二种方法：实现Runnable接口 public class Test { public static void main(String[] args)
{ ThreadClass t = new ThreadClass(); Thread thread = new Thread(t); thread.start(); System.out.println("end"); } } class ThreadClass implements Runnable { public void run() //必须有此方法否则编译报错。它是Runnable接口中的抽象方法。 { System.out.println("Threads"); } } 局部内部类是否可以访问非final变量？ 不能访问局部的非final修饰的变量，可以访问局部的使用了final修饰的变量，可以访问成员变量（全局的）。 class Out { private String name = "https://www.doczj.com/doc/da9631274.html,"; void print() { final String work = "out.local.work";//若不是final的则不能被Animal 使用. int age=10; class Animal //定义一个局部内部类.只能在print()方法中使用. //局部类中不能使用外部的非final的局部变量.全局的可以. { public void eat() { System.out.println(work);/ /ok //age=20;//error not final，编译时就会出错 System.out.println(name);/ /ok. } } Animal local = new Animal(); local.eat(); }
Java工程师笔试题 一、填空题(本大题10小题,每空1分，共20分)。 1.Java语言的三大特性即是: 继承、封装、多态。 2.在Java中，char 型采用____unicode_______编码方案,这样，无论是中文字符还是英文字符,都是占用__2___个字节的内存空间。 3. 形式参数指的是方法被__定义____ 时的参数行，实际参数是方法被__调用__ _ 时所传递进去的变量或值。 4.JSP内置对象中，application对象是代表应用程序上下文，它允许JSP页面与包括在同一应用程序中的任何Web组件共享信息，而session 对象则是每个客户专用的。 5.如果想把一个对象写入一个流，那么这个类就必须实现Seralizable 接口。 6.程序中实现多线程的方法有两种:继承Thread类和实现___Runable _ 接口。 7.多线程中，可以通过调用相应的setPriority() 方法来修改一个线程的相对优先级。 8.面向对象编程的五大设计原则，分别是单一职责、开放封闭、 里氏替换、依赖倒置、接口分离 9.通过Ajax，客户端获取的数据主要有两种类型：文本型和xml 10.Socket通常也称为套接字，用于描述__ ip 和_ _接口 二、选择题(本大题20 小题，每小题2分.共40分)。 1.在JA V A中，如果父类中某些方法不包含任何逻辑，并且需要由子类重写.应该使用( )关键字来声明父类的这些方法: A) final B) static C) abstract D) void 2.在JA V A中，已定义两个接口B和C,要定义一个实现这两个接口的类，以下语句正确的是（）。 A) interface A extend B,C B) interface A implements B,C C) class A implements B,C D) class A implements B, implements C
职业技能题库&在线云笔试平台https://www.doczj.com/doc/da9631274.html, 试卷名称：Java经典面试题带答案 试卷描述：java笔试题目、招聘笔试、微信考试、在线考试 试卷链接：https://www.doczj.com/doc/da9631274.html,/store/open/paperInfo/41651 试卷限时：50分 一.单项选择题 每题分值：2.5分 是否题目乱序：是 是否选项乱序：是 是否可回溯：是 难度：中 1.[单选]Java是从（）语言改进重新设计。 A．Ada B．C++ C．Pasacal D．BASIC 答案：B 2.[单选]下列语句哪一个正确（） A．Java程序经编译后会产生machine code B．Java程序经编译后会产生byte code C．Java程序经编译后会产生DLL D．以上都不正确
职业技能题库&在线云笔试平台https://www.doczj.com/doc/da9631274.html, 答案：B 3.[单选]下列说法正确的有（） A．class中的constructor不可省略 B．constructor必须与class同名，但方法不能与class同名 C．constructor在一个对象被new时执行 D．一个class只能定义一个constructor 答案：C 4.[单选]提供Java存取数据库能力的包是（） A．java.sql B．java.awt C．https://www.doczj.com/doc/da9631274.html,ng D．java.swing 答案：A 5.[单选]下列运算符合法的是（） A．&& B．<> C．if D．:= 答案：A 6.[单选]执行如下程序代码 a=0;c=0;
职业技能题库&在线云笔试平台https://www.doczj.com/doc/da9631274.html, do{ --c; a=a-1; }while(a>0); 后，C的值是（） A．0 B．1 C．-1 D．死循环 答案：C 7.[单选]下列哪一种叙述是正确的（） A．abstract修饰符可修饰字段、方法和类 B．抽象方法的body部分必须用一对大括号{}包住 C．声明抽象方法，大括号可有可无 D．声明抽象方法不可写出大括号 答案：D 8.[单选]下列语句正确的是（） A．形式参数可被视为localvariable B．形式参数可被字段修饰符修饰 C．形式参数为方法被调用时，真正被传递的参数 D．形式参数不可以是对象
一、选择题（共25题，每题3分，满分75分） 1）使用面向对象思想进行设计的基本步骤不包括（）。 A.发现类 B.发现对象 C.发现类的属性 D.发现类的方法 2）在UML屮，类图是一个包含3个部分的矩形，各部分A容不包括（）。 A.类名 B.属性 C.方法 D.类和类之间的关系 3）下面关于Java接口的说法错误的是（）。 A.—个Java接口是一些方法特征的集合，但没有方法的实现 B.Java接n中定义的方法在不同的地方被实现，可以具有完全不同的行为 C.Java接口屮可以声明私有成员 D.Java接口不能被实例化 4）在Java接口中定义常量，下面语法错误的是（）。 A.static int MALE = 1; B.final int MALE = 1; C.int MALE = 1; D.private int MALE = 1; 5）在Java接口中，下列选项中属于有效的方法声明是（）。 A.public void aMethod（）;
B.void aMethod(); C.void aMethod(){} D.private void aMethod(); 6)给定如下Java程序代码，在横线处加入()语句，可以使这段代码编译通过。 interface Parent{ public int count (int i); } public class Test implements Parent { public int count (int i) { return i % 9; } public static void main(String[] args){ int i = p.count(20); } } 7）以下选项屮关于Oracle屮数裾库的说法错误的是（）。 A.数据库在逻辑上表现为数据文件、日志文件和控制文件等 B.必须首先创建数据库，然后才能使川Oracle C.可在安装Oracle软件吋同吋创建数据库，也可以在安装后再单独创建数据库 D.每个启动的数据库都对应一个数据库实例，然后由这个实例来访问和控制数据库 8）在Oracle中，使用数据库表student存放学生信息，其中birthday字段存放学生生日，查询该表中1980年9月15 口及以后的学生信息，以下SQL语句正确的是（）。 A.SELECT * FROM student WHERE birthday>=,1980-09-15,; B.SELECT * FROM student WHERE birthday〉=.15-9 月-19801; C.SELECT * FROM student WHERE TO_DATE（birthday；YYYY-MM-DD'）>=,2009-10-1 *; D. SELECT * FROM student WHERE birthday>=TO_CHAR(' 1980-09-15'；YYYY- MM-DD'); 9）一个Oracle数椐库表包含性别字段，在该字段上建立（）最合适。
Java 软件高级工程师笔试题 【智力部分】（30分） 1.烧一根不均匀的绳要用一个小时，如何用它来判断半个小时？（5分） 2.4，4，10，10，加减乘除，怎么出24点？（5分） 3.如果你有无穷多的水，一个容积为3L的和5L的提桶，你如何准确称出4L的水？（5分） 4.一只蜗牛从井底爬到井口，每天白天蜗牛要睡觉，晚上才出来活动，一个晚上蜗牛可以向上爬3尺，但是白天 睡觉的时候会往下滑2尺，井深10尺，问蜗牛几天可以爬出来？（5分） 5.有一种细菌，经过一分钟分裂为2个，再过一分钟，分裂为4个，这样，将一个细菌放在一个瓶子里面，一个 小时后瓶子被细菌充满了。现在假设一开始放入瓶中的为两个细菌，那么到充满瓶子要多长的时间？（10分） 【专业部分】（70分） 6.简述一下面向对象的特征，并举例说明你对面向对象的理解？（5分） 7.ArrayList和HsahSet的区别,HashMap和Hashtable的区别?（5分） 8.线程同步的关键字是什么？sleep() 和wait() 有什么区别?怎么唤醒wait()停止的线程?（5分）
9.列举你在项目中常用的设计模式（伪代码或类图），并说明每种设计模式的具体应用场景。（5分） 10.Spring中事务管理支持哪几种方式以及每种方式的具体使用方法。（5分） 11.Hibernate的缓存等级及其特点（5分） 12.至少写出一种11位手机号码的正则表达式。（5分） 13.用简短的代码实现字符串“s tr in g”到“s tr in g”转换。即将多个空格转换为一个空格（5 分） 14.使用Socket编写一个程序，客户端向服务器端发送请求（发送字符串即可），服务端接收后发送反馈信息.（10 分）
Java经典面试题带答案一、单项选择题 1．Java是从（）语言改进重新设计。 A．Ada B．C++ C．Pasacal D．BASIC 答案：B 2．下列语句哪一个正确（） A．Java程序经编译后会产生machine code B．Java程序经编译后会产生byte code(字节码) C．Java程序经编译后会产生DLL D．以上都不正确 答案：B 3．下列说法正确的有（） A．class中的constructor不可省略 B．constructor必须与class同名，但方法不能与class同名C．constructor在一个对象被new时执行（构造器） D．一个class只能定义一个constructor 答案：C 4．提供Java存取数据库能力的包是（） A．Java.sql /sql/数据库还有Oracle 也是一种数据库 B．java.awt C．https://www.doczj.com/doc/da9631274.html,ng D．java.swing 答案：A 5．下列运算符合法的是（） A．&& B．<> C．if D．:= 答案：A 6．执行如下程序代码 a=0;c=0; do{ --c; a=a-1; }while(a>0); 后，C的值是（） A．0 B．1 C．-1 D．死循环
答案：C 7．下列哪一种叙述是正确的（） A．abstract修饰符可修饰字段、方法和类 B．抽象方法的body部分必须用一对大括号{}包住 C．声明抽象方法，大括号可有可无 D．声明抽象方法不可写出大括号 答案：D 8．下列语句正确的是（） A．形式参数可被视为localvariable B．形式参数可被字段修饰符修饰 C．形式参数为方法被调用时，真正被传递的参数 D．形式参数不可以是对象 答案：A 9．下列哪种说法是正确的（） A．实例方法可直接调用超类的实例方法 B．实例方法可直接调用超类的类方法 C．实例方法可直接调用其他类的实例方法 D．实例方法可直接调用本类的类方法 答案：D 二、多项选择题 1．Java程序的种类有（） A．类（Class） B．Applet C．Application D．Servlet 2．下列说法正确的有（） A．环境变量可在编译sourcecode时指定 B．在编译程序时，所能指定的环境变量不包括class path C．javac一次可同时编译数个Java源文件 D．javac.exe能指定编译结果要置于哪个目录（directory）答案：BCD 3．下列标识符不合法的有（） A．new B．$Usdollars C．1234 D．car.taxi 答案：ACD 4．下列说法错误的有（） A．数组是一种对象 B．数组属于一种原生类 C．intnumber=[]={31,23,33,43,35,63} D．数组的大小可以任意改变 答案：BCD 5．不能用来修饰interface的有（）
java高级软件工程师面试题 招聘java高级工程师，职位描述如下，有兴趣的加394504340交流，打扰了，谢谢！ 职位名称：java高级开发工程师(急) 职位描述：互联网产品的开发和维护。 职位要求：1. 熟悉JAVA、J2EE体系结构，熟练掌握Spring、Struts、Hibernate、ibatis 的开发技术。 2. 熟悉MySql等数据库开发，熟练掌握SQL语句，有较好的数据库设计能力。 3. 熟练掌握HTML、javascript、ajax等web开发技术，熟悉http协议。 4. 熟悉SVN、Maven、Junit等工具。 5. 具有良好的学习能力、沟通能力，乐于承担工作压力。 6. 有大型门户或社区网站开发经验者优先。 职位所在城市：杭州 职位所在行业：高科技 -------------------------========================================================= 1.说一下struts中常用的对象 2.怎样整合apatche和tomcat 3.说一下在linx系统中搭建服务器 4.简述一下sql server 建模 5.请写一个程序,把一个10进制转换成16进制 6.表student 列id name age WA(本科以上,大专,高中,初中以下) 毕业学校ID,学校信息表 问:统计出文化学历本科以上,大专,高中,初中以下,每个年龄各有多少人(一条SQL语句) 7.有两位少年从隧道的一端向另一端行走.当他们走过隧道的五分之二时,发现隧道外面迎来一辆火车.火车很快就要进入隧道.两位少年向来时隧道跑去.两位少年都是每小时10公里.两位在千钧一发跑出了隧道.假设火车速度恒定,并且两位少年都在瞬间达到最大速度,请问火车的速度 8.请写出常用的oracle语句及说明,存储过程的语句及说明 ---------------------------------------------------------------------------------------------------------------------------------