Java常见面试题(持续更新中)

常见面试题

1.JDK、JRE、JVM的区别:

  1. JDK:java开发工具包,是java的核心,包括:JRE+编译、运行等命令工具
  2. JRE:java运行环境,是运行java程序所必须的环境的集合,包括:JVM+java系统类库
  3. JVM:java虚拟机,是java实现跨平台的最核心部分,能够运行java语言所开发的程序

2. java的8种基本数据类型是什么?(简述java的8种基本数据类型)

答:8种基本数据类型包括:byte,short,int,long,float,double,boolean,char
1) byte:字节型,用于存储整数的,占用1个字节,范围-128到127
2) short:短整型,用于存储整数的,占用2个字节,范围-32768到32767
3) int:最常用的整型,用于存储整数的,占用4个字节,范围-231到231-1
4) long:长整型,用于存储较大的整数,占用8个字节,范围-263到263-1
5) float:单精度浮点数,用于存储小数的,占用4个字节,不能表示精确的值
6) double:双精度浮点数,最常用的存储小数的类型,占用8个字节,不能表示精确的值
7 ) boolean:布尔型,存储true或false,占用1个字节
8) char:字符型,采用Unicode字符编码格式,存储单个字符,占用2个字节

3.switch可以作用于哪些数据类型上?

答:byte,short,int,char,String,枚举,其余类型都不允许

4.重写与重载的区别:

1)重写:发生在父子类中,方法名相同,参数列表相同
----用于在子类中修改父类中的方法
2)重载:发生在同一类中,方法名相同,参数列表不同
----方法名相同的完全不同的方法

5.实例变量与静态变量的区别:

----实例变量和静态变量都属于成员变量

1)实例变量:是属于对象的,在创建对象时存储在内存堆中,创建多少个对象,则实例变量就会在内存堆中存在多少份,需要通过引用变量来访问

2)静态变量:是属于类的,在类被加载时存储在内存方法区中,无论创建多少个对象,静态变量在内存中都只有一份,常常通过类名来访问

6. java是值传递还是引用传递?

—java中无论是基本类型还是引用类型,都是值传递
1)对于基本类型而言,传递的是具体的值的副本
2)对于引用类型而言,传递的是具体的地址值的副本
注意:网站上说Java有引用传递的文章都是错误的!!!

​ 举例:
​ int a = 5;
​ int b = a; //将a的值5赋值给b(传递的是值的副本–5)
​ Student zs = new Student();
​ Student zss = zs; //将zs的地址值赋值给zss(传递的是地址值的副本–0x1111)
​ //zss和zs指向了同一个Student对象

public abstract class Text {
    private static int a;
    public static void main(String[] args) {
        modify(a);//a----静态变量a
        System.out.println(a);//静态方法访问静态变量a,默认值为0
    }
    public static void modify(int a){
        a++;//a是参数,也是局部变量
        System.out.println(a);
    }

7.抽象类与接口的区别:

1)抽象类:
1.1)由abstract修饰
1.2)可以包含变量、常量、构造方法、普通方法、静态方法、抽象方法
1.3)派生类通过extends来继承
1.4)只能继承一个(体现单一继承)
1.5)抽象类中的成员是任何访问权限都可以(默认为默认权限(同包中的))
2)接口:
2.1)由interface定义
2.2)只能包含常量、抽象方法
2.3)实现类通过implements来实现
2.4)可以实现多个(体现多实现)
2.5)接口中的成员的访问权限只能是public(默认为public权限)

8. 运算符"+"基本类型转换面试题

short s = 5; 
//s = s+5;这句话编译错误,short在运算时默认转为int,前面s是short,类型不一致,需改为 s = (short)(s+5) 
System.out.println(s);//10
s +=5;// s = (short)(s+5) 
System.out.println(s);//15
byte a = 5; a =  (byte)(a+10); 
System.out.println(a);//15 a -= 5; 
System.out.println(a);//10

9.内部类面试题

问: 内部类有独立的.class文件吗?

答: 有,成员/匿名内部类都有独立的.class文件.

   外部类名  			  $  		内部类名.class		
    Mama   			$  			Baby .class			 内部类
   NonTnnerClassDemo   $ 		     1   .class  		 匿名内部类
   NonTnnerClassDemo   $ 		     2   .class  		 匿名内部类    
   NonTnnerClassDemo   $ 		     3   .class  		 匿名内部类  

10.String面试题:

常见面试题:
String s = new String(“hello”);
问:如上语句创建了几个对象?
答:2个

第一个:字面量"hello"
----java会创建一个String对象表示字面量"hello",并将其存入常量池中
第二个:new String()
----new String()时会再创建一个字符串对象,并引用hello字符串的内容

请添加图片描述

11."=="和equals的区别

“==”:可以作用于基本类型和引用类型

  • ==:作用于基本类型,是在比较值是否相等
  • ==:作用于引用类型,是比较地址是否相同

equals(): 只能作用于引用类型

  • 若没有重写equals(), 则默认调用的是Object类的equals()类比较地址是否相同,无意义
  • 若想比较对象的属性值是否相同,则必须重写equals()方法. 在java中,String类重写了equals()来比较字符串是否相同.

