推广计划和推广单元什么区别/小吴seo博客

一、String、StringBuffer、StringBuilder区别

        (1)String。采用 final修饰，对象不可变，线程安全。如果对一个已经存在的String对象修改，会重新创建一个新对象，并把值放进去。

        (2)StringBuffer，可变对象，采用 synchronized 关键字修饰，线程安全，因此比StringBuilder慢。

        (3)StringBuilder，可变对象，非线程安全，但效率会更高些，适用于单线程。

例题

1、问：运行以下程序代码，会打印什么结果？

public class Sample {public static void main(String args[]) {StringBuffer a = new StringBuffer("One");StringBuffer b = new StringBuffer("Two");swap(a,b);System.out.println("a is "+ a +" b is " + b);}static void swap (StringBuffer a, StringBuffer b) {a.append(" more");b=a;}
}

（A）    a is One    b is Two
（B）    a is One    b is One
（C）    a is One more    b is One more
（D）    a is One more    b is Two

答：D；swap()方法的参数a与main()方法中的变量a都引用同一个StringBuffer对象，swap()方法的a.append(" more")会修改参数a引用的StringBuffer对象的内容。

2、问：以下代码能否通过编译，如果通过编译，运行时得到什么打印结果？

Object o = new String("abcd");
String s = o;
System.out.println(o);

（A）运行时打印“abcd”。
（B）运行时打印“java.lang.Object@de6ced”。
（C）运行时出错：抛出java.lang.ClassCastException。
（D）编译时出错：变量o不能直接赋值给变量s。

答：D；变量o为Object类型，把它赋值给变量s时，必须进行强制类型的转换：String s=(String)o。

3、问：String fullName = "Jason Shapiro";下面那句话会打印大写的"JASON SHAPIRO"?

（A）fullName = fullName.toUpperCase();
（B）fullName.toUpperCase();

答：A；问题体现了不变性和返回值，只有fullName再次接收返回值，才能真正改变。

4、问：执行以下代码，得到什么结果？

String s1="JavaThinker";
String s2=".net";
s1.concat(s2);
System.out.println(s1);

（A）打印：JavaThinker
（B）打印：JavaThinker.net
（C）打印：.net
（D）运行时出错

答：A；s1.concat(s2)方法的返回值是“JavaThinker.net”字符串，而s1变量本身的取值不变。

6、问：String s = new String("abc")；创建了几个 String Object?

答：分为两种情况。

（1）如果String常理池中，已经创建"abc"，则不会继续创建，此时只创建了一个对象new String("abc")

（2）如果String常理池中，没有创建"abc"，则会创建两个对象，一个对象的值是"abc"，一个是指向"abc"的引用对象s。

二、== 和 equals 有什么区别？

        == ，如果是基本数据类型，比较两个值是否相等；如果是对象，比较两个对象的引用是否相等，指向同一块内存区域

        equals，用于对象之间，比较两个对象的值是否相等。

例题

1、问：假设有以下代码String s=“hello”;String t=“hello”;char c[]={'h','e','l','l','0'}，下列选项中，返回false语句的是?

A.s.equals(t)

B.t.equals(c)

C.s==t

D.t.equals(new String(“hello”))

答：B。从上面的介绍可以看出A与D显然会返回true，从不可变类小节的介绍中可以得出，选项C的返回值也为true。对于选项B，由于t与c分别为字符串类型和数组类型，因此返回值为false。

2、问：下面程序的输出结果是什么？String s=“abc”;String s1=“ab”+“c”;System.out.println(s==s1);

答：true。在不可变类小节中已经介绍过，“ab”+“c”在编译器就被转换为“abc”，存放在常量区，因此输出结果为true。

