java面试用

1. 使用Java开发应用程序包括编写源程序，编译源程序，解释并运行三个步骤，其中编译和解释分别需要使用javac.exe和 java.exe 实现

2.int i=078 //编译会错误，因为java中不能直接写八进制的 The literal 078 of type int is out of range

3. short s=1;s=s+1; short s=1;s+=1; 哪个错误？第一个错误，因为s+1会变成int类型的报错。

4. static void main(String args[]) //错误。必须public才可以，不然执行时会报错误。

public static void main() //正确，当做普通方法

5.int a=5; System.out.println("value: "+((a<5)?10.9:9)); 输出结果是？ //9.0,不能为9，

因为10.9影响了数据精度，然后进行自动转换。

字节：

boolean 布尔型              1/8
byte 字节类型                1
char 字符型                  2 一个字符能存储一个中文汉字
short 短整型                 2
int 整数类型                 4
float 浮点类型（单精度）     4
long 长整形                  8
double 双精度类型（双精度） 8

三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。

6.char x='x';

int i=10;

System.out.println(false?i:x); //因为i是变量，x被提升为int类型，所以输出120

System.out.println(false?10:x); //当表达式中有一个数是常量，另一个是T类型，则输出T类型的结果。x

7.&&前面是false,则&&后面的表达式就不用再算；||前面是true,则||后面的表达式就不用再算。但是 & 和 | 依旧要算。

8.二进制中8位是一个循环，所以a=32;a>>32后，仍旧是32；但a>>33则为1。

9.System.out.println(true?false:true==true?false:true); ==优先级比?:高，先执行

得到： true?false:true?false:true; 所以前面看做一个整体，true执行false,结果为false

10.final：修饰的类不能被继承;方法能被继承，但不能被重写；修饰基本类型变量，变量的值不能被改变；

修饰引用类型变量(如类对象)，栈内存的引用变量值(指向堆内存的地址)就不能变；成员变量的值可以改变；

finally: 是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。

finalize: 是Object类的一个方法，在垃圾收集器执行的时候会调用回收对象的此方法，

可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

==和equals的区别于联系：

1.==

a)基本类型，比较的是具体的值

b)引用类型，比较的是地址

c)不能比较没有父子关系的对象如String和StringBuffer和StringBuilder

2.equals

a)系统的类一般都已经覆盖了equals()，比较的是内容

b)用户自定义的类如果没有覆盖equals()，则会调用父类的equals( 比如是Object)，

而Object的equals比较的是地址（return this==obj）

c)用户自定义类需要覆盖父类的equals(),否则默认是直接父类的equals()或者Object的equals()

注：Object的==和euqals

11.能输出false结果的为 AB

String str1="java";

String str2="java";

String str3=new String("java");

StringBuffer str4=new StringBuffer("java");

A. str2==str3 //内存地址不同 false

B. str3.equals(str4) // 由于StringBuffer字串默认初始长度16+java的长度为20，跟str3长度4比较为false

C. str1==str4 //类型不同不能进行地址比较

D.str1==str2 //str1已经在方法区生成，str2使用已生成的java字符串，两个一样。

1.abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?　　

abstract不可以被static,因为抽象方法要被子类实现，与static没关系。

abstract的method也不可以是native，native是要用另外一种依赖平台的编程语言(如c)实现，不存在被子类实现。所以也不能

abstract不可以是synchronized的；因为synchronized同步使用的同步锁对象是this,而抽象方法无法确定是this是什么。

2.try...finally 分析：

