Java基础面试题

Benjamin Cheung

已于 2024-08-08 18:27:20 修改

阅读量856

点赞数 18

分类专栏： Java基础文章标签： java 开发语言

于 2024-07-05 17:35:26 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43732943/article/details/140214894

版权

Java基础专栏收录该内容

35 篇文章

订阅专栏

4种访问修饰符

public: 在所有类中都是可见的
protected: 仅在自己的包中、自己的子类中可见
package-private（没有修饰符）: 仅在自己的包中可见
private: 仅在自己的类中可见

package com.meteorological.basic;
public class Animal {
    private String name;
    protected String habby;
    String remark;
    public String getName() {
        return name;
    }
}

//在自己的包中
package com.meteorological.basic;
public class Animal2 {
    public void test() {
        Animal animal = new Animal();
        System.out.println(animal.habby);//protected在自己的包中
        System.out.println(animal.remark);//没有修饰符在自己的包中
    }
}

//其他包下
package com.meteorological.basic2;
import com.meteorological.basic.Animal;
public class Cat extends Animal {
    public void test() {
        System.out.println(this.getName());//public
        System.out.println(this.habby);//protected子类中可见
    }
}

java面向对象的三大特性

1，封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

类中的成员变量私有化（private）
提供公共的（public）Getter和Setter方法让外界操纵成员变量

2，继承：继承是子类继承父类的特性（包括数据和方法），从而可以扩展或修改父类的行为。子类拥有父类的所有属性和方法（除了private修饰的属性和方法不能拥有）从而实现了实现代码的复用；

如果我们在子类中编写一个独有的方法（没有继承父类的方法），此时就不能通过父类的引用创建的子类对象来调用该方法！！！

子类继承了父类中的所有成员（成员变量、成员方法和嵌套类）。
构造方法不是成员，所以构造方法不会被子类继承，但父类的构造方法可以被子类调用。
子类继承了父类的成员变量和成员方法后，非私有的（public、protected、package-private）属性和方法可以在子类直接访问。
私有的属性和方法子类不能够直接访问，可通过非私有的方法间接访问。

不管使用子类的哪个构造器，默认情况下都会先去调用父类的无参构造器。
如果父类没有提供无参构造器，则子类的构造器中必须用 super 关键字去指定使用父类的哪个构造器。否则，编译无法通过。
public class Animal {
    private String name;
    protected String habby;
    String remark;
    //父类构造方法
    public Animal(String name, String habby, String remark) {
        this.name = name;
        this.habby = habby;
        this.remark = remark;
    }
}

public class Cat extends Animal {
    //super使用的时候必须放在构造器第一行，且super只能在构造器中使用
    //super()和this()都只能放在构造器的第一行，所以这两个方法不能在一个构造器中同时存在
    //子类构造方法
    public Cat(String name, String habby, String remark) {
        super(name, habby, remark);
    }
}

3，多态：多态就是对象的多种形态。
父类的引用可以指向本类的对象，也可以指向子类的对象；
继承是多态的基础。

重载和重写的区别：

区别	含义
方法重载	在同一个类中处理不同数据的多个相同方法名的多态手段
方法重写	相对继承而言，子类中对父类已经存在的方法进行区别化的修改

八种基本数据类型

整型：byte, short, int, long
浮点型：float, double
字符型：char
布尔型：boolean

	byte	short	int	long	float 单精度浮点型	double 双精度浮点型	char	boolean
默认值	0	0	0	0L	0.0f	0.0d	无默认值	false
长度	1字节8bit	2字节16bit	4字节32bit	8字节64bit	4字节32bit	8字节64bit	2字节16bit	1字节（8位）
取值	-128到 127	取值-32768到 32767	-2^31 到 2^31-1	-2^63 到 2^63-1			如：char a = ‘a’;char a = ‘中’;char a = 12; 取值范围0~65536	仅有两个值true, false
包装类	Byte	Short	Integer	Long	Float	Double	Character	Boolean
包装类对象缓存范围	-128~127	-128~127	-128~127	-128~127	没有	没有	0~127	true和false

字符型：char
char占2字节16bit，可以赋值单字符以及整型数值, 变量初始化无默认值，包装类Character。
如：char a = ‘a’;char a = ‘中’;
char a = 12; // 取值范围0~65536，因为char类型在ASCII字符编码中，有对应的数值，可直接做运算，输出字符表中对应的字符

char 类型支持数学运算，背后的原理就是char 可以转化成对应的数字，然后数字计算之后，又可以对应到字符表中的字符，所以运算结果就是新的字符,运算的结果是int 类型，只不过这个int 类型要想赋值给char ，还有一个范围的要求0~65536

