华为公司 java 面试题 大家一起来讨论

Question

第一部分：选择题
QUESTION NO: 1
1、public class Test {
    public static void changeStr(String str){
        str="welcome";
    }
    public static void main(String[] args) {
        String str="1234";
        changeStr(str);
        System.out.println(str);
    }
}
Please write the output result ：QUESTION NO:2
1. public class Test {
2. static boolean foo(char c) {
3. System.out.print(c);
4. return true;
5. }
6. public static void main( String[] argv ) {
7. int i =0;
8. for ( foo('A'); foo('B')&&(i<2); foo('C')){
9. i++ ;
10. foo('D');
12. }
13. }
14. }
What is the result?
A. ABDCBDCB
B. ABCDABCD
C. Compilation fails.
D. An exception is thrown at runtime.QUESTION NO: 3
1. class A {
2. protected int method1(int a, int b) { return 0; }
3. }
Which two are valid in a class that extends class A? (Choose two)
A. public int method1(int a, int b) { return 0; }
B. private int method1(int a, int b) { return 0; }
C. private int method1(int a, long b) { return 0; }
D. public short method1(int a, int b) { return 0; }
E. static protected int method1(int a, int b) { return 0; }QUESTION NO: 4
1. public class Outer{
2. public void someOuterMethod() {
3. // Line 3
4. }
5. public class Inner{}
6. public static void main( String[]argv ) {
7. Outer o = new Outer();
8. // Line 8
9. }
10. }
Which instantiates an instance of Inner?
A. new Inner(); // At line 3
B. new Inner(); // At line 8
C. new o.Inner(); // At line 8
D. new Outer.Inner(); // At line 8//new Outer().new Inner()QUESTION NO: 5
Which method is used by a servlet to place its session ID in a URL that is written to the servlet’s response output stream?
A. The encodeURL method of the HttpServletRequest interface.
B. The encodeURL method of the HttpServletResponse interface.
C. The rewriteURL method of the HttpServletRequest interface.
D. The rewriteURL method of the HttpServletResponse interface.QUESTION NO: 6
Which two are equivalent? (Choose two)
A. <%= YoshiBean.size%>
B. <%= YoshiBean.getSize()%>
C. <%= YoshiBean.getProperty("size")%>
D. <jsp:getProperty id="YoshiBean" param="size"/>
E. <jsp:getProperty name="YoshiBean" param="size"/>
F. <jsp:getProperty id="YoshiBean" property="size"/>
G. <jsp:getProperty name="YoshiBean" property="size"/>QUESTION NO: 7
Which of the following statements regarding the lifecycle of a session bean are correct? 
1.  java.lang.IllegalStateException is thrown if SessionContext.getEJBObject() is invoked when a stateful session bean instance is passivated. 
2.  SessionContext.getRollbackOnly() does not throw an exception when a session bean with bean-managed transaction demarcation is activated. 
3.  An exception is not thrown when SessionContext.getUserTransaction() is called in the afterBegin method of a bean with container-managed transactions. 
4.  JNDI access to java:comp/env is permitted in all the SessionSynchronization methods of a stateful session bean with container-managed transaction demarcation. 
5.  Accessing resource managers in the SessionSynchronization.afterBegin method of a stateful session bean with bean-managed transaction does not throw an exception.
第二部分：概念题
1．    描述Struts体系结构？对应各个部分的开发工作主要包括哪些？2．    XML包括哪些解释技术，区别是什么？
3．    JSP有哪些内置对象和动作？它们的作用分别是什么？
4、SQL问答题
SELECT * FROM TABLE
和
SELECT * FROM TABLE 
WHERE NAME LIKE '%%' AND ADDR LIKE '%%' 
AND (1_ADDR LIKE '%%' OR 2_ADDR LIKE '%%' 
OR 3_ADDR LIKE '%%' OR 4_ADDR LIKE '%%' ) 
的检索结果为何不同？5、SQL问答题
表结构：
1、    表名：g_cardapply
字段(字段名/类型/长度)：
g_applyno        varchar   8；//申请单号（关键字）
g_applydate     bigint     8；//申请日期
g_state        varchar     2；//申请状态
2、    表名：g_cardapplydetail
字段(字段名/类型/长度)：
g_applyno        varchar     8；//申请单号（关键字）
g_name        varchar     30；//申请人姓名
g_idcard        varchar     18；//申请人身份证号
g_state        varchar     2；//申请状态
其中，两个表的关联字段为申请单号。
题目：
1、    查询身份证号码为440401430103082的申请日期
2、    查询同一个身份证号码有两条以上记录的身份证号码及记录个数
3、    将身份证号码为440401430103082的记录在两个表中的申请状态均改为07
4、    删除g_cardapplydetail表中所有姓李的记录

