JAVA相关

JAVA语言概述

1. 一个".java"源文件中是否可以包含多个类？有什么限制？

可以。
一个源文件可以声明多个类，但是最多只能有一个类使用public进行声明
且要求声明public的类的类名与源文件相同。

2. Java的优势？

• 跨平台性
• 安全性高
• 简单性
• 高性能
• 面向对象性
• 健壮性
• 社区繁荣

3. Java中是否存在内存溢出、内存泄漏？如何解决？

存在。
（内存溢出、内存泄漏：程序在执行过程中，已经不再使用的内存空间， JVM通过相关算法判定以后不认为是垃圾，于是构成内存泄漏）

4. 如何看待Java是一门半编译半解释型语言？

java源码经过编译器生成字节码(.class)，字节码可以通过解释器（解释执行） | JIT编译器（编译执行）得到机器码

变量与运算符

1. 如何高效的计算2*8的值？

使用<<（左移）

2. &和&&区别？

都是表示且的关系，&左边是false时仍然执行，&&左边是false不再执行

3. Java中的基本数据类型有哪些？String时最基本的数据类型吗？

8种基本数据类型：byte，short，int，long，char，boolen，float，double
String不是，属于引用类型

4. Java开发中计算金额是是用什么数据类型？

不能使用double，float，因为精度不高
使用BigDecimal类替换，可以实现任意精度的运算

5. char变量中能不能存储一个中文汉字？

可以，应为char使用Unicode字符集，包含了世界范围的所有字符集。
char='中'

6. 代码分析

short s1=1;
s1=s1+1;	//有什么错？（右边是int类型，需要强制转换）

short s1=1;
s1+=1;	//有什么错？（没错）

7. int i=0; i++; 执行这两句话后，i的值为？

0

8. 如何将两个变量值互换

String s1 = "abc"
String s2 = "def"String temp = s1;
s1 = s2;
s2 = temp;

9. boolean占几个字节？

编译的时候不谈占几个字节。
但是JVM再给boolean类型分配内存空间是，boolean类型的变量占据一个slot（4B）。

拓展：在内存中，byte\short\char\int\boolean\float：占用1个slot
______________________________double\long：占用2个slot

10. 为什么Java中0.1+0.2≠0.3?

不是每个小数都有对应的二进制数字，可以采用四舍五入或同乘同除方法进行验证，避免上述问题。

流程控制语句

1. break和continue的作用

2. if分支语句和switch分支语句的异同之处？

• if-else语句优势

if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。

switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。

• switch语句优势

当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。

使用switch可以利用穿透性，同时执行多个分支，而if…else没有穿透性。

3. switch语句中忘写break会发生什么？

case穿透

4. Java至此和那些类型循环？

while，do-while，for，foreach

5. while和do-while循环的区别？

do-while至少会执行一次

IDEA安装与使用

1. 开发中你接触过的开发工具有哪些？

IDEA，Eclipse

2. 谈谈你对Eclipse和IDEA使用上的感受？

IDEA是一种智能化开发工具，Eclipse不够人性化

数组

1. 数组有没有length()这个方法？String有没有length()这个方法？

数组没有length()方法，是length属性
String有length()方法

2. 有数组int[] arr，用Java代码将数组元素顺序颠倒

for(int i=0;i<arr.length/2;i++){int temp=arr[i]arr[i]=arr[arr.length-i-1];arr[arr.length-i-1]=temp;
}

3. 为什么数组要从0开始编号，而不是1？

数组索引，表示了数组元素距离首地址的偏移量。因为第一个元素与首地址元素相同，所以偏移量为0。

4. 数组有什么排序？手写

冒泡排序，快速排序，二分算法

