java int 转long_java面试题（基础语法）

一、类型转换题

1. Which ofthe following are legal lines ofcode?( 下列哪些代码是合法的？)

(a) int w=(int)888.8

(b) byte x=(byte)1000L

(c )long y=(byte)100

(d) byte z=(byte)100L

参考答案:(a)、(b)、(c)、(d)。

分析：

在Java中,整型、实型、字符型被视为简单的数据类型，这些数据类型由低

到高级分別为:(byte,short,char)int long float double

简单数据类型之间的转换又可以分为:

低级到高级的自动类型转换;

高级到低级的强制类型转换;

包装类过渡类型能够转换。

1、自动类型转换

低级变量可以直接转换为高级变量，下面的语句可以在JAVA中直接通过，代码如下：

byte b;

int i=b;

long l=b;

f loat f=b;

doubled=b

如果低级类型为char型，向高级类型(整型) 转换时，会转换为对应ASCII码值，代码如下：

码如下:

char c='c';

int i=c;

System.out.println("output:"+i);

输出:

output:99 ;

对于byte、short、char 3种类型而言，它们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换，代码如下:

short i=99;

char c=(char)i;

System.out.printIn("output:"+c) ;

输出:

output:c

2.强制类型转换

将高级变量转换为低级变量时，情况会复杂一些，可以使用强制类型转换.示例代码如下：

int i=99;

byte b=(byte)i;

char c=(char)i;

float f=(float)i;

3.包装类过渡类型转换

Java 的包装类将基本数据类型与对象类型在一定程度上统一起来，井提供以下两个方

面的功能。

将基本类型封装后当作对象进行操作。

口为基本数据类型提供各种转换功能。

Java 共有6 个包装类，分别是Boolean、Character、Integer、Long、Float 和Double。

从字面上就可以看出它们分别对应于boolean、char、int、long、float和double 类型。而String和Daue本身就是类。也就不存在包装类的概念。

在进行简单数据类型之间的转换(自动转换或强制转换)时，可以利用包装类进行过渡。

一般情况下，首先声明一个变量。然后生成个对应的包装类，就可以利用包餐类的

各种方法进行类型转换了。例如，当希望把float型转换为double型时、示例代码如下:

float f1=100.00f;

FloatF1=new float(f1);

Double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

当希望把double型转换为int型时，代码如下所示:

doubled1= 100.00;

DoubleD1=new Double(d1);

int i1=D1.intvalue();

当希望把int型转换为double型时，自动转换如下:

int i1=200;

double d1=i1

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数，如Boolean(boolean

value)、Character(charvalue) 、Integer(int value) 、Long(long value)、Floal (float value)、Double(double value)

而在各个包装类中，总有形为XXXValue()的方法，来得到其对应的简单类型数据。利

用这种方法，也可以实现不同数值型变最间的转换。例如对于一个双精度实型类，intValue()

可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

一个浮点类型数据通过强制类型转换可以转换为int类型，这时小数位会被截去，所以

(a) 是正确的。一个长整型数值可以被转换为byte 类型，如果长整型数大于127 转换为

byte 类型就会变为-128，所以(b) 和(d) 是正确的。由于长整型数的范围覆盖byte 类型数范围，所以(c) 也是正确的。

2. switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

可以作用在byte上，因为byte能自动转为int；不能作用在long上，long转int不能自动转，需要强转；在jdk1.7以后可以作用在String上..

二、修饰符相关的考题

编译并运行下面代码，请选择描述正确的项。

public class XiuShiFu{

int i =10;

private static float pi=3.0f;//(1)

public static void main(string [] args) {

public inti= 20;//(2)

final doubled= 4.0d;//(3)

System.out.println(i+d +pi) ;} }

(a) 编译正确，输出结果28.0

(b) 编译错误，(1) 处有错误

(c) 编译错误，(2) 处有错误

(d) 编译错误，(3) 处有错误

(e) 编译正确，输出结果18.0

参考答案(c)

分析：

Java语言定义了public、protected、private、abstract、和final这6个常用修饰符词外，还定义了4个不太常用的修饰符，下面是对这10个java修饰符的介绍。