12.String的常用方法有哪些?

  1. length():获取字符串的长度
  2. trim():去除两边的空白字符
  3. toUpperCase/toLowerCase: 将英文部分转换为全大写/全小写
  4. startsWith/endsWith: 判断是否以???开头或结束
  5. charAt: 根据下标查找字符
  6. indexOf/lastIndexOf: 查找字符串第一次出现/最后一次出现
  7. substring():截取字符串
  8. 静态方法valueOf():将其他数据类型转换成字符串
  9. matches(): 验证匹配的(正则表达式)
  10. replaceAll(): 替换(正则表达式)
  11. split():拆分(正则表达式)

13.String、StringBuilder、StringBuffer的区别:

1)String:由final修饰,所以不能被继承
底层封装的是final的字符数组,所以为不变对象
每次修改String引用变量的值,都是在创建新的对象
适合查看,但不适合频繁修改
2)StringBuilder:底层封装的是字符数组,所做操作就是在该数组之上进行,修改效率高
非线程安全的,并发处理的,性能稍快----一般都用StringBuilder
3)StringBuffer:底层封装的是字符数组,所做操作就是在该数组之上进行,修改效率高
线程安全的,同步处理的,性能稍慢------应用率不高

14.面试题(冒泡排序,去重排序)如下泛型Sting如何去重?

List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        list.add("two");
        System.out.println(set);
 	Set<String> set = new HashSet<>();
	set.addAll(list);//把list集合添加到set中
	System.out.println(set);//输出set

      

15. 请分别说明final,finally,finalize

1) final: 修饰类—类不可以被继承,
修饰方法------方法不可以被重写,
修饰变量-----变量不可以被改变

2)finally:
finally块是异常处理机制的最后一块。
它可以直接跟在try后面或者最后一个catch 后面。
finally块保证:只要程序执行到try语句块中,无论是否出现异常,finally最终都
必定执行。
因此我们会将释放资源这类操作放在这里确保执行。

3) finalize是一个方法,被定义在Object中。
该方法会被GC调用。当一个对象没有任何引用后就会被GC释放资源,在释放前的最后一个操作就是GC调用其finalize方法,调用后该对象被释放。

16.finally相关的代码分析题

public class FinallyDemo3 {
   public static void main(String[] args) {
       System.out.println(
           test("0")+","+test(null)+","+test("")
       );   //没有finally块输出的结果是   0,1,2
   }

   public static int test(String str){
       try {
           return str.charAt(0)-'0';
       } catch (NullPointerException e) {
           return 1;
       } catch (Exception e){
           return 2;
       } finally {
           return 3;
       }
   }
}

输出的结果是3,3,3---------
第一次调用方法 ,return的结果是1,再调用finally,return返回结果3,原来的值被覆盖了.所以输出3,后面一样,以此类推----

补充:

1.构造方法可以私有化(其他类不能访问)

class Aoo{
     private Aoo(){ 
     }
  }
  class Test{
    public static void main(String[] args){
      Aoo o = new Aoo(); //Aoo()报错
     //new对象时候自动调用Aoo中的构造方法,但是Aoo的构造方法权限是私有的,权限不够无法访问
    }
  }

2.超类/派生类/语句块/静态块------执行顺序:

public class ooDay09Evensong {
    public static void main(String[] args) {
        //1)超类静态块  2)超类语句块  3)超类构造方法
        Aoo o1 = new Aoo();//new了一个Aoo对象
        
        /1)超类静态块    2)派生类静态块
        /3)超类语句块    4)超类构造方法
        /5)派生类语句块  6)派生类构造方法
        Boo o2 = new Boo();//new了一个Boo对象,
        //在加载派生类之前先加载超类,所以超类静态块先走
            
        Aoo o3 = new Boo();//向上造型的执行过程,同上
    }
}

class Aoo{
    static{
        System.out.println("超类静态块");
    }
    {
        System.out.println("超类语句块");
    }
    Aoo(){
        System.out.println("超类构造方法");
    }
}

class Boo extends Aoo{
    static{
        System.out.println("派生类静态块");
    }
    {
        System.out.println("派生类语句块");
    }
    Boo(){
        System.out.println("派生类构造方法");
    }
}

3. 文档注释:/** */

1)是一种功能性注释,用于描述某个东西的功能的
2)一般用在类上、方法上、常量上
3)用于类上时可以加参数,常见的有:
3.1)@author用于标记作者(必写)
3.2)@see用于标记参见哪个类
3.3)@since用于标记始于哪个版本

    /**表示窗口的运行状态 */
    public static final int RUNNING = 0;
    /**
    *用于计算两个加数的和
    *@param num1   第一加数(参数)
    *@param num2   第二加数(参数)
    *@return 返回两个加数的和 
    */
    punlic int puls(int num1,int num2){
    int num = num1+num2;
    return num;
    }

4. 局部变量和成员变量的区别

1) 定义位置
成员变量:定义在类中的方法, 属于类
局部变量: 定义在方法中的变量,属于方法
2) 初始值:
成员变量: 有默认是初始值,在加载类的时候就会给成员变量赋初始值
局部变量:没有初始值, 必须初始化才可以使用
3)生命周期
成员变量:属于类,随着对象的创建而创建,随着对象的消失而消失-----GC回收
局部变量: 属于方法,随着方法的调用而创建
4)作用域
成员变量:属于类,类中的每个方法都可以使用
局部变量:属于方法,只能在某个方法中使用
5)优先级不同
在同一个类中, 当局部变量和成员变量同名时, 局部变量的优先级比成员变量高

注意: 在方法的参数列表中的参数也是局部变量.

5. HAVING和WHERE的区别

WHERE : 先执行, 过滤记录
HAVEING : 后执行,过滤分组,仅在GROUP BY后

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值