java面试（java基础）

1.什么是java?

Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。

2.面向对象的三大特征

封装：面向对象的三大特质之一，是对象和类概念的只要特征进行封装，就是把客观事务封装成为抽象的类，把可以自己的数据或者方法进行封装，让可信的类或者对象进行操作，对不可信的进行隐藏；
继承：子类对象继承父类的所有功能，同时可以对基础的方法进行重写，基础的对象叫做子类（派生类），被基础的对象叫做父类（基类），同时一个子类可以继承多个父类。
多态：允许将子类类型的指针赋值给父类类型的指针。
实现多态，有二种方式，覆盖，重载。
覆盖：是指子类重新定义父类的虚函数的做法。
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

3.接口和抽象类的异同点

相同：
都不能创建对象
都可以定义抽象方法，并且一定要在子类中重写
不同：
关键字不同abstract interface
抽象方法中既可以有抽象的方法也可以有普通的方法
接口中中所有的方法都是抽象方法
抽象类的方法可以任意权限，接口中方法只能是public
抽象类只能单继承，接口可以多实现

4.重载(overload)和重写(overwrite)区别

重写：	
子类和父类,子类重写了父类的方法
方法名、参数列表必须和父类完全一致
返回值类型要么相同，要么子类方法的返回值类型是父类方法返回值类型的子类！
重载的规则(两同一不同)
同一个类中、方法名相同、参数列表不同（个数，列表，类型）、和返回值无关

5.StringBuffer、StringBuilder、String区别

String字符串常量不可变使用字符串拼接时会开辟新空间
StringBuffer字符串变量可变线程安全字符串拼接直接在字符串后追加
StringBuilder字符串变量可变非线程安全字符串拼接直接在字符串后追加

1.StringBuilder 执行效率高 StringBuffer，高于String.
2.String是一个常量，是不可变的，所以对于每一次+=赋值都会创建一个新的对象，StringBuffer和StringBuilder都是可变的，当进行字符串拼接时采用append方法，在原来的基础上进行追加，所以性能比String要高，
StringBuffer是线程安全的而StringBuilder是线程非安全的，所以StringBuilder的效率高于StringBuffer.
3.对于大数据量的字符串的拼接，采用StringBuffer,StringBuilder.

6.冒泡排序

//算法
int array={12,13,15,42,2,8,17,23,6,15};
int temp =0 ;
for(int i =0;i<=array.length-1;i++){
	for(int j=0;j<array.length-i-1;j++){
		if array[j] >array[j+1]{
			temp = array[j];
			array[j] = array[j+1]
			array[j+1] = temp
	}
}
//排序后输出
for(int i ：array{
	System.out.print(i+"\t");
}

7.选择排序

int a={12,13,15,42,2,8,17,23,6,15};
int max = 0;
int tem = 0;
for (int i=0;i<a.length;i++){
	max = i;
	for(int j=0;i<a.length;j++){
		if(a[max]<a[j]){
		max = j;
		}
		if(i ！= max){
			tem = a[i];
			a[i]= a[max];
			a[max] =tem
		}
	}
	for (int i=0;i<a.length;i++){
		System.out.print(a[i]+"\t");
	}
}

8.单例设计模式

单例就是该类只能返回一个实例。
单例所具备的特点：

1.私有化的构造函数
2.私有的静态的全局变量
3.公有的静态的方法

懒汉式

package com.ruoyi.test;

public class Singleton {
    //私有的静态的全局变量
    private static Singleton uniqueInstance = null;
    //私有的构造函数
    private Singleton(){

    }
    //公有的静态方法
    public static Singleton getInstance(){
        if (uniqueInstance!=null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }

}

线程安全懒汉式

package com.ruoyi.test;

public class Singleton {
    //私有的静态的全局变量
    private static Singleton uniqueInstance = null;
    //私有的构造函数
    private Singleton(){

    }
    //公有的静态方法
    public synchronized static Singleton getInstance(){
    if (uniqueInstance!=null){
        uniqueInstance = new Singleton();
    }
    return uniqueInstance;
}


}

饿汉式

package com.ruoyi.test;

public class Singlenton {
    private final static Singlenton uniqueInstance = new Singlenton();
    
    private Singlenton(){
    }
    public static Singlenton getInstance(){
        return  uniqueInstance;
    }
}

9.常见的异常类型

NullPointerException空指针异常
ClassCastException类型强制转换异常
IllegalArgumentException传递非法参数异常
ArithmeticException算数运算异常
IndexOutOfBoundsException下标越界异常
NumberFormatException数字格式异常
ClassNotFindException加载请求异常

10.Throws和Throw的区别

位置：Throw方法内部，Throws方法名之后
作用：Throw抛出异常，Throws声明异常
个数：Throw一次抛出一个异常，Throws可以声明多个异常

package com.ruoyi.test;

import org.bouncycastle.eac.EACException;

public class ThrowDemo {
    public boolean getErrOR() throws Exception, EACException {
        int a =0;
        int b =1;
        try {
            if (a == b){

            }
        }catch (Exception e){
            throw new Exception(e.getMessage());
        }
        return true;
    }

}

11.Final，Finally，finalize关键字的作用

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
修饰类：（最终类）不能被子类继承
修饰方法：（最终方法）不能被子类重写
修饰变量：（常量）一旦声明之后，不能再次修改其中的值
finally是异常处理语句结构的一部分，表示总是执行。不管是否有异常总是被执行，除非虚拟机停止才不执行。System.exit(1);
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法可以实现资源回收，释放资源，例如关闭文件等。JVM不保证此方法总被调用.

12.JDK和JRE的区别

JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
JRE：Java Runti me Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。
JDK包含了JRE，同时包含了编译java源码的编译器javac,还包含了java程序调试和分析的工具。
如果你需要运行 Java 程序，只需安装 JRE 就可以了，如果你需要编写 Java 程序，需要安装 JDK。

13. == 和 equals的区别

“== ”
基本类型：比较的是值是否 相同；
引用类型：比较的是引用是否相同；
String x = “string”;
String y = “string”;
String z = new String(“string”);
System.out.println(x == y);
System.out.println(x == z); // false
System.out.println(x.equals(y)); // true
System.out.println(x.equals(z)); // true

代码解读：因为 x 和 y 指向的是同一个引用，所以 == 也是 true，而 new String()方法则重写开辟了内存空间，所以 == 结果为 false，而 equals 比较的一直是值，所以结果都为 true。
equals 解读:
equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。看下面的代码就明白了。

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

14.java的数据类型

八种数据类型
字节型： char
布尔型：boolean
数字类型：
整数型：int short long byte
浮点类型: float double

15.如何将字符串反转？

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