Answer 1

我想如果能够把这些问题搞定，进华为应该没问题。
wangx1949这个很简单吗？光说不练决不是好汉。先做了再说，鄙视你

Answer 2

...
LZ用不着这样吧,你的选择题都是出自SCJP的,不信可以去google搜搜

Answer 3

当然很多单位的笔试题都是从SCJP摘的,但我认为华为是不可能出这些题的.

Answer 4

public class Test {
    public static void changeStr(String str){
        str="welcome";
    }
    public static void main(String[] args) {
        String str="1234";
        changeStr(str);
        System.out.println(str);
    }
}
这一题我想他主要考查 static这个关键字，changestr是个静态的方法（类方法）那么str应该也是一个静态成员，所有的对象都是公用这样的一个成员，那么对他的修改应该是可以保持的。而为什么最后的结果却是初始值1234，我有点迷惑。

Answer 5

to ziyongkun
值传递而非引用传递

Answer 6

to CpRcF 
能不能跟我讲一下值传递，结合这个题目。谢谢

Answer 7

QUESTION NO: 1
输出：1234
我记得对象是传引用的，怎么回事？

Answer 8

那是在c++中，java中都是值传递，
我也是刚刚找资料知道的。

Answer 9

不管是在c/c++中还是在java函数调用都是传值调用，.
当参数是对象的时候，传递的是对象的引用，这个和c/c++传递指针是一个道理，在函数中改变引用本身，不会改变引用所指向的对象，而在QUESTION NO: 1中只是改变了引用，所以在main函数中输出还是原来的那个值：1234

Answer 10

参数是对象时传的是地址。但str="welcome";相当于str=new String("welcome");，所以原对象没变。
可以参考以下代码：
public class Test {
public int ss = 999;
public Test(int s){
ss = s;
}
    public static void changeStr(Test t){
     t.ss = 888;
     }
    public static void main(String[] args) {
        Test t = new Test(999);
        changeStr(t);
        System.out.println(t.ss);
    }
}
public class Test {
public int ss = 999;
public Test(int s){
ss = s;
}
    public static void changeStr(Test t){
     t = new Test(888);
     }
    public static void main(String[] args) {
        Test t = new Test(999);
        changeStr(t);
        System.out.println(t.ss);
    }
}

Answer 11

String str="1234";和 str="welcome";是两个不同对象！

Answer 12

传递的是地址的值，java都是传值的。

Answer 13

严重同意：
leonwu1981_2
java 中对象是引用传递的 
  不要误导

Answer 14

1.1234
2.A
3.AB
4.c
5.B
6.BG
7.对不起，我不用ejb....问答题就不用做了吧，很浪费时间的
感觉像小学时候考政治.......

Answer 15

QUESTION NO:2
1. public class Test {
2. static boolean foo(char c) {
3. System.out.print(c);
4. return true;
5. }
6. public static void main( String[] argv ) {
7. int i =0;
8. for ( foo('A'); foo('B')&&(i<2); foo('C')){
9. i++ ;
10. foo('D');
12. }
13. }
14. }
What is the result?
A. ABDCBDCB
B. ABCDABCD
C. Compilation fails.
D. An exception is thrown at runtime做一下这个吧！！

Answer 16

str="welcome"  和 str=new String("welcome");是有很大区别的，误人子弟。

Answer 17

第一题终于清楚了。对象是传引用的。但是下面还是有区别public class test6 { public int ss = 999;
public test6(int s){
ss = s;
}
public static void changeStr(test6 t){
t.ss = 888;
}
public static void change(test6 t){

t = new test6(222);
}
public static void main(String[] args) {

test6 t = new test6(999);
changeStr(t);
System.out.println(t.ss);
change(t);
System.out.println(t.ss);

}
}

Answer 18

