小题目（错题）

1、

public class StringDemo{

  private static final String MESSAGE="taobao";

  public static void main(String [] args) {

    String a ="tao"+"bao";

    String b="tao";

    String c="bao";

    System.out.println(a==MESSAGE);

    System.out.println((b+c)==MESSAGE);

  }

}

输出结果是：true  false

解析：

要注意两个问题：
1，字符串在java中存储在字符串常量区中
2，==判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true

再次比较(b+c)==MESSAGE 这相当于 new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false

 "ABC".toLowerCase()会返回一个新的字符串对象，所以==abc是false。

2、

下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader

A，Thread可以被继承，用于创建新的线程

B，Number类可以被继承，Integer，Float，Double等都继承自Number类

C，Double类的声明为

1	public final class Doubleextends Numberimplements Comparable<Double>

  final生明的类不能被继承

D，Math类的声明为

1	public final class Mathextends Object

   不能被继承

E，ClassLoader可以被继承，用户可以自定义类加载器

 

 

3.
以下代码的输出结果是？

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class B {     public static B t1 = new B();     public static B t2 = new B();     {         System.out.println("构造块");     }     static     {         System.out.println("静态块");     }     public static void main(String[] args)     {         B t = new B();     } }

• 静态块 构造块 构造块 构造块

• 构造块 静态块 构造块 构造块

• 构造块 构造块 静态块 构造块

• 构造块 构造块 构造块 静态块

正确答案是选C。。这是阿里巴巴的题，只能说优秀。。

首先要注意以下几点：

1、每调用一次构造方法(new )，则执行一次构造块(非静态的，这是必然执行的，而静态的只有在第一次执行)，构造块在类加载阶段不执行，只有在调用构造函数时才执行。

2、静态块只在类加载(初始化阶段)的时候加载一次，类加载的准备阶段（在初始化阶段之前）初始化静态变量（块）。

3、有多个静态变量或块时，按声明顺序加载。需要初始化的就是静态变量或块，静态方法不用初始化，使用时直接调用即可，main方法除外，该方法不需要调用，它是程序的入口（main方法作为类加载中初始化的条件之一，会触发初始化，初始化阶段会初始化静态变量和块）。

静态代码块（静态变量）只有在类第一次加载时（触发初始化的五个条件）才会初始化，而且只能加载一次。

这一题的分析：首先会找到程序入口main方法，调用main方法，此时会触发类加载中的初始化，加载类B，会按顺序给静态变量或块进行初始化，所以首先执行t1=new B()。此时因为 已经加载过类B一次了（调用main方法时），所以这是第二次加载类B，所以不会再触发静态块的初始化，由于这里调用构造函数，所以执行非静态块（或非静态变量的初始化），所以会输出“构造块”，然后t1初始化结束，继续初始化t2（因为第一次的类加载还没有结束），也是一样，只执行非静态块，输出“构造块”，接下来继续初始化静态变量（块），输出“静态块”。到这里为止，由main方法触发的类加载结束了，然后执行方法中内容，t=new B()。这是也就是只执行非静态的，也就是输出“构造块”。

 

4.

以下代码执行后输出结果为（ ）

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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);      }  }

输出结果为

hello and dbc  .

注意：在fun中函数变量str和成员变量str是不一样的，不是一个变量，这里函数中修改的只是函数变量指向的值，并没有对地址的内容进行改变。
而ch数组对ch[0]操作，是直接对地址内容操作了，所以ch的内容要变了

 

内部类

 1.成员内部类的实例：Outer out=new Outer(); Inner in=out.new Inner();          /Outer.Inner in=out.new Inner();

2.静态内部类：Outer.Inner in=new Outer.Inner();

 

正确答案: A B D E   你的答案: A B D (错误)

float f[][] = new float[6][6];

float []f[] = new float[6][6];

float f[][] = new float[][6];   x

float [][]f = new float[6][6];

float [][]f = new float[6][];

以下代码将打印出

1 2 3 4

public static void main (String[] args) {      String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";     System.out.println(classFile); }

正确答案: C   你的答案: B (错误)

com. jd

com/jd/MyClass.class

///////MyClass.class

com.jd.MyClass

由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换