char a ='a';
char b =1;
int c = a+b;

Integer a1=100 Integer a2=100，a1==a2的运行结果及原因？

享元模式，通过复用对象，减少对象的创建次数，减少内存占用和提升性能。
Integer内部维护了IntegerCache，它缓存了-128~127这个区间的数值对应的Integer类型。自动装箱调用了valueOf方法，如果在这个区间就直接获取，否则就创建新的对象。结果为true，因为指向了同一个内存地址

Integer a1=-128;
Integer a2=-128;
System.out.println(a1 == a2);//true
Integer a3=128;
Integer a4=128;
System.out.println(a3 == a4);//false

int & integer的区别？

作为成员变量，int初始值为0，integer初始值为null
int存储在栈空间中，integer存储在堆内存中
integer是一个对象类型，封装了很多属性，Java是面向对象的，集合中也只能存储对象元素，普通类型不能存储在集合中

instanceof a是否是b的实例

object instanceof type

1,instanceof只适用于引用类型
System.out.println(1 instanceof int); // 错误！编译时发生错误

2,instanceof可以处理继承关系
public class Animal {
    // Animal类的定义
}
public class Dog extends Animal {
    // Dog类继承自Animal类
}
public class Cat extends Animal {
    // Cat类继承自Animal类
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        System.out.println(animal instanceof Animal); // true
        System.out.println(dog instanceof Animal); // true
        System.out.println(cat instanceof Animal); // true

        System.out.println(dog instanceof Dog); // true
        System.out.println(cat instanceof Dog); // false
    }
}

3,instanceof可以处理接口类型
public interface Drawable {
    void draw();
}
public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}
public class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}
public class Main {
    public static void main(String[] args) {
        Drawable shape1 = new Circle();
        Drawable shape2 = new Rectangle();

        if (shape1 instanceof Drawable) {
            shape1.draw();
        }
        if (shape2 instanceof Drawable) {
            shape2.draw();
        }
    }
}

4,类型判断和处理
public class FormData {
    // 表单数据的定义
}

public class Main {
    public static void processFormData(Object formData) {
        if (formData instanceof FormData) {
            // 处理表单数据的逻辑
            }
    }
}

JDK 和 JRE 有什么区别？

JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。
具体来说 JDK 其实包含了 JRE，同时还包含了编译 Java 源码的编译器 Javac，还包含了很多 Java 程序调试和分析的工具。简单来说：如果你需要运行 Java 程序，只需安装 JRE 就可以了，如果你需要编写 Java 程序，需要安装 JDK。

isEmpty和isBlank的区别

//isEmpty仅当字符串长度为0，或者字符串为null时，认为字符串为空,所以当为""或null时为true
boolean empty = StringUtils.isEmpty(" ");//false
//isBlank，除了isEmpty的功能，还会判断字符串中的每个字符是否为空白字符。
//字符串中至少包含一个非空格字符
//空白字符包括空格、制表符、换页符等
boolean blank = StringUtils.isBlank(" ");//true

== 和 equals 的区别是什么？

== 对于基本类型来说是值比较，对于引用类型来说是比较的是内存地址；而 equals 默认情况下是内存地址比较，只是很多类重写了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

String x = "string";
String y = "string";
String z = new String("string");
System.out.println(x==y); // true
System.out.println(x==z); // false

String s1 = new String("老王");
String s2 = new String("老王");
System.out.println(s1.equals(s2)); // true

String x = "x";
String y = "y";
//x+y底层是stringbuffer.append("x").append("y").toString()会new一个string对象，存储在堆内存中
//"xy"存储在字符串常量池
System.out.println(x+y=="xy"); // false

final String a = "x";//存储在运行时常量池
String b = a + "y";//编译期间编译优化为"xy"
System.out.println(b =="xy");// true

两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？

不对，两个对象的 hashCode() 相同，equals() 不一定 true。
重地通话，儿女农丰

String str1 = "通话";
String str2 = "重地";
System. out. println("str1. hashCode() : "+str1. hashCode());//1179395
System. out. println("str2. hashCode() : "+str2. hashCode());//1179395
System. out. println(str1. equals(str2));//false

重写equals()就必须重写hashCode() ？

equals()比较的是两个对象内存地址是否相等
hashCode()用来计算对象的散列值，是判断集合中对象是否重复的关键
如果自定义对象中，只重写了equals()，那么就会造成equals()相等，那么hashCode()值不相等
那么当存储在K-V中k时，就会造成两个相同的对象，却存储在集合中不同位置。
所以一般重写equals()就必须重写hashCode()

