01:
Path与classPath的区别?
配置环境变量Path是为了让 .Java文件在任意目录下都可以编译.
配置classPath是为了让 .class文件在任意目录下都可以运行.
02:
1.看下面程序是否有问题,如果有问题,指出并说明理由.
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 b2;
从两方面去回答这个题
b1和b2是两个变量,变量里面存储的值都是变化的,
所以在程序运行中JVM是无法判断里面具体的值
byte类型的变量在进行运算的时候,会自动类型提升为int类型
byte b4 = 3 4;
3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了
2.问哪句会报错,为什么?
byte b = 10;
b ;
b = b 1;
答:第三句会报错,因为b是byte类型的,而1是int类型的,相加结果应该为int类型的.
而第二句不会报错是因为 的过程中系统会执行一个强制类型转换的过程
b 即 b = (byte)(b 1);所以不会报错.
3.看下面程序是否有问题,如果有,请指出并说明理由.
short s = 1;s = s 1;
short s = 1;s = 1;
答:第一句有问题,s=s 1;中s是short类型的,而1是int类型的,相加结果应该为int类型.
第二句没有问题,因为 =的过程中隐藏了一个强制类型转换的过程
s =1 即 s=(short)s 1;
注意题:
System.out.println('0' "aa" 47);//结果是0aa47(只要字符与字符串之间没有可以运算的字符
那么就都是连接.)
System.out.println('0' 47 "aa");//结果是95aa
03:
1.请实现两个整数的交换.(不定义第三方变量)
int x=3;
int y=4;
x = x^y;//3^4
y = x^y;//3^4^4=3
x = x^y;//3^4^3=4
System.out.pritnln("x=" x ",y=" y);
2.最有效率的算出2*8的结果?
2 * 2 ^ 3
System.out.println(2<<3);(意思是把2左移3位)
解: 2
00000000 00000000 00000000 00000010 (2的原码反码和补码)
(000)00000 00000000 00000000 00000010000 (2左移3位后的原反补)
16 (2*8的结果)
3.
byte可以作为switch的表达式吗?//可以
long可以作为switch的表达式吗?//不可以
String可以作为switch的表达式吗?//JDK1.7后可以(JDK1.5之后可以是枚举)
05:
Java中到底是传值还是传址?
答:
1.既是传值,又是传地址.基本类型是传值,引用类型是传址.
2.Java中只有传值,因为地址值也是值(出去面试说这种,支持者是詹姆斯高斯林(Java之父)).
06:
谈谈你对面向对象的理解
答:?????
08:
1,看程序,写结果
class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class Demo2_Student {
static {
System.out.println("Demo2_Student静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
结果是: Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
总结:
执行顺序是:(有继承关系)
先执行静态代码块(静态代码块在类中方法外,用static修饰.
随着类加载而执行,并且只执行一次,用于给类进行初始化)
因为加载子类之前,需要先加载父类.
而构造代码块是多个构造方法中重复的代码,被提到类中方法外.所以会在构造方法之前执行.
并且每执行一次构造方法都会先执行一次构造代码块.
最后执行子类中的代码块(先执行子类的构造代码块,因为构造方法是为了给对象进行初始化,是随着对象的创建而调用,所以后执行)
2,方法重写
override和overload的区别?overload能改变返回值类型吗?
overload可以改变返回值类型,只看参数列表.
方法重写:子类中出现了和父类中方法声明一模一样的方法,与返回值类型有关.返回值是一致的(或是子父类)
方法重载:本类中出现方法名相同,参数列表不同,与返回值无关的方法.
子类对象调用方法的时候:先找子类本身,再找父类.(看子类中有没有要调用的方法,如果没有再找父类)
09:
1,面试题:
抽象类与接口的区别:
(1).
接口中的成员变量默认用public static final修饰,只能是常量.
接口中的成员方法默认用public abstract修饰,只能是抽象方法.
抽象类中的成员变量可以是常量,也可以是变量.
(2).
抽象类中有成员变量,有构造方法,有成员方法;
但接口中有成员变量,成员方法,但没有构造方法.
(3).
抽象类只能单继承;但接口可以多实现.
抽象类里可以有抽象方法也可以没有,但如果一个类中有抽象方法,那么这个类就必须定义为抽象类.
2,面试题:
一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
答:可以.这么做的目的只有一个,就是不想让其他的类创建对象,要交给子类完成
3,面试题:
abstract不能和哪些关键字共存
A:static:
被static修饰的可以通过类名去调用,但通过类名调用抽象类没有什么意义,因为抽象类里的方法没有方法体.
B:final:
被final修饰的方法不能被重写,被abstract修饰的方法强制子类重写.
C:private:
被private修饰的方法只能在本类中被访问,被abstract要求子类进行重写.
10:
1,package,import,class有没有顺序关系?
答:有顺序. package语句必须放在程序的第一条可执行语句.
import放在类定义之前,package之后.
之后才是定义class.
2,匿名内部类面试题:
按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
分析:这是链式编程的形式.method方法用Outer调用,说明此方法是用静态修饰的方法
后面跟着再次调用了一个方法,说明前面返回的是一个对象,而show方法又是接口Inter的抽象方法,所以返回的对象是Inter接口的,代码如下:
interface Inter { void show(); }
class Outer {
public static Inter method() {
Inter i = new Inter() {
public void show() {
System.out.println("helloworld");
}
}
/*return new Inter() {
public void show() {
System.out.println("helloworld");
}
};*/ //返回匿名对象的子类对象,并调用方法
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
3,内部类分为:
成员内部类
静态成员内部类
局部内部类:局部内部类访问局部变量必须用final修饰
匿名内部类:是怎样使用的?
A:当做参数传递
???? B:存在一个接口或者类(具体类,抽象类都可)中,通过实现接口,重写方法实现匿名内部类的调用.
4,内部类是如何调用外部类成员的,包括私有:
直接调用:内部类.this.属性
11:
面试题: ==号和equals的区别:
答:==号是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,
基本数据类型比较的是值,引用数据类型比较的是地址值.
equals方法是一个方法,只能比较引用数据类型,所有对象都会继承Object
类中的方法,如果没有重写Object类中的equals方法,equals方法和==
号比较引用数据类型没有区别,重写后的equals方法比较的是对象中的属性.
12:
String类的面试题:
1.判断定义为String类型的s1和s2是否相等
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
2.下面这句话在内存中创建了几个对象?
String s1 = new String("abc"); //创建了两个对象
3.判断定义为String类型的s1和s2是否相等
String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2); //false
System.out.println(s1.equals(s2)); //true
4.判断定义为String类型的s1和s2是否相等
String s1 = "a" "b" "c";
String s2 = "abc";
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
5.判断定义为String类型的s1和s2是否相等
String s1 = "ab";
String s2 = "abc";
String s3 = s1 "c";
System.out.println(s3 == s2); //false
System.out.println(s3.equals(s2)); //true
13:
面试题1,String类型和int类型的相互转型:
int--String:
A: "";(和双引号进行拼接)
B:public static String valueOf(int i)
C:int--Integer--String(Integer类的toString()方法)
D:public static String toString(int i)(Integer类的静态方法)
String--int:
A:String--Integer--int(Integer类的parseInt()方法)
B:public static int parseInt(String s)
面试题2,StringBuffer类型和String类型的相互转换:
A:String -- StringBuffer
a:通过构造方法
b:通过append()方法
B:StringBuffer -- String
a:通过构造方法
b:通过toString()方法
c:通过subString(0,length);
面试题3,String,StringBuffer,StringBuilder的区别:
A:StringBuffer和StringBuilder的区别
a:StringBuffer是jdk1.0版本的,是线程安全的,效率低
b:StringBuilder是jdk1.5版本的,是线程不安全的,效率高
B:String和StringBuffer,StringBuilder的区别:
a:String是一个不可变的字符序列
b:StringBuffer,StringBuilder是可变的字符序列
面试题4,
Integer面试题:
看程序写结果
Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2); //false
System.out.println(i1.equals(i2)); //true
System.out.println("-----------");
Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4); //false
System.out.println(i3.equals(i4)); //true
System.out.println("-----------");
Integer i5 = 97;
Integer i6 = 97;
System.out.println(i5 == i6); //true
System.out.println(i5.equals(i6)); //true
System.out.println("-----------");
Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8); //false(对象存储在常量池中,但是超过了byte数据的范围)
System.out.println(i7.equals(i8)); //true
面试题5,
为什么已经有int类型,还会有Integer类型?
答:因为他是int类型的装箱,更符合现在的面向对象的思想.
Integer能够调用方法来对数据进行相关操作.
15:
面试题:List有三个儿子:ArrayList,Vector,LinkedList.他们的区别,以及什么时候使用谁?
ArrayList和Vector的区别:
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高.
共同点:底层都是数组结构的
ArrayList和LinkedList的区别:
ArrayList底层是数组结构,查询修改快,增删慢.
LinkedList底层是链表结构的,查询修改慢,增删快.
共同点:都是线程不安全的.
查询多时用ArrayList,增删多时用LinkedList,都多用ArrayList,需要线程安全时用Vector.
16:
三种迭代的方法能否执行删除?
for循环:能删除,但需要索引 --(减减)
迭代器:可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常.
增强for循环:不可以删除.
18:
面试题:HashMap和Hashtable的区别:
Hashtable是JDK1.0版本出现的,是线程安全的（同步）,效率低;
HashMap是JDK1.2版本出现的,是线程不安全的,效率高.
Hashtable不可以存储null键和null值;
HashMap可以存储null键和null值.
19:
1,面试题:
final,finally和finalize的区别
三者没有什么关系,只是长得像而已.
final: (最终的)
可以修饰类,不能被继承
可以修饰方法,不能被重写
可以修饰变量,只能被赋值一次.(常量)
finally:
在try catch中使用,不能单独存在.是用来释放资源的.
finalize:
是一个方法. 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
2,面试题:
如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。
答:会执行finally的代码.在return后执行.
具体的说:当执行到try catch中的return语句时,会找语句中是否有finally语句,
如果有就将finally的语句执行完,再彻底返回.但这之前,return已经执行了.
要注意的是:finally中不能写return语句,等同于犯罪.因为一旦finally中有return语句,那么try catch中的return语句就没有什么意义了.
3,面试题:
编译期异常和运行期异常的区别?
编译期异常:当程序发生错误时,如果不处理,编译就不会通过
运行期异常:一般是程序员犯的错误的体现,需要重新修改代码.
