java题目

1, 二维数组的定义      

      char a[][] = new char[2][3]; // 直接定义一个数组，并分配空间
       char b[][] = new char[6][]; // 定义一个不规则数组，分配以为数组的空间，在后面要分别为每一维分配空间，如b[0] = new char[3];这个与c，c++不同，c++中必须一次指明每一维的长度，如new char[2][3];
       char [][]c = new char[3][3];
//       char [][]d = new char[][4];  错误
       int []e[] = new int[10][10];  // 数组的定义形式不限，像[]e[]这样都可以
       char[][] f = new char[3][3]; // 可见char [][]c 和 char[][] c没有区别

 

2, 接口interface常见错误

http://baike.soso.com/v605129.htm

      接口的定义包括接口声明和接口体。
　　接口声明的格式如下：
　　[public] interface interfaceName[extends listOfSuperInterface] { … }
　　 extends 子句与类声明的extends子句基本相同，不同的是一个接口可有多个父接口，用逗号隔开，而一个类只能有一个父类。

　　接口体包括常量定义和方法定义
　　常量定义格式为：type NAME=value; 该常量被实现该接口的多个类共享; 具有public ,final, static的属性。必须被显示初始化
　　方法体定义格式为：(具有 public和abstract属性)
　　returnType methodName([paramlist])；

 

public interface A
   {
    int var; //错,var是常量,必须显示初始化

public A(){...}; //错,接口中不能包含构造方法
    void method(){...};   //错,接口中只能包含抽象方法

    void method2(); //错,接口中的方法必须是public类型
    static void method3(){...};   //错,接口中不能包含静态方法
   }

 

3， 内部类的实例化及其引用  

import com.mao.testjava.Outer.Inner;  // 当通过Inner inner = outer.new Inner(); 时候，需要导入

public class TestJava {

   public static void main(String[] args) {
           Outer outer = new Outer();
          //  Inner inner = outer.new Inner(); // 这样写是可以的,但是要导入Inner这个类
          Outer.Inner inner = outer.new Inner(); //可以直接使用Inner类
          inner.go();
     }

}

class Outer {
            class Inner {
                      void go() {
                      System.out.println("Test Java");
           }
 }
}

内部类是在一个类的内部嵌套定义的类，它可以是其它类的成员，也可以在一个语句块的内部定义，还可以在表达式内部匿名定义。
　　内部类有如下特性：

　　◇ 一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称.名字不能与包含它的类名相同。
　　◇ 可以使用包含它的类的静态和实例成员变量,也可以使用它所在方法的局部变量。
　　◇ 可以定义为abstract。
　　◇ 可以声明为private或protected。
　　◇ 若被声明为static,就变成了顶层类,不能再使用局部变量。
　　◇ 若想在Inner Class中声明任何static成员,则该Inner Class必须声明为static。

 

4， new String() 和 直接赋值的区别

http://blog.csdn.net/kkdelta/article/details/3948725

http://blog.csdn.net/sunnyjavamoon/article/details/913599

       String s3=new String("hellojava");
        String s1="hellojava";
        String s4=new String("hellojava");
        String s2="hellojava";
        String s5=s1;

        System.out.println("s1 == s2:" + (s1==s2));
        System.out.println("s1 == s3:" + (s1==s3));
        System.out.println("s1 == s4:" + (s1==s4));       
        System.out.println("s1 == s5:" + (s1==s5));
        System.out.println("s3 == s4:" + (s3==s4));

打印：

s1 == s2:true
s1 == s3:false
s1 == s4:false
s1 == s5:true
s3 == s4:false

 

demo：                                                         

String str = "abc"+"cde";

String str1 = "abccde";

String str2 = new String("abccde");

String str3 = "abc";

String str4 = "cde";

String str5 = str3+str4;     // =右边是重现new了一个对象，赋值给=左边

String str6 = str2.intern(); // str2.intern() 方法相当于一个liter String，取值与str2相等，最后赋值给str6

String str7 = "abc“+str4;   //有str4变量存在，故=右边会重新new一个对象，给str7

说明：

str == str1 ? YES

str1 == str2 ? NO

str == str5 ? NO

str == str6 ? YES

str == str7 ? NO

 

注意： 像“abc”这样的字符串叫liter String,编译时就放在constent String pool中的了，而new出来的空间是放在堆中的。

 

1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。
2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
3. Java中的数据类型有两种。基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char。存在于栈中。另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中.

String str = "abc";和String str = new String("abc");和char[] c = {'a','b','c'};String str=new String(c);都采用堆存储

String str = "abc";在栈中如果没有存放值为"abc"的地址，等同于：
String temp=new String("abc");
String str=temp;

关于String str = "abc"的内部工作。Java内部将此语句转化为以下几个步骤：
(1)先定义一个名为str的对String类的对象引用变量：String str；
(2)在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并返回o的地址。
(3)将str指向对象o的地址。

使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

char[] c = {'a','b','c'};String str=new String(c);等同于：
String str = new String('a'+'b'+'c');

 

 

5， 线程方法重写

class MyThread extends Thread {
 public void run() {
  System.out.println("MyThread: run()");
 }
 public void start() {      // 将start方法重写了，而代码中也没有调用run方法的痕迹
//  super.start();   //如果加上这句话，就还是会调用run方法的
  System.out.println("MyThread: start()");
 }
}

class MyRunnable implements Runnable {
 public void run() {
  System.out.println("MyRunnable: run()");
 }
 public void start() {    // 将start方法重写了，而代码中也没有调用run方法的痕迹
  System.out.println("MyRunnable: start()");
 }
}

 main 函数中：

MyThread myThread = new MyThread();
  MyRunnable myRunnable = new MyRunnable();
  Thread thread = new Thread(myRunnable);  // 新包装的类
  myThread.start();   

  thread.start();  // 在新包装的类中，默认的start方法还是会调用run方法的

打印：

MyThread: start()    // 该start方法被重载了，而里面的代码又没有调用run方法
MyRunnable: run()

 

// 注意，对于线程Thread，Runnable，默认情况start方法是可以起到run方法，但是要小心start方法被重载

 

6. try {} catch() {} finally {} 中finally 不一定会执行

try {
   System.out.println("try");
//   System.exit(0);  // 强制退出
   return ;  // 在return情况下都是会执行的，除非强制退出、或断电等极端情况
  } catch (Exception e) {
   // TODO: handle exception
  } finally {
   System.out.println("Finally");
  }
打印：

try
Finally