import javax.swing.JOptionPane;
public class Test {
    public void changeStr(String str){
        str="welcome";
    }
    public void main(String[] args) {
        String str="1234";
        str="welcome";
        //changeStr(str);
JOptionPane.showMessageDialog(null,str); 
    }
}如果这样做的话结果是welcome在我我想说的是在C语言以后所有的参数传递都是值传递，问题是传的值是是什么，而没有什么引用传递之类的东西。
 
关于输出为1234而不是welcome 还有待进一步分析。
我现在去上课了，回来再和大家细说

Answer 19

对第一题的详细分析：
Java中函数参数传递是值传递，在C语言以后的都是这样的，关键是传进来的值是什么（这一点我在上面说了到一次）。
①如果参数是基础类型，如int型的，则传进来的是int型变量的值，这个值放在堆里。
举个例子：
void fun(int i){};
int i = 5;
fun(i);
传进fun函数的是5;
②如果参数是引用类型。如String型的，则传进来的是String型变量的值，这个值放在栈里，此值是该变量将要指向的对象的地址。
举个例子：
void fun(String str0){};
String str = "Hello";
fun(str);fun()方法调用时第一件事就是，做了一个赋值操作：str0 = str;
这个操作的结果就是将str变量的值传给str0变量的值，也就是使得str0也指向str所指向的对象。对str0所指向的对象做修改操作，也就是对str所指的对象做修改。
有了上面的两点，我想做第一个题目一定是没什么问题的了：说明：为了方便分析我把changeStr()方法中的参数名改成了str0。
改动后的代码如下：
1.public class Test {
    public static void changeStr(String str0){
        str0="welcome";
    }
    public static void main(String[] args) {
        String str="1234";
        changeStr(str);
        System.out.println(str);
    }
}

Answer 20

哎,第一题没那么复杂,都说的离谱了,具体讨论请见TIJ的附录一 关于别名和引用那一章.我们不争论JAVA到底是传值还是传引用,因为两者某种意义上都是正确的.传值的认为传递引用本身是传值行为,这没错,可我们一般把reference当成了对象,所以说成传引用也说得过去,概念就不多说了.
为什么str在changeStr之后没变?这是因为JAVA对所有的外覆类性(基本类型的对应类)是采用所谓的恒常对象(唯读对象,read-only),这些外覆类中的任何函数行为的调用都不会改变原对象,而是产生一个新对象,这就是为什么我们在需要动态增加String时要用StringBuffer的原因.可对于我们自己所创建的对象,并没有这个"恒常"的特性，所以在这里有个"别名"现象，也就是几个引用同时指向一个对象,任何一个引用对对象的修改都将影响到其他.在这个例子中,changeStr函数的行为其实产生了一个新的对象,函数内的str是局部性的,它指向新的对象，可对原对象没有产生任何影响.不知道我的解释清楚了,更具体讨论请见Thinking in Java

Answer 21

对第一题的详细分析：
Java中函数参数传递是值传递，在C语言以后的都是这样的，关键是传进来的值是什么（这一点我在上面说了到一次）。
①如果参数是基础类型，如int型的，则传进来的是int型变量的值，这个值放在堆里。
举个例子：
void fun(int i){};
int i = 5;
fun(i);
传进fun函数的是5;
②如果参数是引用类型。如String型的，则传进来的是String型变量的值，这个值放在栈里，此值是该变量将要指向的对象的地址。
举个例子：
void fun(String str0){};
String str = "Hello";
fun(str);fun()方法调用时第一件事就是，做了一个赋值操作：str0 = str;
这个操作的结果就是将str变量的值传给str0变量的值，也就是使得str0也指向str所指向的对象。对str0所指向的对象做修改操作，也就是对str所指的对象做修改。
有了上面的两点，我想做第一个题目一定是没什么问题的了：说明：为了方便分析我把changeStr()方法中的参数名改成了str0。
改动后的代码如下：
1.public class Test {
2.    public static void changeStr(String str0){
3.        str0="welcome";
4.    }
5.    public static void main(String[] args) {
6.        String str="1234";
7.        changeStr(str);
8.        System.out.println(str);
9.    }
10.}第7行代码执行过程如下：
将str的值赋给str0，使得str0和str指向同一个String类对象1234
而在changeStr()方法中第3行代码执行的结果是将str0值（也就是对象的地址）做了修改，str0的值为String类对象welcome的地址，这样一来，使得str和str0所指向的对象不再是同一个对象了，而且str的值并没有改变，也就是说str还是指向String类对象1234的。综上所述，程序最终的结果一定是1234。补充：
ziyongkun  在 2006-05-10 10:08:00 发的贴子里说的不是很对，并不是一个副本的问题，它们会指向同一个对象的。