final 在 Java 中有什么作用？

final 修饰的类叫最终类，该类不能被继承。
final 修饰的方法不能被重写。
final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。可以直接赋值，也可以在构造方法中赋值相对较灵活。
final修饰的参数，在方法中不能被修改。

1、final修饰的类不可以被继承，但可以继承其他的类。
2、final修饰的方法，子类可以继承但是不能重写。
3、子类重写父类的非final方法可以加上final。
4、被final修饰的基本数据类型或者String类型的变量可以看作是常量，赋值后不能改变。
5、被final修饰的引用数据类型变量的引用内存地址值不能改变，可以改变引用数据类型变量的属性值。
6、被final修饰的普通成员变量必须在对象创建完成前进行赋值，可以直接赋值，如果没有直接赋值则需要用构造方法进行赋值，如果有多个构造方法则多个构造方法都要为其赋值，但是不能用set方法赋值。
7、被final修饰的静态成员变量必须要直接赋值或者静态代码块赋值，否则编译不通过。
8、final修饰的成员变量会在编译阶段赋默认值，final固定的是成员变量的手动赋值不是内存中的默认值。

Java 中的 Math. round(-1. 5) 等于多少？

等于 -1，因为在数轴上取值时向右取整，所以正 0.5 是往上取整，负 0.5 是直接舍弃。

long round1 = Math.round(-1.5);//-1
long round2 = Math.round(1.5);//2

String 属于基础的数据类型吗？

String 不属于基础类型，基础类型有 8 种：byte、short、int、long、float、double、char、boolean，而 String 属于对象。

StringBuffer、StringBuilder之间有什么区别？

操作字符串的类有：String、StringBuffer、StringBuilder。

StringBuffer 和 StringBuilder 最大的区别在于，StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的。
但 StringBuilder 的性能却高于 StringBuffer。
所以在单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。

String str="i"与 String str=new String(“i”)一样吗？

不一样，因为内存的分配方式不一样。String str="i"的方式，Java 虚拟机会将其分配到常量池中；
而 String str=new String(“i”) 则会被分到堆内存中。

如何将字符串反转？

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

示例代码：

// StringBuffer reverse
StringBuffer stringBuffer = new StringBuffer();
stringBuffer. append("abcdefg");
System. out. println(stringBuffer. reverse()); // gfedcba
// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder. append("abcdefg");
System. out. println(stringBuilder. reverse()); // gfedcba

String 类的常用方法都有那些？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

抽象类必须要有抽象方法吗？

不需要，抽象类不一定非要有抽象方法，可以只包含普通方法。

示例代码：

abstract class Cat{
    public static void sayHi(){
        System.out.println("hi~");
    }
    //abstract void sayHello();
}

普通类和抽象类有哪些区别？

普通类	抽象类
不能包含抽象方法	可以包含普通方法
可以直接实例化	不能直接实例化，需要先继承，再实例化
可以使用final修饰	不能使用final修饰

抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类，
如下图所示，编辑器也会提示错误信息：
在这里插入图片描述

接口和抽象类有什么区别？

接口	抽象类
接口必须使用 implements 来实现	抽象类的子类使用 extends 来继承
接口不能有构造函数	抽象类可以有构造函数，但是不能直接实例化
类可以实现很多个接口	只能继承一个抽象类
接口中的方法默认使用 public 修饰	抽象类中的普通方法可以是任意访问修饰符
接口自上而下，一般不考虑子类如何实现	抽象类自下而上，将多个相同特征定义成抽象类让子类继承，比如AQS

Java 中 IO 流分为几种？

按功能来分：输入流（input）、输出流（output）。
按类型来分：字节流和字符流。
字节流和字符流的区别是：字节流按 8 位传输以字节为单位输入输出数据（1个字节=8bit），字符流按 16 位传输以字符为单位输入输出数据（1个字符char=2个字节=16bit位）。

BIO、NIO、AIO 有什么区别？

BIO：Block IO 同步阻塞式IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
NIO：Non IO 同步非阻塞IO，是传统 IO 的升级，客户端和服务器端通过Channel（通道）通讯，实现了多路复用Selector。
AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。

Files的常用方法都有哪些？

Files. exists()：检测文件路径是否存在。
Files. createFile()：创建文件。
Files. createDirectory()：创建文件夹。
Files. delete()：删除一个文件或目录。
Files. copy()：复制文件。
Files. move()：移动文件。
Files. size()：查看文件个数。
Files. read()：读取文件。
Files. write()：写入文件。