第7题：示例代码：单例设计模式，两种方法一种即可，并说说这两种方法的区别？

神之梦 发表于 2013-7-15 20:30
5，final修饰的类、方法、变量的特点？提示：变量分为基本数据类型的变量和引用型变量。 ...

final修饰的类不可被继承；修饰方法则不可被重写；修饰基本数据类型变量则该变量不可在被赋值，修饰引用类型变量例如修饰一个数组，其数组的值是可以被修改的，由于引用变量引用的是数组的地址值，所以只要地址值不改变则不会报错。

7题

1. 
   
2. <P>class Single{
   
3.                 private Single(){
   
4.                 }
   
5. 
   
6.                 static Single s = new Single();
   
7. 
   
8.                 public static Single getInstance(){
   
9.                         return s;
   
10.                 }
    
11.         }</P>
    
12. <P> </P>
    
13. <P>懒汉式后建对象,饿汗式先建对象</P>

复制代码

用final修饰变量是常量，修饰的类不能被继承，修饰的方法不能重写
方法内部类对象不能使用该内部类所在方法的非final局部变量。

神之梦 发表于 2013-7-15 20:06
2，列举五个RuntimeException？

1.int a=1/0;
除以零”时，抛出ArithmeticException异常。
2.int a[]={1,2};
System.out.println(a[2]);
空指针异常。NullPointerException
3.String a="aa";
System.out.println(a.charAt(3));
超出字符串的大小，抛出StringIndexOutOfBoundsException异常
4.Object x = new Integer(0);
     System.out.println((String)x);
当试图将对象强制转换为不是实例的子类时，抛出该异常（ClassCastException)
5.int a[]=new int[-1];
创建大小为负的数组，则抛出NegativeArraySizeException异常。

        懒汉式
        class Single {
                private Single(){}

                private static Single s;

                public static Single getInstance(){
                        if(s==null){
                                s = new Single();
                        }
                        return s;
                }
        }

还有一种饿汉式、不同在于饿汉式在创建对象时候会直接static Single s = new Single();

第五题:
final可修饰类,是类不能继承,final不能修饰接口,因为接口要被实现的否则就没有意义.
final可以修饰方法,是方法不能被复写,但可以重载.
final也可以修饰变量,是变量只能被赋一次值,这时变量也就变成了常量.虽然变不能再变,但值可以是变量,所以值本身还是可以变的

第8题：下面代码片段创建（）个对象。
       int a = 10;
       String b = "abc";
       String c = new String("abc");
       MyTest test = new MyTest();

class Single {

//饿汉式
        //第一步：将构造函数私有 不让其他类创建本类对象
        private Single(){}
        //第二步：自己创建一个本类对象
        private static Single s = new Single();
        //第三步：对外提供公共的访问方式
        public static Single getInstance(){
        return s;
        }


//懒汉式

        //第一步：将构造函数私有 不让其他类创建本类对象
        private Single(){}
        //第二步：自己创建一个本类对象
        private static Single s = null;
        //第三步：对外提供公共的访问方式
        public static Single getInstance(){
                if (s == null) {
                s = new Single();
                }
                return s;

神之梦 发表于 2013-7-15 20:35
第6题：重载和重写的区别？

      首先，重载一般是发生在一个类中定义多个重名方法，而这些方法参数列表中个数不同或类型不同。
    重写又叫覆盖，一般发生于子父类之间，子类对父类方法进行重写，子类重写的方法其返回必须小于或等于父类的。
    区别：两者的区别除了一个发生在类中，一个发生在两个类之间外还有几点，比如方法重载可提供类似多态性的好处，但又和多态的机制有些区别，重载方法是可改变返回值类型的，另，重载和重写不同，并非是面向对象所特有的。

神之梦 发表于 2013-7-15 20:12
3，示例代码，如何启动一个线程。两种方法一种即可，并简述这两种方法？

new Thread(new Runnble{
public void  run(){
  for(int i=1;i<5;i++){
   System.out.println(i);
}
}
};
).statrt   //这个是实现匿名内部类，是继承Runnable 接口的。
2.是继承Thread 类，复写run()方法；

第五题:
final可修饰类,是类不能继承,final不能修饰接口,因为接口要被实现的否则就没有意义.
final可以修饰方法,是方法不能被复写,但可以重载.
final也可以修饰变量,是变量只能被赋一次值,这时变量也就变成了常量.虽然变不能再变,但值可以是变量,所以值本身还是可以变的

神之梦 发表于 2013-7-15 20:15
4，写出5个你用过的IO流？

InputStream, FileInputStream ,OutputStream, FileOutputStream ,BufferedInputStram

8题
4个

第八题 3个对象

阅读代码片段，下面（）代码导致程序出错。
int  count;                                //第1行
int  x[] =new int[10];                //第2行
for(int i=0;i<5){                       //第3行
count++;                                //第4行
i++;                                      //第5行
}                                           //第6行
System.out.println(x[5]);        //第7行

第八题:
4个

额..
第3行

第三题:
new Thread(
     new Runnable(){
        public void run(){
           System.out.println("线程执行代码块");//线程执行代码块
        }
     }
   ).start();

第三行啊