1、pubic

使用对象: 类、接口、成员。

介绍：无论所属的包定义在哪，该类（接口、成员）都是可访问的。

2、private

使用对象: 成员。

介绍: 成员只可以在定义它的类中被访问。

3、static

使用对象: 类、方法、变量、初始化函数。

介绍：static修辞的内部类是一个项级类，它和类包含的成员是不相关的。静态方法是类方法，被指向到所属的类面不是类的实例。静态变量是类变量，无论该变量所在的类创建了多少实例，该变量只存在一个实例被指向到所属的类而不是类的实例。初始化函数是

在装载类时执行的，面不是在创建实例时执行的。

4、final

使用对象：类、方法、变量。

介绍：被定又成final的类不允许出现子类，不能被覆盖(不应用于动态查询)，变量值不允许被修改。

5、abstract

使用对象：类、接口、方法。

介绍：abstract类中包括没有实现的方法。不能被实例化。abstract 方法的方法体为空

该方法的实现在子类中被定义，并且包含一个abstract方法的类必须是一个abstact类。

6、protected

使用对象: 成员

介绍：protected 成员只能在定义它的包中被访问，如果在其他包中被访问，则实现这个

方法的类必须是该成员所属类的子类。

7、native

使用对象: 成员。

介绍: 与操作平台相关，定义时并不定义其方法，方法被个外部的库实现。

8、synchronized

使用对象: 方法。

介绍: 对于一个静态的方法，在执行之前JVM把它所在的类锁定；对于一个非静态类

的方法，执行前把某个特定对象实例锁定。

9、volatile

使用对象：变量。

介绍：因为异步线程可以访问变量，所以有些优化操作是一定不能作用在变量上的。

volatile有时可以代替synchronized.

10、transient

使用对象: 变量。

介绍。变量不是对象持久状态的一部分，不应该把变量和对象一起串起

三、static静态变量相关考题

运行下面程序，请选择输出结果

public class x(

private static int a

pubilc static void main(String[ ] args) {

modify(a)

System. out.println(a);

}

public static void modify(int a) {

a++;

}

(a) 0

(b) 1

(0) 2

(d) 3

参考答案:(a)

分析：

类的静态变量a在modify（）方法中并没有被改变，而是改变了modify() 方法的参数。（就近原则）如果将上述代码修改如下:

public class x(

private static int a;

pubilc static void main(String[ ] args) {

modify(a)

System. out.println(a);

}

public static void modify(int b) {

a++;

}

那么输出结果为1，但是面试题中静态变量a的值并没有改变，所以应该输出为0。

四、考察构造函数

下面程序代码运行结果是什么?

class MyTest extends Test {

public MyTest() {

system.out.printin("S2");

public class Test {

public static void main(String args[]) {

new myTest( );

public Test() {

System.out.println("S1") ;

}

}

选择正确的答案:

(a) S1。

(b) S2。

(c) S1S2.

(d) S2S1。

考点:考察求职者对于Java的构造函数运行顺序的掌握和理解

出现频率:★★★★

【面试分析】父类的构造函数是先于子类的构造函数运行的。

参考答案: (c)。

五、int和Integer的区别

1、Integer是int的包装类，int则是java的一种基本数据类型

2、Integer变量必须实例化后才能使用，而int变量不需要

3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值

4、Integer的默认值是null，int的默认值是0

延伸：

关于Integer和int的比较

1、由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);

Integer j = new Integer(100);

System.out.print(i == j); //false

2、Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);

int j = 100；

System.out.print(i == j); //true

3、非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);

Integer j = 100;

System.out.print(i == j); //false

4、对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;

Integer j = 100;

System.out.print(i == j); //true

Integer i = 128;

Integer j = 128;

System.out.print(i == j); //false

对于第4条的原因：

java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：

public static Integer valueOf(int i){

assert IntegerCache.high >= 127;

if (i >= IntegerCache.low && i <= IntegerCache.high){

return IntegerCache.cache[i + (-IntegerCache.low)];

}

return new Integer(i);

}

java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了