3、问：对于以下程序代码：
        Float f = new Float(0.9F);
        Float g = new Float(0.9F);
        Double d = new Double(0.9);

        以下哪个是合法的表达式，并且取值为true？ 
    （A）(f==g)
    （B）(f.equals(new Float(0.9F))
    （C）(f.equals(d))
    （D）(f=(Float)d)

答：B；“==”操作符判断两个引用变量是否引用同一个Java对象。变量f和变量g分别引用不同的Float对象，因此“f==g”的值为false。

三、访问修饰符

        类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。

修饰符	当前类	同 包	子 类	其他包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

例题

1、问：给出如下代码；如何使成员变量m 被方法fun()直接访问？

class Test{private int m;public static void fun() {// some code...}
}

（A）将private int m 改为protected int m
（B）将private int m 改为 public int m
（C）将private int m 改为 static int m
（D）将private int m 改为 int m

答：C；在静态方法中不能直接访问非静态的成员变量，但可以直接访问静态的成员变量。

2、问：顶层类（非内部类）可以采用哪些访问控制级别？
（A） private，默认，protected，public
（B） public，默认
（C） public，protected
（D） public，private

答：B；顶层类可以采用public和默认访问控制级别。

3、问：如果一个方法只能被当前类以及同一个包中的类访问，这个方法使用什么访问控制级别？ 
（A）public
（B）默认
（C）protected
（D）private

答：B；如果一个方法处于默认访问级别，它只能被当前类以及同一个包中的类访问。

4、问：关于非静态内部类，以下哪个说法正确？ 
（A） 它必须实现一个接口。
（B） 它可以访问外部类的private类型的实例变量。 
（C） 只有它的外部类才能创建它的实例。
（D） 如果它位于一个方法中，必须声明为final类型。

答：B；非静态内部类可以直接访问外部类的private类型的实例变量。

5、问：一个类中的一个成员变量只可以被所有的子类以及同一个包中的类访问，这个成员变量采用什么访问控制级别？
（A） public
（B） private 
（C） protected 
（D） 默认 

答：C；protected级别的成员变量只可以被所有的子类以及同一个包中的类访问。

6、问：以下哪段是不合法的代码？
（A）

public class Outer {String a;public class Inner {String b;public void innerMethod() {System.out.println("Enclosing a is " + （A）;System.out.println("b is " + （B）;}}public void createInner() {Inner i=new Inner();i.innerMethod();}
}

（B） 

public class Outer {String a;public class Inner {String b;public void innerMethod() {System.out.println("Enclosing a is " + （A）;System.out.println("b is " + （B）;}}public void createInner() {Outer.Inner i=new Outer.Inner();i.innerMethod();}
}

（C） 

public class Outer {String a;int k=1;public static class Inner {String b;public void innerMethod() {System.out.println("Enclosing a is " + a);System.out.println("b i s " + b);}}public void createInner() {Outer.Inner i=new Outer.Inner();i.innerMethod();System.out.println("This is the value of k: " + k);}
}

（D） 

public class Outer {static String a;static int k;public Outer() {k++;}public class Inner {String b;public void innerMethod() {System.out.println("Enclosing a is " + （A）;System.out.println("b is " + （B）;}public void createInner() {Outer.Inner i=new Outer.Inner();i.innerMethod();System.out.println("This is the instance no: " + k);}}
}

答：C；在选项C中，" System.out.println("Enclosing a is " + a);"这句话是错误的。因为Inner类是静态内部类，不能直接访问Outer外部类的实例变量a。

四、&和&&的区别

        &是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。

例题

1、问：以下代码能否通过编译，如果能通过编译，运行时得到什么打印结果？ 

int output=20; 
boolean b1 = false; if((b1==true) && ((output+=10)==30)){ System.out.println("We are equal "+output); 
}else{ System.out.println("Not equal! "+output); 
}  

（A）编译时出错：第3行的逻辑表达式语法不正确。
（B）运行时打印“We are equal 30”。
（C）运行时打印“Not equal! 20”。
（D）以上选项都不正确。

答：C；“&&”为短路逻辑与操作符。表达式“b1==true”的值为false，可以得出整个if条件表达式的值为false，因此表达式“(output+=10)==30”不会被执行，output变量的值仍为20。

2、问：以下程序代码能否通过编译，如果通过编译，运行“java Sample”时会出现什么情况？

public class Sample{void test() {System.out.println(6 && 3); }public static void main(String[] args) {new Sample().test();} 
}

（A） 运行时打印“true”。
（B） 运行时打印“false”。
（C） 编译时出错。
（D） 运行时打印“9”。

答：C；“&&”是逻辑与操作符，两边的操作元必须是布尔类型。

3、问：以下哪段代码段会通过编译？

（A）

int i=0;
if(i){System.out.println("Hello");
}

（B）

boolean b = true;
boolean bb = true;
if(b==bb){System.out.println("So true");
}

（C）

byte i=1;
byte j = 2;
if(i =1|| j=2)System.out.println("OK");

（D）

byte i=1;
byte j = 2;
if(i &1 >j)System.out.println("OK");

答：B；解答：
        比较操作符“>”的优先级比操作符“&”大，因此对于选项D中的表达式“i &1 >j”，先运算“1>j”，得到一个布尔值，再把它与byte类型的变量i进行“&”运算。byte类型变量与布尔值之间既无法进行位与运算，也无法进行逻辑与运算，所以表达式“i &1 >j”是非法的。

五、instanceof 运算符 

        instanceof 用于类型检查。它可用于测试对象是否是类、子类或接口的实例。

例题

1、问：假定在C:盘根目录下存在a.txt文件。以下程序代码能否通过编译，如果通过编译，运行时会出现什么情况？

FileInputStream fin=new FileInputStream("C:\a.txt");
System.out.println(fin instanceof InputStream);
System.out.println(fin instanceof Reader);

    （A） 编译时出错
    （B） 运行时出错
    （C） 运行时打印“true”和“false” 
    （D） 运行时打印“true”和“true”

答：A；FileInputStream类和Reader类不在同一个继承分支上，不能用instanceof 操作符比较，代码“fin instanceof Reader”会导致编译错误。

六、位运算符 

        <<左移、>>右移、>>>无符号右移、&位与、|位或、~位非、^位异或。

        其中位非（~）是一元运算符，其他六个都是二元运算符。

        这些位运算符都是作用在二进制的数上的。

        一般使用场景

位运算符以及常见的使用场景_Lebron_Chen的博客-CSDN博客_java 位运算符应用场景https://blog.csdn.net/Leon_cx/article/details/81911183Java位运算的基础及使用（意义）_易（Master Yi）的博客-CSDN博客_位运算的意义这几天在看HashMap的源码，但里面的位运算太多，看得有点晕。故，先整理位运算相关知识。在了解位运算的计算后，又在思考，使用位运算的意义是什么，毕竟平时开发基本没用过位运算。经大量的资料查找，整理了两个自己感觉比较好的位运算利用例子，特在此记录，分享。另外，毕竟位运算的代码可读性差，请大家谨慎使用。一、位运算基础1、位运算是针对整数的二进制进行的位移操作2、整数 32位 , 正数符号为...https://blog.csdn.net/hhy107107/article/details/82801780例题

1、问：下面哪个选项的说法正确？

        （A） >> 是算术右移操作符
        （B）>> 是逻辑右移操作符
        （C）>>> 是算术右移操作符
        （D）< 是逻辑左移操作符

答：A；>>是算术右移操作符，>>> 是逻辑右移操作符。

2、问：表达式“6 | 3”的值为多少？

         （A） true
         （B） false
         （C） 9
         （D） 7

答：D；表达式“6 | 3”中的“|”是位或操作符。

3、问：以下程序代码能否通过编译，如果通过编译，运行“java Sample”时会出现什么情况？

public class Sample{void test() {System.out.println(6 >> 33); }public static void main(String[] args) {new Sample().test();} 
}

        （A） 6
        （B） 1
        （C） 3
        （D） 编译时出错：操作符“>>”的右边的操作元不能大于32。 

答：C；“>>”是算术右移位操作符，“6 >> 33”等价于“6>>1”。

 七、算术运算符

        +、-、*、/、％、++、--

1、问：以下程序代码能否通过编译，如果通过编译，运行“java Sample”时会出现什么情况？

public class Sample{void test() {System.out.println("Result:" + 6 - 6); }public static void main(String[] args) {new Sample().test();} 
}

        （A） 运行时打印“Result:0”。
        （B） 运行时打印“Result:66”。
        （C） 运行时出错：无法把int类型数据转换为字符串。
        （D） 编译时出错：操作符“-”的操作元的类型不匹配。

答：D；对于表达式"Result:" + 6 ? 6，先计算"Result:" + 6，得到字符串"Result:6"，然后再计算"Result:6" ? 6，String类型与int类型之间无法进行减法运算，因此编译出错。   

2、问：运行以下程序代码，会打印什么结果？

int a=1,b=1;
b=++a;
a=b++;
System.out.println("a="+a+" b="+ b);  

        （A） a=1 b=1
        （B） a=1 b=2
        （C） a=2 b=3
        （D） a=2 b=2

答：C；对于表达式“b=++a”，先把变量a加1，再把变量a赋值给变量b；对于表达式“a=b++”，先把变量b赋值给变量a，再把变量b加1。

3、问：在下面的代码段中，执行之后i 和j 的值是什么? 

int i = 0;
int j;
j = i++;

        （A）0, 1
        （B）1, 2
        （C）1, 0
        （D）1, 1

答：C；“j=i++”的操作先把变量i赋值?变量j，再把变量i的值递增1。

 八、数据类型和封装类型

        基本数据类型包括：int、short、float、double、long、boolean、byte、char；

        对应封装类分别是：Integer、Short、Float、Double、Long、Boolean、Byte、Character。

1、问：下面关于int 和 Integer 的区别，那些是正确的? 

        （A）Integer是int的包装类，int则是java的一种基本数据类型。
        （B）Integer变量必须实例化后才能使用，而int变量不需要。
        （C）Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值。
        （D）Integer的默认值是null，int的默认值是0，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。

答：ABCD

2、问：下面代码输出的是ture还是false；

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j);

答：false；由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

3、问：下面代码输出的是ture还是false；

Integer i = new Integer(100);
int j = 100；
System.out.print(i == j);

答：true；Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆箱为int，然后进行比较，实际上就变为两个int变量的比较）

4、问：下面代码输出的是ture还是false；

Integer i = 100;
Integer j = 100;
System.out.print(i == j);Integer i1 = 128;
Integer j1 = 128;
System.out.print(i1 == j1);

答：true，false；对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false。java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了。