/*
1、冒泡排序（最经典）
思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），就交换它们，经过多轮比较，最终实现排序。（例如：从小到大）     每一轮可以把最大的沉底，或最小的冒顶。过程：arr{6,9,2,9,1}  目标：从小到大
第一轮：第1次，arr[0]与arr[1]，6>9不成立，满足目标要求，不交换第2次，arr[1]与arr[2]，9>2成立，不满足目标要求，交换arr[1]与arr[2] {6,2,9,9,1}第3次，arr[2]与arr[3]，9>9不成立，满足目标要求，不交换第4次，arr[3]与arr[4]，9>1成立，不满足目标要求，交换arr[3]与arr[4] {6,2,9,1,9}第一轮所有元素{6,9,2,9,1}已经都参与了比较，结束。第一轮的结果：第“一”最大值9沉底（本次是后面的9沉底），即到{6,2,9,1,9}元素的最右边
第二轮：第1次，arr[0]与arr[1]，6>2成立，不满足目标要求，交换arr[0]与arr[1] {2,6,9,1,9}第2次，arr[1]与arr[2]，6>9不成立，满足目标要求，不交换第3次：arr[2]与arr[3]，9>1成立，不满足目标要求，交换arr[2]与arr[3] {2,6,1,9,9}第二轮未排序的所有元素 {6,2,9,1}已经都参与了比较，结束。第二轮的结果：第“二”最大值9沉底（本次是前面的9沉底），即到{2,6,1,9}元素的最右边
第三轮：第1次，arr[0]与arr[1]，2>6不成立，满足目标要求，不交换第2次，arr[1]与arr[2]，6>1成立，不满足目标要求，交换arr[1]与arr[2] {2,1,6,9,9}第三轮未排序的所有元素{2,6,1}已经都参与了比较，结束。第三轮的结果：第三最大值6沉底，即到 {2,1,6}元素的最右边
第四轮：第1次，arr[0]与arr[1]，2>1成立，不满足目标要求，交换arr[0]与arr[1] {1,2,6,9,9}第四轮未排序的所有元素{2,1}已经都参与了比较，结束。第四轮的结果：第四最大值2沉底，即到{1,2}元素的最右边
*/
public class Test19BubbleSort{public static void main(String[] args){int[] arr = {6,9,2,9,1};//目标：从小到大//冒泡排序的轮数 = 元素的总个数 - 1//轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套//外循环控制 轮数，内循环控制每一轮的比较次数和过程for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮for(int j=0; j<arr.length-i; j++){//希望的是arr[j] < arr[j+1]if(arr[j] > arr[j+1]){//交换arr[j]与arr[j+1]int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}//完成排序，遍历结果for(int i=0; i<arr.length; i++){System.out.print(arr[i]+"  ");}}
}

面向对象（基础）

1. 代码输出

		int[] arr = new int[]{1,2,3};System.out.println(arr);char[] arr1 = new char[]{'a','b','c'};System.out.println(arr1);boolean[] arr2 = new boolean[]{true,false,false};System.out.println(arr2);

int：地址
char：abc
boolean：地址

2. 代码问题

编写method(a,b)，输出a=100，b=200

    public static void main(String[] args) {int a = 10;int b = 10;method(a,b);System.out.println("a="+a);System.out.println("b="+b);}

解答：