public static boolean finallyTest1() {

try {

int i = 10 /0; // 抛出 Exception，后续处理被拒绝

System.out.println("i vaule is : " + i);

return true; // Exception 已经抛出，没有获得被执行的机会

} catch (Exception e) {

System.out.println(" -- Exception --");

return true; // Exception 已经抛出，获得被执行的机会，但返回操作将被 finally 截断

}finally {

System.out.println("finallyTest last");

return false; // return 将结束整个方法，返回 false,已经return false，就不再执行catch里面的return true;

}

static int mtest2() {

int x = 1;

try {

System.out.println("m2 return.."+x);

return x; //应该看做return语句已经准备返回1，但是被打断，所以后面++x，虽然x已经改变，但仍旧返回1

} catch(Exception e){

System.out.println(e.getMessage());

}finally {

System.out.println("m2 finally..f "+x);

++x;

System.out.println("m2 finally..e "+x);

//return x;

}

// System.out.println("m2 after...finally"+x);

return x;

}

3.1.假设文件”a.txt”的长度为100字节，那么当正常运行语句”OutputStream f=new FileOutputStream(new File(“a.txt”));”之后，

文件”a.txt”的长度变为0字节。（正确）

OutputStream out=new FileOutputStream("d:\\a.txt",true); //有true为追加文件之后，d:\\a.txt文件内容不会被清空；

OutputStream out=new FileOutputStream("d:\\a.txt"); //没有true，文件会被重写，旧的数据会被清空。

源码打开文件，open(name,append) ///append为boolean代表为true，追加不重写旧文件；false重写，旧文件会被重写，内容清空。

4.输出结果：AB.B

public static void main(String[] args) {

StringBuffer a = new StringBuffer("A");

StringBuffer b = new StringBuffer("B");

mb_operate(a, b);

System.out.println(a + "." + b);

}

static void mb_operate(StringBuffer x, StringBuffer y) {

x.append(y); //x指向a所在的内存区域，直接进行操作。

y = x; //y指向x的内存区域，但是一个新的串，旧指向B的链给断掉，y虽然改变了，但是b的值仍然是B，没变。

}

5.str="fgh"; str2="fghi"; 包含左边，不包含右边。

String str="abcdefghi".substring(5, 8)；

String str2="abcdefghi".substring(5)；

6.java中传值与传引用：

a.对于基本类型变量(int,long,double,float,byte,boolean,char)传值的是副本。

副本改变，自己却不会变。

b.对于一切对象型变量，java都是传引用的副本(实质是复制指向地址的指针，String也是对象型变量，传引用)。

引用副本指向自己的地址，所有会一起变化，而不是实际值的副本。String 是final类

7.Object sobj=new Object(); //因为第2行已置为nulll,符合垃圾回收的要求

sobj=null;

Object sobj=new Object(); //第四行相当于吧sobj置为null

sobj=new Object(); //回收1和3行的内存。

//内存回收的标准： a.给对象了空值null,以后没再调用过

b.给对象赋了新值(重新分配了内存空间)

8.什么是java中的内存泄漏？

在java中，内存泄漏是指存在一个被分配的对象不会被GC所回收，但却占用着内存。

特点：a.对象是可达的，即在有向图中存在通路可以与其相连 b.对象是无用的即程序以后不会再使用这些独享。

内存泄漏的例子：

Vector v=new Vector();

for(int i=0;i<100;i++){

Object obj=new Object();

v.add(obj);//实际仍在引用obj的，解决内存溢出，通过置null或者从v(容器)中移除对象。

obj=null;

}

9.缓存:一种数据结构，用于快速查找已经执行的操作结果。

常见算法：

a.检查结果是否存在缓存中，如果有，则返回结果。

b.如果结果不在缓存中，就进行计算。

c.如果缓存所占的空间过大，就移除缓存最久的结果。

d.将计算出来的结果添加到缓存中，方便以后对该操作的调用可以使用

java.lang.ref.SoftReference可以跟踪缓存中的对象。如果虚拟机的内存

用尽需要更多的堆，则此方法可以保证这些引用被移除

10.clone

Object类的clone是protected的，不能直接调用，可以被子类调用。能知道对象大小，并分配最够的内存空间，并将旧对象

的内容复制到新的对象中，但是Object.clone()执行之前必须检查class是否已经实现了Cloneable接口。

特点：假设x是一个非空对象，

x.clone!=x 为true,说明他们不是同一个对象。

x.clone().getClass()==x.getClass() 为true,说明是同一个类型class

x.equals(x.clone()) 为true,说明逻辑上应该相等。1

11.public class Test {

private String value=null;

public Test(String v){

value=v;

}

public boolean equals(Test o){

if(o==this){

System.out.println("=="); //判断是不是本对象

return true;

}

if(o instanceof Test){

Test test=(Test)o;

System.out.println("equal"); //走equal

return value.equals(test.value);

}

return false;

}

public static void main(String[] args) throws IOException{

List list=new ArrayList();

Test test1=new Test("object");

Test test2=new Test("object");

Test test3=new Test("object");

Object test4=new Test("object");

list.add(test1);

System.out.println(list.contains(test2)); //list中存test1的地址，没有test2的地址，false

System.out.println(test2.equals(test3)); //true，test2与test3是一个类的，使用String的equals

System.out.println(test3.equals(test4)); //false test4是Object所以使用Object的equals
}

}

12.集合：

List:以特定次数存储元素，所以取出来的顺序可能和放入的顺序不同。

Set:每个值只能保存一个对象，不能有重复的元素。

例子：以下输出结果是？无法确定123的输出顺序。564

Map<String,String> map=new HashMap<String,String>();

map.put(String.valueOf(System.currentTimeMillis()+"a"),"1");

map.put(String.valueOf(System.currentTimeMillis()+"a"),"2");

map.put(String.valueOf(System.currentTimeMillis()+"a"),"3");

for(Map.Entry<String, String> entry:map.entrySet()){

System.out.printf(entry.getValue());

}

几种输入和输出流特点：

FileInputStream和FileOutputStream 节点流，以文件为数据源和目的地

BufferedInputStream和BufferedOutputStream 处理流，提供缓冲流，提高读写的效率

DataInputStream和DataOutputStream 处理流，提供了方便读写基本类型数据和String数据的方法。

ObjectInputStream和ObjectOutputStream 处理流，不仅提供了方便读写基本数据类型和String数据的方法，还提供了读写引用数据类型的方法

ByteArrayInputStream和ByteArrayOutputStrem 节点流以字节数组为数据源和目的地。

HashMap与Hashtable的区别：

1) 都属于Map接口的类，实现了将唯一键映射到特定的值上。