Answer 22

QUESTION NO:2
1. public class Test {
2. static boolean foo(char c) {
3. System.out.print(c);
4. return true;
5. }
6. public static void main( String[] argv ) {
7. int i =0;
8. for ( foo('A'); foo('B')&&(i<2); foo('C')){
9. i++ ;
10. foo('D');
12. }
13. }
14. }
========================================================================
考察的是for语句的执行过程：
for(1;2;3)
过程如下：
1；
2；
3；
2；
.
.
.
当i<2时，便不再执行。其实是基础＆细心～～～～～～～

Answer 23

4、SQL问答题
SELECT * FROM TABLE
和
SELECT * FROM TABLE 
WHERE NAME LIKE '%%' AND ADDR LIKE '%%' 
AND (1_ADDR LIKE '%%' OR 2_ADDR LIKE '%%' 
OR 3_ADDR LIKE '%%' OR 4_ADDR LIKE '%%' ) 
的检索结果为何不同？
=========================================================
前者检索全部，后者有三种情况检索不出：NAME＝null或ADDR=null或1_ADDR LIKE 2_ADDR 3_ADDR 4_ADDR其一为null.

Answer 24

killme2008(zane dennis)解释的最清楚,其实什么值不值的,除了直接对地址操作除外,其他的在子函数中产生都是副本,函数调用完后,局部变量自动被清除,里面的值也释放.

Answer 25

华为不是做设备的吗？ 要java做什么？

Answer 26

java 不了解 但是 sql 不难

Answer 27

楼上 ，SQL2道题做一下，都说不难，没一个人做。

Answer 28

4、SQL问答题
SELECT * FROM TABLE
和
SELECT * FROM TABLE 
WHERE NAME LIKE '%%' AND ADDR LIKE '%%' 
AND (1_ADDR LIKE '%%' OR 2_ADDR LIKE '%%' 
OR 3_ADDR LIKE '%%' OR 4_ADDR LIKE '%%' ) 
的检索结果为何不同？答：前者检索所有记录，后者只能检索出 NAME 和ADDR中非Null的记录。
5、SQL问答题
表结构：
1、    表名：g_cardapply
字段(字段名/类型/长度)：
g_applyno        varchar   8；//申请单号（关键字）
g_applydate     bigint     8；//申请日期
g_state        varchar     2；//申请状态
2、    表名：g_cardapplydetail
字段(字段名/类型/长度)：
g_applyno        varchar     8；//申请单号（关键字）
g_name        varchar     30；//申请人姓名
g_idcard        varchar     18；//申请人身份证号
g_state        varchar     2；//申请状态
其中，两个表的关联字段为申请单号。
题目：
1、    查询身份证号码为440401430103082的申请日期
select A.g_applydate 
from g_cardapply A inner join g_cardapplydetail B on A.g_applyno = B.g_applyno
where B.g_idCard = '440401430103082'2、    查询同一个身份证号码有两条以上记录的身份证号码及记录个数
select g_idCard,count(*) as Cnt from g_cardapplydetail 
group by g_idcard
having count(*) > 13、    将身份证号码为440401430103082的记录在两个表中的申请状态均改为07
update g_cardapplydetail set g_state = '07'
where g_idcard = '440401430103082'update A  set g_state = '07'
from g_cardapply A inner join  g_cardapplydetail B on A.g_applyno = B.g_applyno 
where B.g_idcard = '440401430103082'
4、    删除g_cardapplydetail表中所有姓李的记录
delete from g_cardapplydetail 
where g_name like '李%'

Answer 29

3、 将身份证号码为440401430103082的记录在两个表中的申请状态均改为07
update g_cardapplydetail set g_state = '07'
where g_idcard = '440401430103082'update A set g_state = '07'
from g_cardapply A inner join g_cardapplydetail B on A.g_applyno = B.g_applyno
where B.g_idcard = '440401430103082'这题需要使用事务。请重写吧，呵呵

