首页 / 面试 / java基础中常见的面试题
java基础中常见的面试题
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了java基础中常见的面试题，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6617字，纯文字阅读大概需要10分钟。
内容图文
java基础中常见的面试题
三目运算符中的常见面试题
第一题
public class Test01 {
public static void main(String[] args) {
double num = 90>100?90.0:100;
System.out.println(num);
}
}
输出：
100.0
解析： 表达式中类型会自动提升。
第二题
public class Test01 {
public static void main(String[] args){
// 判定一个数字奇数还是偶数
int num = -1;
// 被除数-被除数/除数*除数
String str = num%2==1?"奇数":"偶数";
System.out.println(str);
}
}
输出：
偶数
解析： java中的取余运算遵循a%b=a-(a/b)*b 的规则，例如：
5%3=5-(5/3)*3=2
5%-3=5-(5/-3)*-3=2
-5%3=-5-(-5/3)*3=-2
-5%-3=-5-(-5/-3)*-3=-2
如果操作数中有浮点数则采用的规则为a%b=a-(b*q),这里q=int(a/b) ,例如：
5.2%3.1=5.2-1*3.1=2.1
5.2%-3.1=5.2-(-1)*(-3.1)=2.1
-5.2%3.1=-5.1-(-1)*3.1=-2.1
-5.2%-3.1=-5.1-(-1)*(-3.1)=-2.1
类的加载顺序
第三题
package com.mage.interview;
public class Test02 {
public static void main(String[] args) {
new S2().m();
}
}
class F {
static {
System.out.println("F static");
}
{
System.out.println("F init");
}
public F() {
System.out.println("F construct");
}
}
class S1 extends F {
static {
System.out.println("S1 static");
}
{
System.out.println("S1 init");
}
public S1() {
System.out.println("S1 construct");
}
}
class S2 extends F {
static {
System.out.println("S2 static");
}
{
System.out.println("S2 init");
}
public S2() {
System.out.println("S2 construct");
}
public void m() {
new S1();
}
}
输出：
F static
S2 static
F init
F construct
S2 init
S2 construct
S1 static
F init
F construct
S1 init
S1 construct
解析： 对象被创建时，类的加载顺序是：
-
父类的静态代码块
-
子类的静态代码块
-
父类的初始化块
-
父类的构造器
-
子类的初始化块
-
子类的构造器
String
第四题
//由于String不可变 所以经过方法不会发生改变
public class Test03 {
public static void main(String[] args) {
String str = "123";
System.out.println(str);
change(str);
System.out.println(str);
}
public static void change(String str) {
str = "234";
}
}
输出：
123
123
解析： 由于String不可变 所以经过方法不会发生改变。
第五题
//intern 获取到的是当前String对象的地址
public class Test04 {
public static void main(String[] args) {
String s1 = "Cat";
String s2 = "Cat";
String s3 = new String("Cat");
System.out.println("s1 == s2 :" + (s1 == s2));
System.out.println("s1 == s3 :" + (s1 == s3));
String s4 = s1.intern();
System.out.println("s1 == s4 :" + (s1 == s4));
System.out.println("s3 == s4 :" + (s4 == s3));
}
}
输出：
s1 == s2 :true
s1 == s3 :false
s1 == s4 :true
s3 == s4 :false
解析： String s1 = "Cat"; String直接创建变量时，所创建的变量的值是存放在常量池中的，再一次创建变量赋给相同的值时直接在常量池中寻找该值，String s3 = new String("Cat"); 通过new创建对象会在堆中开辟空间，然后将常量池中该值的地址存放在该开辟的空间中。String s4 = s1.intern(); intern 获取到的是当前String对象的地址。内存分析图如下：
第六题
/* *
* +号拼接：
* 左右两边操作数如果是字面值，则直接拼接之后再在常量池开空间
* 如果左右两边操作数是变量，则通过常量池重新分配空间存储变量地址
*/
public class Test05 {
public static void main(String[] args) {
String s1 = "Cat";
String s2 = "Dog";
final String s3 = s1 + s2;// append
String s4 = "CatDog";
String s5 = "Cat" + "Dog";// s5 = "CatDog"
System.out.println(s3 == s4);
System.out.println(s4 == s5);
}
}
输出：
false
true
解析： 用+号进行字符串拼接：
- 左右两边操作数如果是字面值，则直接拼接之后再在常量池开空间。
- 如果左右两边操作数是变量，则通过常量池重新分配空间，该空间存储变量地址。
类加载
一个类何时被加载：
- 主动使用
- 创建一类的实例 new Person();
- 访问某个类、接口中的静态变量，或者对于静态变量做读写；
- 调用类中的静态方法；
- 反射 （Class.forName(“xxx.xxx.xxx”)）;
- 初始化子类 父类会被加载。
- Java虚拟机标明的启动器类 (Test.class(main)|Person.class|Student.class，此时Test就是启动器类).
- 被动使用
- 引用常量不会导致该类发生初始化[常量它是在编译器确定的]
- 通过数组定义类的引用，不会触发该类的初始化
- 通过子类引用父类的静态变量，不会导致子类初始化。
第七题
package com.mage.test;
/*
* 类加载：
* 连接
* 验证(字节码文件的验证)
* 准备 将静态内容做初始化
* 解析(将符号引用 变为直接引用)
* 初始化
* 给静态内容赋值
*
*/
public class Test06 {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
System.out.println(s1.count1);
System.out.println(s1.count2);
}
}
class Singleton{
//准备阶段 null 0 0
private static Singleton singleton = new Singleton();
public static int count1;
public static int count2 = 0;
private Singleton(){
count1++;
count2++;
}
public static Singleton getInstance(){
return singleton;
}
}
输出：
1
0
解析： Singleton s1 = Singleton.getInstance(); 调用了类中的静态方法，类被加载，静态内容也被加载，利用private static Singleton singleton = new Singleton(); 创建对象时加载构造方法，此时count1=1,count2=2,然后加载public static int count1;public static int count2 = 0; 将count2=0.
第八题
public class Test07{
public static void main(String[] args) {
T[] ts = new T[10];
System.out.println(ts.length);
}
}
class T{
static {
System.out.println("我被执行了");
}
}
输出：
10
解析： 通过数组定义类的引用，不会触发该类的初始化。
第九题
public class Test08 {
public static void main(String[] args) {
System.out.println(Son.num);
}
}
class Father{
static int num = 20;
static {
System.out.println("F 我被执行了");
}
}
class Son extends Father{
static {
System.out.println("S 我被执行了");
}
}
输出：
F 我被执行了
20
解析： 通过子类引用父类的静态变量，不会导致子类初始化。
第十题
public class Test09 {
public static void main(String[] args) {
System.out.println(T2.num);
}
}
class T2{
static final int num = 20;
static {
System.out.println("F 我被执行了");
}
}
输出：
20
解析： 引用常量不会导致该类发生初始化[常量它是在编译器确定的]，如果static int num=(int)Math.random()*20 该常量是一个变化的值，这种情况下类会被初始化，静态内容被加载。
第十一题
public class Test10 {
public static void main(String[] args) {
System.out.println(new T3().num);
System.out.println(T3.t);
}
}
class T3 implements In{
static final int num = 20;
static {
System.out.println("F 我被执行了");
}
}
interface In{
Test05 t = new Test05() {
{
System.out.println("1");
}
};
}
输出：
F 我被执行了
20
1
com.mage.interview.In$1@15db9742
解析： 子类被引用，父类接口没有被调用时，父类接口不会被加载，只有当接口被调用时接口中的内容才会被加载。
第十二题
public class Test11 {
public static void main(String[] args) {
System.out.println(Tns.num);
}
}
interface Tns extends In1{
static int num = 20;
}
interface In1{
Test06 t = new Test06() {
{
System.out.println("1");
}
};
}
输出：
20
解析： 只是调用了子类的引用并没有使用接口中的内容，所以接口内容不会被加载。
类接口没有被调用时，父类接口不会被加载，只有当接口被调用时接口中的内容才会被加载。
第十二题
public class Test11 {
public static void main(String[] args) {
System.out.println(Tns.num);
}
}
interface Tns extends In1{
static int num = 20;
}
interface In1{
Test06 t = new Test06() {
{
System.out.println("1");
}
};
}
输出：
20
解析： 只是调用了子类的引用并没有使用接口中的内容，所以接口内容不会被加载。
内容总结
以上是互联网集市为您收集整理的java基础中常见的面试题全部内容，希望文章能够帮你解决java基础中常见的面试题所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。