2) HashMap没有分类或者排序，允许一个null值和多个null值。

3) Hashtable类似HashMap,但不允许null键和null值。

4) Hashtable继承自Dictonary类，而HashMap是Map接口的一个实现。

5) HashMap把Hashtable的contains方法去掉，改成了containsvalue()和containskey().

6) Hashtable是线程同步的，在多个线程访问Hashtable时，不需要为它的方法实现同步，线程安全；

而HashMap是非同步的，必须为之提供外同步，线程不安全。

Int与Integer的区别：

1) int是8种基本数据类型之一，Integer是整型包装类；

2) int的默认是值0，而Integer的默认值为null

3) Integer可以区分出未赋值和值为0的区别，int则无法表达未赋值的情况

4) Integer提供了多个与整数相关的操作方法，将一个字符串转换成整数，还定义了表示整数的最大值和最小值的常量。

5) 使用集合存整数时，只能使用Integer而不能使用int

如何进行序列化,并写出步骤：

1）Java序列化可以使得将一个对象的状态写入一个Byte流，并且可以从其他地方
把该Byte流里的数据读出来，重新构造一个相同的对象。
2）通过这种机制使得我们可将对象通过网络进行传输，并且可以随时把对象持久化到数据库、文件等系统里。
3）ObjectOutputStream oos=new ObjectOutputStream(new FuleOutputStream(文件名));
4) oos.writeObject(需要序列化的对象);

String、StringBuffer、StringBuilder的区别:

String是一个不可变的类，一旦一个String对象被创建后，包含这个对象的字符串序列是不可变的，直至对象销毁。

StringBuffer代表的是一个字符序列可变的字符串，可以通过append、insert、reverse等方法改变其内容，

一旦最终生成最终的字符串，调用toString()转成String. //意思在没调用之前是一个对象。

StringBuilder与StringBuffer相似，构造方法和方法基本相同。不同的是StringBuffer线程安全，

StringBuilder线程不安全，效率较高。但是通常创建一个内容可变的字符串，优先考虑StringBuilder.

13.输出结果22

public class Test {

public static void main(String[] args) throws IOException{

go(new SubBase());

}

static void go(Base b){

b.add(8);

}

class Base{

int i;

Base(){

add(1);

System.out.println("base "+i);

}

void add(int v){

i+=v;

System.out.println(i);

}

class SubBase extends Base{

SubBase(){

add(2);

System.out.println("sub "+i);

}

void add(int v){

i+=v*2;

System.out.println(i);

}

14.匿名内部类：没有名字的内部类，不能extends其他类，但是可以作为一个接口，由另外一个类去实现。

15.TCP/IP协议三次握手协议，

第一次握手，建立连接时，客户端发送SYN(SYN=j)包到服务器，并进入SYN_SEND状态，等待服务器确认。

第二次握手，服务器收到SYN包，必须确认客户的SYN(ack=j+1)，同时再发送一个SYN(SYN=k)包，即SYN+ACK包，

此时服务器进入SYN_RECV状态。

第三次握手，客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1),此包发送完毕，客户端和服务器

进入ESTABLISHED状态，完成三次握手。

16.class AA{

public int a;

public int c;

public AA(int aa,int cc){

this.a=aa;

this.c=cc;

System.out.println("aa ac "+a+" "+c);

}

class BB extends AA{

public int a;

public int b;

public BB(){

System.out.println("bb "+a+" "+b);

}

public BB(int a,int b){

super(a,b);

System.out.println("bb ab "+a+" "+b);

}

17.结果为12

int counter=0;

for(counter=1;counter++<10;counter++);

System.out.println(counter);

counter = 0;

if (counter < 10) { // 9

counter++; // 满足时的自增 11

}

counter = counter + 1; // 判断条件的counter++ 10

counter++; // 取11跟10比较失败，跳出，counter仍自增,所有1

null

posted on 2018-03-06 18:00 xiaojiayu0011 阅读(286) 评论(0) 收藏举报

刷新页面返回顶部

xiaojiayu0011

java面试用

导航

公告