java面试题

一：学习Java基础的目的?

　　一、掌握基本的Java语言底层编码方法，同时掌握Java这门语言的编程思想，为了后期学习JavaEE打下基础，要不然在学习JavaEE的时候，连封装，继承，多态都不懂.
　　二、在学习完JavaSE和JavaEE后招工作的时候能够答上面试题和笔试题（Java基础在面试的过程中也占不小的一部分）。

二：String是最基本的数据类型吗?

　　　String 是引用数据类型。基本数据类型包括byte、int、char、long、float、double、boolean和short。java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类，JDK1.5版本之后出现了StringBuilder，StringBuilder是线程不同步的，Stringbuffer是线程同步的，开发建议使用StringBuilder,，提高了效率。

三：String 和StringBuffer的区别

　　　JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。

四：Java语言的基础开发工具是：( JDK )，集成开发工具是： ( Eclipse )

五：已知字符a的编码是97，大写字符A的编码是65，而且大写字符和小写字符的编码都是连续的，则小写字符e和大写字符E的编码依次是：(101，69)

 

六：修改以下代码中的错误：

　　char c = 100000;数值超出char的取值范围 

七：Java有没有goto?

　　java中的保留字，现在还没有在java中使用。其实goto这个词是C语言中的，goto语句通常与条件语句配合使用，可用来实现条件转移， 构成循环，跳出循环体等功能。而在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。但是在java语言中，goto这个词只是作为了保留字，还没有使用。那是因为java语言讲究简单，方便。

八：一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

　　可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。

九：在Java中，字符串是作为 对象 出现的。

十：是否可以继承String类?

  　 String是被final修饰的最终类，不能被继承

 

 十一：程序结果：

public class Test extends Fu {
	public static void main(String[] args) {
		int i = 0;
		Fu f = new Test();
		Test t = new Test();
		for(f.show('A');f.show('B') && (i<2);f.show('C')){
			i++;
			t.show('D');
		}
		
	}
	boolean show(char a){
		System.out.println(a);
		return false;
	}
}
class Fu{
	boolean show(char a){
		System.out.println(a);
		return true;
	}
}
//结果为A B

　　

public class Test extends Fu {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.func());//编译失败，因为a所属的A接口没有定义func方法
    }
}
interface A{}
class B implements A{
    public String func(){
        return "func";
    }
}

public class Test extends Fu {
    public static void main(String[] args) {
        A a = get();//相当于   A a = new B();
        System.out.println(a.test());//编译失败，因为a所属的A接口没有定义test方法
    }
    static A get(){
        return new B();
    }
}
interface A{}
class B implements A{
    public String test(){
        return "yes";
    }
}

public class Test extends Super {
    public static void main(String[] args) {
        int i = 4;
        Super d = new Test("A");
        System.out.println(d.i);
    }
    public Test(String a){
        //super();//走的是父类的空参数构造函数
        System.out.println("C");
        i+=5;
    }
}
class Super{
    int i = 0;
    public Super(String a){
        System.out.println("A");
        i = 1;
    }
    public Super(){
        System.out.println("B");
        i+=2;
    }
}
//结果是B C 7

public class Test {
    public static void main(String[] args) {
        //补足代码,调用两个函数，用匿名内部类
        Inter in = new Inter(){
            public void func() {
            }
            public void show(int a, int b) {
            }
        };
        in.func();
        in.show(3, 5);
    }
}
interface Inter{
    void show(int a,int b);
    void func();
}

public class Test {
    public static void main(String[] args) {
        TD.Inner ti = new TD().new Inner();
        ti.show();
    }
}
class TD{
    int y = 6;
    class Inner{
        static int y = 3;//编译失败，非静态内部类中不能有静态成员
        void show(){
            System.out.println(y);
        }
    }
}

class fu{
    int num = 4;
    void show(){
        System.out.println("showfu");
    }
}
class zi extends fu{
    int num = 5;
    void show(){
        System.out.println("showzi");
    }
}
class T{
    public static void main(String[] args){
        fu f = new zi();
        zi z = new zi();
        System.out.println(f.num);//4
        System.out.println(z.num);//5
        f.show();//showzi
        z.show();//showzi
    } 
}

十二:写出错误答案错误原因，用单行注释的方式

class Demo{
    int show(int a,int b){
        return 0;
    }
}
下面那些函数可以在Demo的子类中存在
A.public int show(int a ,int b){return 0;}//可以,覆盖
B.private int show(int a ,int b ){return 0;}//不可以，权限不够
C.private int show(int a,long b){return 0;}//可以，子类特有的方法
D.public short show (int a,int b){return 0;}//不可以，调用的不确定性，当调用show方法是不知道返回short 还是int
E.static int show(int a ,int b){return 0;}//不可以，静态只能覆盖静态 

十三：写出this关键字的含义，final有哪些特点

十四：

十五：多线程面试题

class Test implements Runnable{
    public void run(Thread t){
    }
}
//如果错误 错误发生在哪一行？错误在第一行，应该被abstract修饰,因为run方法没有被覆盖


class ThreadTest{
    public static void main(String[] args) {

        new Thread(new Runnable(){
            public void run(){
                System.out.println("runnable run");
            }
        })
        {
            public void run(){
                System.out.println("subThread run");
            }
        }.start();//结果是subThread run


        /*
        new Thread()
        {
            public void run()
            {
                for(int x=0; x<50; x++)
                {
                    System.out.println(Thread.currentThread().getName()+"....x="+x);
                }

            }
        }.start();
        
        for(int x=0; x<50; x++)
        {
            System.out.println(Thread.currentThread().getName()+"....y="+x);
        }
        Runnable r = new Runnable()
        {
            public void run()
            {
                for(int x=0; x<50; x++)
                {
                    System.out.println(Thread.currentThread().getName()+"....z="+x);
                }
            }
        };
        new Thread(r).start();

        */
        
    }
}