Java基础面试题-JavaSE_1

1、写出Java的四类⼋种基本数据类

整数 byte short int long

⼩数 ( 浮点 ) float double

布尔 boolean

字符 char

2、& 和 && 的区别

& 符号的左右两边 , ⽆论真或假都要执⾏

&& 符号的左边如果为假 ,符号的右边不再执⾏ , 提⾼了代码的执⾏效率

3、switch的参数可以是什么类型

byte ， short ， int ， char ， String ，枚举

4、说出实例变量和局部变量的区别

1, 物理位置

成员变量 : 类中⽅法外

局部变量 : ⽅法中或⽅法定义的⼩括号⾥⾯

2, 内存位置

成员变量 : 在堆内存中

局部变量 : 通常在栈内存中（栈帧）

3, ⽣命周期

成员变量 : 随着对象创建⽽产⽣ , 随着对象的消失⽽消失

局部变量 : 随着⽅法的调⽤⽽产⽣ , 随着⽅法调⽤结束⽽消失

4, 有⽆默认值

成员变量 : 有默认值 , 整数 0, ⼩数 0.0 字符 ‘\u0000’ 布尔 false 引⽤数据类型 null

局部变量 : 没有默认值 , 使⽤的时候 , 必须先赋值

5、static关键字都能修饰什么？ 都有什么特点

1, 修饰成员变量 , 叫静态变量 具有共享性 , 节省内存空间；

2, 修饰⽅法 : 静态⽅法 : 可以直接使⽤类名 . 进⾏调⽤；

3, 修饰代码块 : 静态代码块 , 给静态变量进⾏赋值；

4, 修饰类 : 静态内部类；

6、overload和override的区别

overload 是重载 要求在同⼀个类中 , ⽅法名相同 , 参数列表不同与返回值类型⽆关 。

参数列表不同表现在 : 个数不同 , 数据类型顺序不同 , 数据类型不同。

override 是重写 要求发⽣在⼦⽗级的继承关系中 , ⽅法名相同 , 参数列表相同 , 返回值类型是⽗类返回值类型本身或其⼦类, 异常等于⽗类本身异常类型或⼩于⽗类本身异常。

7、 final 和 finally的区别

final 是权限修饰符 , 表示最终的 , 能修饰 变量 , ⽅法 , 和类 。

修饰变量 : 变成了常量。

修饰⽅法 : 变成了最终的⽅法 , 不能被重写 , 但是可以被正常调⽤。

修饰类 : 变成的最终的类 , 不能有⼦类 , 但是可以被正常创建对象。

finally 是⼀个代码块 , 只能与我们的 try 代码块连⽤ , 表示⽆论代码是否发⽣异常 ,finally ⾥⾯的代码都要执 ⾏ 。

finally 强制退出两种⽅式： System.exit() 、

Finally 把控细节：

public class FinallyDemo {
    public static void main(String[] args) {
        FinallyDemo finallyDemo = new FinallyDemo();
        //finallyDemo.finallyTestTryNoResult();
        //System.out.println(finallyDemo.finallyTestTryResult());
        //System.out.println(finallyDemo.finallyTestCatchResult());
        System.out.println(finallyDemo.finallyTestFinallyResult());
     }
     // 1.都没有返回值
    public void finallyTestTryNoResult() {
    try {
        System.out.println("try code block invoked");
        //int i = 1 / 0;
        throw new Exception();
     } catch (Exception e) {
        System.out.println("catch code block invoked");
     } finally {
        System.out.println("finally code block invoked");
         }
     }
     // 2.try有返回值
     public String finallyTestTryResult() {
        try {
            System.out.println("try code block invoked");
            return "no result";
            //throw new Exception();
             } catch (Exception e) {
        e.printStackTrace();
            System.out.println("catch code block invoked");
         } finally {
            System.out.println("finally code block invoked");
             }
            return "result";
         }
     // 3.catch有返回值
public String finallyTestCatchResult() {
try {
System.out.println("try code block invoked");
//throw new Exception();
int i = 1 / 0;
return "no result";
 } catch (Exception e) {
e.printStackTrace();
System.out.println("catch code block invoked");
return "error";
 } finally {
System.out.println("finally code block invoked");
    }
}
// 4.finally有返回值
public String finallyTestFinallyResult() {
try {
System.out.println("try code block invoked");
//throw new Exception();
int i = 1 / 0;
return "no result";
 } catch (Exception e) {
e.printStackTrace();
System.out.println("catch code block invoked");
return "error";
 } finally {
System.out.println("finally code block invoked");
return "success";
 }
 }
}

8、 this和super都能⽤到哪些地⽅

1 、访问成员变量

this ：可以区分成员变量与局部变量重名问题 , 如果本类没有这个成员变量 , 也可以调⽤⽗类的成员变量。

super ：可以区分本类成员变量与⽗类成员变量重名问题，只能调⽤⽗类的成员变量。

2 、访问成员⽅法

this ：可以调⽤本类的成员⽅法 , 如果本类没有这个成员⽅法 , 也可以调⽤⽗类的成员⽅法。

super ：只能调⽤⽗类的成员⽅法。

3 、访问构造器

this ：可以通过 this() 或 this( 参数 ) 让其本类的构造⽅法直接相互调⽤。

super ：⼦类通过 super() 或 super( 参数 ) 调⽤⽗类的构造⽅法。

9、 接⼝与抽象类的区别

把控细节 ：

抽象类：

例⼦（ example ）：

public abstract class AbstractDemo {
// 抽象类和普通类基本没有区别（只是多了⼀个可以定义抽象⽅法）
private int a;// 成员变量
private static int b;//静态变量
private static final int c = 1;//常量
// 1.抽象类中静态⽅法--有⽅法的实现
public static void a() {
 }
// 2.抽象类中构造⽅法
public AbstractDemo(int a) {
this.a = a;
 }
// 3.抽象类中实例⽅法
public void b() {
 }
// 4.抽象类中定义⼀个抽象⽅法，注意没有⽅法实现体。
//public abstract void c(){ //fail
//
//}
public abstract void c();// ok
}

接⼝ ：

例⼦（ example)：

public interface InterfaceDemo extends InterfaceDemo1, InterfaceDemo2 {
// 1.接⼝中不能定义静态⽅法--但是可以有静态⽅法的实现
public static void a() {
 }
//public static void b();//fail
// 2.接⼝中不可以定义构造⽅法
//public InterfaceDemo(){//fail
//
//}
// 3.接⼝中不可以定义实例⽅法（没有static 也没有abstract关键字）
//public void c();//fail
// 4.接⼝中不能定义变量--只能有常量
public static final int d = 1;
//public int x;//fail
// 5.接⼝中所有的默认⽅法都是public abstract修饰 且访问修饰符必须要是public或者不写，不写则使
⽤默认(注意：默认指的不是default)
// 抽象类中的访问修饰符四种都可以（public protected private 不写）
void world();// public abstract
// 1.8允许接⼝中有⽅法的实现，但是必须⽤关键字default修饰
default String hello() {
return "hello";
 }
}

10、 静态变量与实例变量的区别

        内存位置 : 静态变量在⽅法区中 , 实例变量在堆内存中。

        ⽣命周期 : 静态变量随着 .class ⽂件加载⽽产⽣ , 随着 .class ⽂件结束⽽结束 ; 实例变量随着对象的创建⽽产⽣ , 随着对象的结束⽽结束。

        调⽤⽅式: 静态变量既可以通过 类名 . 直接进⾏调⽤ , 也可以通过对象名 . 进⾏调⽤ ; 实例变量只能通过 对象名. 进⾏访问。