Java 面试题大全（持续更新中）
2.看程序回答问题.
byte b = 10;
b++;
b = b + 1; 型
问哪句会报错,为什么
b = b + 1;这句会报错.当 byte 与 int 进行混合运算的时候,会提升为 int 类型,
两个 int 相加的结果还是 int,赋值给 byte 会损失精度;
而 b++;这条语句在底层会做强制转换,相当于 b = (byte)(b+1);所以不报错.
3.看下面的程序是否有问题，如果有问题，请指出并说明理由.
(1)short s=1; s=s+1;
(2)short s=1; s+=1;
(1):当 short 与 int 进行运算的时候,会提升为 int 类型,两个 int 类型相加的结果也是 int 类型.
(2):在底层会做强制类型转换,相当于 s=(short)(s+1);
4.实现两个整数的交换.
int a = 5;
int b = 3;
(1)用第三方变量://开发常用
int temp = x;
x = y;
y = x;
(2)不需要第三方变量://有弊端,有可能会超出 int 的取值范围
x = x + y;
y = x - y;
x = x - y;
(3)用位运算符交换两个数.
a = a ^ b;
b = a ^ b;
a = a ^ b;
5. 2 * 8 最有效率的运算方式.
2 << 3;
6.switch 的表达式可以是什么?
byte short char int 枚举(jdk1.5) String(jdk1.7)
7.传值和传址
基本数据类型的值传递,不改变原值,因为调用后就会弹栈,局部变量随之消失
引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问
Java 中到底是传值还是传址
1,既是传值,也是传地址,基本数据类型传递的值,引用数据类型传递的地址
2,java 中只有传值,因为地址值也是值(出去面试都说这种,支持者是高司令(java 之父))
8.面向对象特点及特征
特点: 1.是一个更符合人们思想习惯的思想;
2.将复杂的事情简单化;
3.从执行者变成指挥者;
特征: 1.封装 2.继承 3.多态
9.成员变量和局部变量的区别
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存(成员变量属于对象,对象进堆内存)
局部变量：在栈内存(局部变量属于方法,方法进栈内存)
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
引用数据类型变量包括哪些:数组,类,接口,枚举
10.static 关键字
(1)static 关键字的特点
* a:随着类的加载而加载
* b:优先于对象存在
* c:被类的所有对象共享
* d:可以通过类名调用
(2)static 的注意事项
* a:在静态方法中是没有 this 关键字的
* 静态是随着类的加载而加载，this 是随着对象的创建而存在。
* 静态比对象先存在。
* b:静态方法只能访问静态的成员变量和静态的成员方法
* 静态方法：
* 成员变量：只能访问静态变量
* 成员方法：只能访问静态成员方法
* 非静态方法：
* 成员变量：可以是静态的，也可以是非静态的
* 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
* 简单记：
* 静态只能访问静态。
11.静态变量和成员变量的区别
静态变量也叫类变量 成员变量也叫对象变量
A:所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对 象名调用
12.看程序写结果
class Student {
static {
System.out.println("Student 静态代码块"); //3
}
{
System.out.println("Student 构造代码块"); //4 //6
}
public Student() {
System.out.println("Student 构造方法"); //5 //7
}
}
class Demo2_Student {
static {
System.out.println("Demo2_Student 静态代码块"); //1
}
public static void main(String[] args) {
System.out.println("我是 main 方法"); //2
Student s1 = new Student();
Student s2 = new Student();
}
}
13.看程序写结果
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class Test1_Extends {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
/*
fu
zi
30
20
10
*/
14.看程序写结果
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
}
/*
1,jvm 调用了 main 方法,main 进栈
2,遇到 Zi z = new Zi();会先将 Fu.class 和 Zi.class 分别加载进内存,
再创建对象,当 Fu.class 加载进内存，父类的静态代码块会随着 Fu.class
一起加载,当 Zi.class 加载进内存,子类的静态代码块会随着 Zi.class 一起加载
第一个输出,静态代码块 Fu,第二个输出静态代码块 Zi
3,走 Zi 类的构造方法,因为 java 中是分层初始化的,先初始化父类,
再初始化子类,所以先走的父类构造,但是在执行父类构造时,发现父类
有构造代码块,构造代码块是优先于构造方法执行的所以
第三个输出构造代码块 Fu,第四个输出构造方法 Fu
4,Fu 类初始化结束,子类初始化,第五个输出的是构造代码块 Zi,构造方法 Zi
*/
}
class Fu {
static {
System.out.println("静态代码块 Fu"); //1
}
{
System.out.println("构造代码块 Fu"); //3
}
public Fu() {
System.out.println("构造方法 Fu"); //4
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块 Zi"); //2
}
{
System.out.println("构造代码块 Zi"); //5
}
public Zi() {
System.out.println("构造方法 Zi"); //6
}
}
Zi z = new Zi(); 请执行结果。
15.方法重写的面试题
Override 和 Overload 的区别?Overload 能改变返回值类型吗?
overload 可以改变返回值类型,只看参数列表
方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
方法重载：在同一个类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
16.final 关键字的面试题?
A:修饰局部变量
B:初始化时机
/*
A：
基本类型：值不能被改变。
引用类型：地址值不能被改变。对象中的属性可以改变。
B：
显式初始化
在对象构造完毕前即可
*/
17.一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以
这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
18.abstract 不能和哪些关键字共存
static final private
abstract 和 static
被 abstract 修饰的方法没有方法体
被 static 修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
abstract 和 final
被 abstract 修饰的方法强制子类重写
被 final 修饰的不让子类重写,所以他俩是矛盾
abstract 和 private
被 abstract 修饰的是为了让子类看到并强制重写
被 private 修饰不让子类访问,所以他俩是矛盾的
19.看程序写结果
A:看下面程序是否有问题，如果没有，说出结果
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class Test1Demo {
public static void main(String[] args) {
Fu f = new Zi();
f.method();
f.show();
}
}
//编译出错。编译看左边，而 Fu 类中没有 method()方法。
B:看下面程序是否有问题，如果没有，说出结果
class A {
public void show() {
show2();
}
public void show2() {
System.out.println("我");
}
}
class B extends A {
public void show2() {
System.out.println("爱");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("你");
}
}
public class Test2DuoTai {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}
//爱
//你
20.package,import,class 有没有顺序关系
package 放在有效代码的第一行，import 放在中间，class 放在三者最后。
21.要求：使用已知的变量，在控制台输出 30，20，10。
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?); //num
System.out.println(??); //this.num
System.out.println(???);//Outer.this.num
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
22.按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
//需要补齐代码内容
public static Inter method() {
return new Inter() {
public void show() {
System.out.println("HelloWorld");
}
};
}
23.==号和 equals 方法的区别
相同点:都是作比较的，返回的都是布尔类型。
不同点：
(1)==:
* 是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,
基本数据类型比较的是值, 引用数据类型比较的是地址值
(2)equals:
* equals 方法是一个方法,只能比较引用数据类型,所有的对象都会继承 Object 类中的方法,
如果没有重写 Object 类中的 equals 方法,equals 方法和号比较引用数据类型无区别,
重写后的 equals 方法比较的是对象中的属性。
24.判断定义为 String 类型的 s1 和 s2 是否相等
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
//常量池中没有这个字符串对象,就创建一个,如果有直接用即可
25.下面这句话在内存中创建了几个对象?
String s1 = new String("abc");
//创建几个对象
//创建两个对象,一个在常量池中,一个在堆内存中
26.判断定义为 String 类型的 s1 和 s2 是否相等
String s1 = new String("abc"); //记录的是堆内存对象的地址值
String s2 = "abc"; //记录的是常量池中的地址值
System.out.println(s1 == s2); ? //false
System.out.println(s1.equals(s2)); ? //true
27.判断定义为 String 类型的 s1 和 s2 是否相等
String s1 = "a" + "b" + "c";
String s2 = "abc";
System.out.println(s1 == s2); ? //true,java 中有常量优化机制
System.out.println(s1.equals(s2)); ? //true
28.判断定义为 String 类型的 s1 和 s2 是否相等
String s1 = "ab";
String s2 = "abc";
还未添加个人签名 2021.11.08 加入
还未添加个人简介
评论