    public static void main(String[] args) {int a = 10;int b = 10;method(a,b);System.out.println("a="+a);System.out.println("b="+b);}public static void method(int a,int b){a=a*10;b=b*20;System.out.println("a="+a);System.out.println("b="+b);System.exit(0);//强制退出}

• 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参

• 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

3. 面向对象，面向过程理解？

1. 面向过程的程序设计思想（Process-Oriented Programming），简称POP

• 关注的焦点是过程：过程就是操作数据的步骤。如果某个过程的实现代码重复出现，那么就可以把这个过程抽取为一个函数。这样就可以大大简化冗余代码，便于维护。

• 典型的语言：C语言

• 代码结构：以函数为组织单位。

• 是一种“执行者思维”，适合解决简单问题。扩展能力差、后期维护难度较大。

2. 面向对象的程序设计思想（ Object Oriented Programming），简称OOP

• 关注的焦点是类：在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，用类来表示。

• 典型的语言：Java、C#、C++、Python、Ruby和PHP等

• 代码结构：以类为组织单位。每种事物都具备自己的属性和行为/功能。

• 是一种“设计者思维”，适合解决复杂问题。代码扩展性强、可维护性高。

4. Java引用类型有几种？

类，数组，接口，枚举，记录，注解

5. 类和对象的区别？

类是抽象的
对象是具体的，是类的实例

6. 对象存在Java内存的哪块区域里？

堆空间

7. private、缺省、protected、public的作用区域？

8. main方法的public能不能换成private，为什么？

能。当修改以后就不能作为程序入口，就只是一个普通的方法。

9. 构造方法和普通方法有什么区别？

编写代码角度：声明格式，作用均不同
字节码文件角度：构造器会以<init>()方法的形态呈现，用以初始化对象

10. 构造器Constructor是否可以被overload？

可以

11. 无参构造器和有参构造器的作用和应用？

初始化属性

12. 成员变量和局部变量区别？

1、声明位置和方式

（1）实例变量：在类中方法外

（2）局部变量：在方法体{}中或方法的形参列表、代码块中

2、在内存中存储的位置不同

（1）实例变量：堆

（2）局部变量：栈

3、生命周期
（1）实例变量：和对象的生命周期一样，随着对象的创建而存在，随着对象被GC回收而消亡，而且每一个对象的实例变量是独立的。

（2）局部变量：和方法调用的生命周期一样，每一次方法被调用而在存在，随着方法执行的结束而消亡，而且每一次方法调用都是独立。

4、作用域

（1）实例变量：通过对象就可以使用，本类中直接调用，其他类中“对象.实例变量”

（2）局部变量：出了作用域就不能使用

5、修饰符（后面来讲）

（1）实例变量：public,protected,private,final,volatile,transient等

（2）局部变量：final

6、默认值

（1）实例变量：有默认值

（2）局部变量：没有，必须手动初始化。其中的形参比较特殊，靠实参给它初始化。

13. 变量赋值和构造方法加载的优先级问题？

变量显式赋值先于构造器赋值（字节码文件）

面向对象（进阶）

1. 区分方法重载和重写？

重载：方法名相同，形参列表不同。不看返回值类型。
重写：不同类中，继承以后，子类覆盖父类中方法

2. 区分 == 和 equals()

• == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址

• equals只能用在引用数据类型上，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==；我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。

• 具体要看自定义类里有没有重写Object的equals方法来判断。

• 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

3. 父类哪些成员可以被继承？属性可以被继承吗？

父类属性、方法、属性可以被继承。
构造器可以被子类调用

4. overload是否可以改变返回值类型？

不可以。返回值不是重载需要改变的。

5. 构造器可以被overrid？

不可以。构造器可以被重载。

6. 为什么要重载，随便命名一个别的函数不行吗？

见名知意

7. super和this的区别？

• this关键字引用的是当前对象。它用于引用当前对象的实例变量和方法。使用this关键字可以让我们避免在代码中重复使用相同的变量名。
• super关键字用于引用父类的成员（实例变量或方法）。它通常用于子类中，当子类需要访问父类的成员时。使用super可以明确地引用父类的成员，避免二义性。

8. 多态的理解？

广义理解：子类对象的多态性、方法的重写、方法的重载
格式：Object obj = new String("hello");父类的引用指向子类对象
多态好处：减少了大量的重载方法定义

9. 多态new出来的对象和不多态new出来的对象有什么区别？

Person p = new Man();虚对象方法，屏蔽了子类Man类特有的属性和方法
Person p = new Person();

10. 重写equals方法注意什么？

明确判定两个对象实体equals()标准。是否需要所有属性参与。
对象的属性且为自定义类型，此属性也需要重写equals()

11. Java中所有的父类是什么？都有什么方法？

Object类
equals(),toString(),clone(),finalize(),getClass(),hashCode()

面向对象（高级）

1. 静态变量和实例变量区别？

• 个数

静态变量：在内存空间中只有一份，被类的多个对象共享
实例变量：类的每一个实例（或对象）都保存着一份实例变量

• 内存位置

静态变量：jdk6之前存放在方法区，之后存放在堆空间
实例变量：存放在堆空间的对象实体中

• 加载时机

静态变量：随着类的加载而加载，由于类只会加载一次，所以静态变量也只有一份
实例变量：随着对象创建而加载，每个对象拥有一份实例变量

• 调用者

静态变量：可以被类直接调用，也可以使用对象调用
实例变量：只能使用对象进行调用

• 判断是否可以调用——>从生命周期的角度

• 消亡时机

静态变量：随着类的卸载而消亡
实例变量：随着对象的消亡而消亡

2. 开发中，什么时候需要将属性声明为静态的方法？

判断当前类的多个实例是否能共享此成员变量，且此成员变量的值是相同的；开发中常将一些常量声明是静态的

方法内操作的变量都是静态变量而非实例变量，则此方法将声明为静态方法；
常常将工具类声明为静态方法

3. 为什么抽象类不可以使用final关键字声明？

因为抽象类不能实例化，只能被继承，但final的类规定不能被继承

详情

4. 一个抽象类中可以定义构造器吗？

可以，因为当子类继承父类时，需要调用父类的构造器。

5.是否可以这样理解：抽象类就是比普通类多定义了抽象方法，除了不能直接进行类的实例化操作之外，没有任何不同？

抽象类里不一定有抽象方法，但抽象方法所属的类一定是抽象类。

详情

6. 静态属性和静态方法是否可以被继承？是否可以被重写？

静态方法不能被重写，可以被重载，不存在多态性。

7. 是否可以从一个static方法内部发出对非static方法的调用？

只能通过对象来对非静态方法的调用。

8. 被static修饰的成员（类、方法、成员变量）能否再使用private进行修饰？

可以。除了代码块

9. 知道哪些设计模式？

单例模式、模板方法、享元设计模式

10. main()方法的public能不能换成private？

可以改，但是改完以后就不是程序入口。

11. 静态代码块、普通代码块、构造方法，从类加载开始的执行顺序？

静态代码块—>普通代码块—>构造器

12. 判断：使用final修饰一个变量时，引用不能改变，引用指向的对象可以改变

√
引用不能变，引用指向的对象实体中的属性若果没有使用final修饰则可以改变。

13. final不能修饰构造器？

是

14. final或static final修饰成员变量能不能进行+1操作？

不能

15. 什么是抽象类？如何识别一个抽象类？

使用abstract修饰。

16. 为什么不能用abstract修饰属性、私有方法、构造器、静态方法、final方法？

语言的自洽。

17. 接口和抽象类的区别？

18. 接口是否可以继承接口？抽象类是否可以继承接口？抽象类是否可以继承实现类？

是，是，是

19. 接口可以有自己的属性吗？

可以，必须为public，static，final

20. 访问接口的默认方法如何使用？

使用实现类的对象进行调用，而且实现还可以重写此默认方法。

21. 内部类有哪几种？

22. 枚举可以继承吗？

使用enum定义的，其父类就是enum类，就不要继承其他类了。

23. 面向对象的理解？

• 面向对象两个要素：类，对象
• 面向对象三大特征
• 接口（类可以实现多个接口）

异常处理

1. Java的异常处理机制

• try-catch-finally
• throws

2. 异常两种类型，Error和Exception区别？

Error: 在Java中，Error 是指那些表示系统级、不可恢复的错误的异常。这些错误通常是由Java虚拟机(JVM)在运行时抛出的，而不是由程序代码直接抛出的。常见的 Error 类型包括 OutOfMemoryError、StackOverflowError 和 ThreadDeath。

Exception: 与 Error 不同，Exception 是指那些程序代码可以抛出的异常，也是开发人员需要关注和处理的异常。Exception 可以进一步分为几种不同的类型，如 RuntimeException 和 CheckedException。

Error 和 Exception 的主要区别在于它们的用途和行为。Error 表示系统级的、不可恢复的错误，通常由JVM在运行时抛出，不需要开发人员显式处理；而 Exception 表示程序代码可以抛出的异常，通常由程序逻辑错误或I/O操作失败导致，需要开发人员显式处理。

3. 运行时异常和一般异常有何异同？

RuntimeException：

• 编译可以通过，运行时可能抛出，出现的概率高，一般针对于运行时异常都不做处理。

Exception

• 编译不能通过，必须在编译之前考虑异常的处理，不处理编译不能通过。

4. 如果不使用try-catch，程序出现异常会如何？

如果不使用则在出现异常对象后会抛出此对象，如果没有处理方案，就会终止程序的执行。

5. try-catch捕捉的是什么异常？

Exception，非Error

多线程

1. string a=“abc” string b=“a”+“bc”，a==b？

是

2. String中 + 怎样实现？

常量+常量
常量+变量StringBuilder，通过append()添加字符串，最后调用toString()返回一个字符串
变量+变量StringBuilder，通过append()添加字符串，最后调用toString()返回一个字符串

3. Java中String是不是final？

是

4. String是否可变？在内存中具体形态？

不可变，在内存中提供字符串常量池。

5. String可以在switch中使用吗？

可以，jdk7开始

6. String中有哪些方法？

charAt(int index): 返回指定索引位置的字符。
length(): 返回字符串的长度。
substring(int beginIndex, int endIndex): 返回从beginIndex到endIndex(不含endIndex)之间的子字符串。
indexOf(String substring): 返回子字符串第一次出现的索引，如果未找到则返回-1。
lastIndexOf(String substring): 返回子字符串最后一次出现的索引，如果未找到则返回-1。
equals(Object anObject): 比较两个字符串的内容是否相同。
equalsIgnoreCase(String anotherString): 忽略大小写比较两个字符串的内容是否相同。
startsWith(String prefix): 测试字符串是否以指定的前缀开始。
endsWith(String suffix): 测试字符串是否以指定的后缀结束。
replace(char oldChar, char newChar): 替换字符串中的所有指定字符。
toUpperCase(): 将所有字符转换为大写。
toLowerCase(): 将所有字符转换为小写。
trim(): 移除字符串首尾的空白字符。
substring(int beginIndex): 返回从beginIndex开始到字符串结束的子字符串。
concat(String str): 将指定字符串连接到此字符串的末尾。
indexOf(int ch): 返回指定字符在此字符串中第一次出现的位置的索引。
lastIndexOf(int ch): 返回指定字符在此字符串中最后一次出现的位置的索引。
intern(): 返回字符串对象的规范表示；具体内容由Java虚拟机实现。
format(String format, Object... args): 根据给定的格式进行格式化。
valueOf(Object obj): 返回表示给定对象的字符串。
静态的 String valueOf(char c): 返回表示给定字符的字符串。
valueOf(boolean b)、valueOf(char c)、valueOf(int i)、valueOf(long l)、valueOf(float f)、valueOf(double d): 返回表示给定的原始数据类型的字符串。
equalsIgnoreCase(): 比较两个字符串，无视大小写。
equals(Object obj): 比较两个对象是否相等，使用equals方法。
compareTo(Object o): 与指定的对象进行比较，并返回一个整数值，该值反映了这个字符串在比较中是大于、等于还是小于指定的对象。
compareToIgnoreCase(String str): 与指定的字符串进行比较，并返回一个整数值，该值反映了这个字符串在比较中是大于、等于还是小于指定的字符串，无视大小写。
matches(String regex): 测试这个字符串是否匹配指定的正则表达式。
replaceFirst(String regex, String replacement): 用指定的替换字符串替换正则表达式匹配的第一个子字符串。
replaceAll(String regex, String replacement): 用指定的替换字符串替换正则表达式匹配的所有子字符串。

7. Java中操作字符串有哪些类？他们之间有什么区别？

在Java中，主要有三个类用于操作字符串：String，StringBuilder和StringBuffer。

1. String：这是Java的内置类，用于创建和管理字符串。它是一个不可变类，这意味着一旦创建了一个字符串对象，就不能更改它。如果尝试更改字符串，例如通过添加或删除字符，实际上会创建一个新的字符串对象。这种不可变性使得String对象在多线程环境下可以安全地使用，但这也意味着在大量操作字符串时可能会产生大量的中间字符串，导致内存和性能问题。
2. StringBuilder：这是一个可变类，可以用于创建和管理可修改的字符串。与String不同，StringBuilder允许修改字符串，例如添加、删除或替换字符。StringBuilder是线程不安全的，因此在多线程环境下使用时需要额外的同步措施。由于它的可变性，它在需要大量修改字符串的情况下比String更高效。
3. StringBuffer：这也是一个可变类，可以用于创建和管理可修改的字符串。与StringBuilder类似，StringBuffer也允许修改字符串。但与StringBuilder不同的是，StringBuffer是线程安全的，可以在多线程环境下无同步地使用。这意味着在需要大量修改字符串且可能存在多线程竞争的情况下，StringBuffer可能比StringBuilder更安全和高效。

总的来说，选择哪个类取决于你的需求：

• 如果你需要一个不可变的字符串，可以使用String。
• 如果你需要一个可变但线程不安全的字符串，可以使用StringBuilder。
• 如果你需要一个可变且线程安全的字符串，可以使用StringBuffer。

8. Comparable接口和Comparator接口比较？

排序方式：

使用Comparable接口：对象实现Comparable接口后，可以通过Arrays.sort()或Collections.sort()方法直接进行排序。
使用Comparator接口：需要先创建一个实现了Comparator接口的类，然后将其作为参数传递给Arrays.sort()或Collections.sort()方法进行排序。

Comparable接口主要用于定义对象的自然顺序，使得代码更加清晰和直观；而Comparator接口则主要用于实现灵活的排序规则，可以在运行时动态地改变比较规则。