Answer 30

5、SQL问答题:
 /*Select g_cardapply. g_applydate
 From g_cardapply, g_cardapplydetail
 Where g_cardapply. g_applyno=g_cardapplydetail. g_applyno
 And g_cardapplydetail.g_idcard='440401430103082'*//*Select *From (select count(*) g_count , g_idcard
              From g_cardapplydetail 
              Group by  g_idcard )  a
              Where a. g_count >= 2*//*Update g_cardapply 
set g_state='07' 
where g_applyno in (select distinct  g_applyno  
                    from  g_cardapplydetail  
                    where g_idcard ='440401430103082') 
update g_cardapplydetail
  set g_state='07'
where g_idcard='440401430103082' *//*Delete from g_cardapplydetail
     Where g_name like '李%'*/
通过测试
PS:偶GF做的，自己先汗一下

Answer 31

对于第一题为何为原值:1234，本人发表一下愚见：
在java中，String类型的变数是对象类型，它同样是一个很特殊的类型。他一旦付值，便不可在被改变。（所以往往大家想要改变一个字符串的值时会使用StringBuffer型，当然也因为他的效率比String高。）在此题中，String str = “1234”；是一个特例，str在这里并非一个实际的对象，它只是一个引用对象！执行此表达式时，并让str引用对象指向常量1234 。在方法 changeStr（）中，将这个引用作为参数传递，在此过程是大家讨论较为激烈的地方：到底是值传递还是引用（地址）传递？在java，基本类型是值传递，对象类型是引用传递！String是对象类型，同时str也是一个对象（引用对象），此处是引用传递！ str="welcome";次表达式并非改变了str所指向的地址的值，而是指向了一个新的地址（“welcome”），然而，毕竟是在新的方法中执行，因而对于str这个引用对象所指向的welcome这个"引用"的生命周期是在此过程域中，一旦离开次过程域，被指向welcome的引用将不在存在！此时java垃圾回收器检测到对于welcome的引用已经没有了，就回收该内存！最后，大家看到的str最终还是指向了1234,因为离开产各Str()时，main方法域还没结束！！

Answer 32

4.删除g_cardapplydetail表中所有姓李的记录我觉的这道SQL这道题应该做两个删除，首先要删除表g_cardapply中姓李所拥有申请单的记录,然后再删除g_cardapplydetail中所有姓李的记录,因为两张表是通过g_applyno来关联的。

Answer 33

JAVA中对象是按值传递的。但是被传递的是对象的引用，而不是本身。当程序执行到方法内部时，就会将实参的引用复制一份在方法内部使用。必须得区分引用，和被引用的隐藏在背后的对象，不然很难搞清楚第一道题是怎么回事。《Practical Java》一书的第一条就说了这个问题，可以参看一下。

Answer 34

我要是没记错的话,在cpp中,static成员函数只能修改static成员数据.估计JAVA也是这个意思吧(很多语言都是相通的),我不太肯定啊,我刚开始学JAVA(刚看到前言-_-#)

Answer 35

/*Select g_cardapply. g_applydate
From g_cardapply, g_cardapplydetail
Where g_cardapply. g_applyno=g_cardapplydetail. g_applyno
And g_cardapplydetail.g_idcard='440401430103082'*/这是ＯＲＡＣＬＥ的写法吗？ＭＳＳＱＬ是不能这样写的吧？

Answer 36

完全同意  o_eonian() !!!!!!!!
其它人不人误导!!!!!!!!!!!!!!!!

Answer 37

第一个问题，支持 o_eonian() 正确，其实考的就是变量的存活空间问题。

Answer 38

第1题..和静不静态没有什么关系.
题目本身只是为了方便在main方法里调用方法.
试问,如果不是静态的难道可以直接调用?
我给换成不是静态方法.难道答案就变了??
public class Test {
    public void changeStr(String str){
        str="welcome";
    }
    public static void main(String[] args) {
        String str="1234";
        new Test().changeStr(str);
        System.out.println(str);
    }
有些人可能题目都没看懂.就在这里瞎起哄!!!!
}

Answer 39

对于 o_eonian() 的说法.基本同意,但是也有所保留.
其实没有必要扣字眼...难道引用就不是值?
Think in java里面说,万事完物皆对象.这虽然是面向对象语言的特点.
但是java仍然没有做到纯粹的面向对象.
否则,干什么要有基本数据类型??应该全部用类来表示.可是java为什么设置这些基本数据类型呢??
原因很简单,这些用的太频繁了....所以很特殊..
String就是这么一个特殊的类.
因为String用的很频繁.所以,java的设计师就允许程序员直接赋值.
String str = "XXXX";
就像o_eonian()所说,这是个常量.
那么参数里传过去的是什么???常量值啊..这一题考的就是String这个特殊的类型

Answer 40

可能我说的还不够明确.
String只不可变的.StringBuffer才是可变的.
无论String是直接赋值常量,还是动态的开辟内存空间(new)
那么在那块内存区域就不可以再更改值!!
public class test {
    public static void changeStr(String str){
        str = str.replace('1','a');
    }
    public static void main(String[] args) {
        String str= new String("1234");
        changeStr(str);
        System.out.println(str);
    }
}
大家会看到结果还是1234.

Answer 41

都是高手呀，帮我做做这一题看看！
http://community.csdn.net/Expert/topic/4746/4746944.xml?temp=.1391413

Answer 42

QUESTION NO: 1
1、public class Test {
    public static void changeStr(String str){
//这里Java是传递的是引用，也就是对象的地址，但是这里的str只是changeStr的形式参数，
//函数调用时，原来"1234"的地址被赋给了这里的str,但是下面的一句又将str的值换成了
//对象"welcome"的地址.        str="welcome";
//这一句改变的是函数形式参数（也就是局部变量str里保存的地址，使str引用的是"welcome",
//但是，Main函数里面的那个str还是引用的"1234"
    }
    public static void main(String[] args) {
        String str="1234";
        changeStr(str);
        System.out.println(str);
    }
}
Please write the output result ：上面的那个程序用c语言写就是下面的形式：void changeStr(char *str)
{
   str="welcome";
}
void main(String[] args) {
        char *str="1234";
        changeStr(str);
        printf("%s",str);
    }
}

Answer 43

接上面：在c语言里面，要想在一个函数里面改变一个字符指针指向的字符串，一定要用指针的指针，因为指针也是变量，如果只是简单的传递指针，参数传递是传的指针变量的值，不是指针变量的地址，在函数里面不能改变指针变量的值。Java里对于对象是传引用，类似于指针，但是需要的不仅仅是指针，而是指向指针变量的指针。

Answer 44

楼上的.那么我这个例子你怎么解释??
public class test {
    public static void changeStr(String str){
        str = str.replace('1','a');
    }
    public static void main(String[] args) {
        String str= new String("1234");
        changeStr(str);
        System.out.println(str);
    }
}
如果是把地址传过去了.为什么str没有改变?

Answer 45

java不考虑参数的类型，一律传递参数的副本(也就是值)。
或许有些人认为是基本类型就传递值,如果是对象,就传递引用...
其实这是错误的..
在c++中，当参数是引用类型，你传递的是引用或者内存地址（传引用），而在java中，传递一个引用类型的参数的结果只是传递引用的副本（传值）而非引用自身。
看下面例子:
package test;class Swap {
    public static void main(String args[]) {
        Integer a, b;
        a = new Integer(10);
        b = new Integer(50);
        System.out.println("Before Swap, a is " + a);
        System.out.println("Before Swap, b is " + b);
        swap(a, b);
        System.out.println("After Swap a is " + a);
        System.out.println("After Swap b is " + b);
    }    public static void swap(Integer ia, Integer ib) {
        Integer temp = ia;
        ia = ib;
        ib = temp;
    }
}
如果传递的是引用的本身..那么值会交换的.

Answer 46

changeStr(str)传递的是str的一个副本,用replace方法肯定改变了changeStr()方法中str的属性,但是跳出来后还是main()里面的str,所以str指向的还是"1234",所以str没有改变.

Answer 47

这么多菜鸟，连第一题都要争这么久，受不了了，不就是java对string对象特殊对待了而已吗，要是换成别的对象，值就是会改变的。基本功太差了

Answer 48

assassin5616() ( ) 信誉：100  2006-05-12 16:00:00  得分: 0  
 
 
   这么多菜鸟，连第一题都要争这么久，受不了了，不就是java对string对象特殊对待了而已吗，要是换成别的对象，值就是会改变的。基本功太差了
  
 ------------------------------------------
是菜鸟的恰恰是阁下，不仅仅是string对象如此,所有外覆类型都如此，你可以把上例中String改成Integer看看,俺已经说明过一次,外覆类的中的方法调用都是产生一个新对象,这就是最大的不同，具体请见TIJ的附录

Answer 49

coolmomo(momo) 有些地方说得不对C/C++里也是传的指针或引用的副本，

Answer 50

我是受不了，才说两句的。
针对第一题， 可以看出，。 很多人基础真的很差啊。哈哈， 字符串是一个特殊的引用类型。 str只是指向他的引用罢了。
当str = "welcome". str 就指向了其他一个地方。但是mian里面的根本就没有受影响。
因为函数体里面的str和mian里面的不是一个str。 所以建议函数参数和传入参数尽量不要同名字呢。 就是这个原因， 免得引起误解， 看到这么多人都误解， 实在是。 唉！
schol(Lv5)， 你的代码。 里面把东西封装到一个对象里面
所以。 因为对象的引用没有被改变， 你改变是对象的成员，同样地址的一个东西，里面的成员变了， 所以。 会改变。
如果你把里面的那个对象t new一次， 你就明白了。

Answer 51

SELECT * FROM TABLE
和
SELECT * FROM TABLE 
WHERE NAME LIKE '%%' AND ADDR LIKE '%%' 
AND (1_ADDR LIKE '%%' OR 2_ADDR LIKE '%%' 
OR 3_ADDR LIKE '%%' OR 4_ADDR LIKE '%%' ) 
的检索结果为何不同？也只有在考试中，才能出这种写法~

Answer 52

shuo_shu(取个名字还真难) ,请试一下这个public class Test {    public static void changeStr(Integer str) {
        str = new Integer(8);
    }    public static void main(String[] args) {
        Integer str = new Integer(7);
        changeStr(str);
        System.out.println(str);
    }
    
}public class Test {    public static void changeStr(int str) {
        str = 8;
    }    public static void main(String[] args) {
        int str = 7;
        changeStr(str);
        System.out.println(str);
    }
    
}

Answer 53

String类是final类型值是不能修改的，String str=“welcome”是让str指向另一个对象。
java的函数都是传值的，除非改变了Clone函数！

Answer 54

shuo_shu(取个名字还真难) ( ) 信誉：100  2006-05-12 17:41:00  得分: 0  
 
 
   我是受不了，才说两句的。
针对第一题， 可以看出，。 很多人基础真的很差啊。哈哈， 字符串是一个特殊的引用类型。 str只是指向他的引用罢了。
当str = "welcome". str 就指向了其他一个地方。但是mian里面的根本就没有受影响。
因为函数体里面的str和mian里面的不是一个str。 所以建议函数参数和传入参数尽量不要同名字呢。 就是这个原因， 免得引起误解， 看到这么多人都误解， 实在是。 唉！
schol(Lv5)， 你的代码。 里面把东西封装到一个对象里面
所以。 因为对象的引用没有被改变， 你改变是对象的成员，同样地址的一个东西，里面的成员变了， 所以。 会改变。
如果你把里面的那个对象t new一次， 你就明白了。
  
 ----------------------
 废话，我的那段代码就是为了解释这个。 还有别学了一点就自满，有什么好“哈哈”的，你了解很多吗？ 真正的菜鸟是你这种懂了一点就自以为是的人。！！

Answer 55

第一个问题不用讨论了,说那么多,killme2008说的是对的

Answer 56

1.1234
2.A
3.AC
4.A
5.B
6.BG

Answer 57

SELECT * FROM TABLE
和
SELECT * FROM TABLE 
WHERE NAME LIKE '%%' AND ADDR LIKE '%%' 
AND (1_ADDR LIKE '%%' OR 2_ADDR LIKE '%%' 
OR 3_ADDR LIKE '%%' OR 4_ADDR LIKE '%%' ) 
的检索结果为何不同？我是新手，请问 ：如果TABLE建了索引，第一句用到索引，
而第二句没有，是吗？