Java知识总结--SE篇

1-1-什么是Java的跨平台原理

Java通过不同的系统，不同的版本不同的位数的Java虚拟机（JVM）来屏蔽不同的指令集，然后对外提供了统一的Java接口（API），这样，我们的开发者只需按照接口开发即可，如果系统需要部署在不同的环境是，只需要系统上面按照片对应版本的虚拟机即可

想要了解更多Java架构技术的，可以关注我一下，我后续也会整理更多关于架构技术这一块的知识点分享出来，里面会分享一些：spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化，并发编程这些成为架构师必备的知识点。获取方式：关注后私信博主！！！

1.2-JDK 和 JRE 有什么区别？

JDK：java 开发工具包，提供了 java 的开发环境和运行环境。

JRE：java 运行环境，为 java 的运行提供了所需环境。

1.3-Java基本数据类型

1.4-Java基本类型所占字节和范围

1.5-int(long) 和 float(double) 哪个表示的范围大？为什么？

float表示的 范围更大。float 和 int 都是4个字节，而 float 还要表示小数，为什么 float 表示的数字范围大？

int 底层使用的是补码的方式表示一个数：1 位符号位 + 31 位二进制数

float 底层使用的是IEEE 754 浮点单精度数字格式，简单来说就是用指数的形式去表示一个数：1 位符号位 + 8 位指数 + 23位尾数

1.6-Int和Integer的区别，在使用时有什么区别？

Integer是int的包装类，int则是java的一种基本数据类型

Integer变量必须实例化后才能使用，而int变量不需要

Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值

Integer的默认值是null，int的默认值是0

1.7-有了基本的数据类型，为什么还需要包装类型

因为Java是一个面向对象的语言，而基本的数据类型，不具备面向对象的特性

1.8-装箱和拆箱，自动拆箱，自动装箱

装箱：把基本的数据类型转换成对应的包装类型

拆箱：把包装类型转换成对应的基本数据类型

自动装箱：实际上编译时会调用integer.valueOf方法来装箱 Integer i=1；

自动拆箱：实际上编译时会调用intValue方法来拆箱 Int j=i.intValue();

1.9-重写，重载

重载：方法名字相同，而参数不同。返回类型可以相同也可以不同

重写：子类定义的方法与父类中的方法具有相同的方法名字，相同的参数表和相同的返回类型

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

声明为 static 的方法不能被重写，但是能够被再次声明。

子类如果不是抽象类，则必须重写父类中的abstract方法。

如果不能继承一个方法，则不能重写这个方法。

1.10-==和equals方法的区别

==对于基本类型是比较的是值是否相同，对于引用类型比较的是地址是否相同。equals默认情况下是引用的比较，只是很多类重写了 equals的方法，比如spring，integer等把它变成了值比较，所以一般情况下equals比较的是值是否相等

1.11- final 在 java 中有什么作用？

final 修饰的类叫最终类，该类不能被继承。

final 修饰的方法不能被重写。

final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

1.12-面向对象的特征有哪些方面

多态，继承，封装， （抽象）

抽象：把一个对象，抽象为类

封装：隐藏类的内部信息，外部类不可以直接访问，可以通过get/set去获取或值改变这个类

继承：通过extends继承父类的基本特征和行为，子类也可以改变这些基本特征和行为

多态：也就是同一个操作作用在不同对象上面的时候可以产生不同的效果

1.13-接口和抽象类（接口的抽象级别最高）

相同点：

不能被实例化。

不同点：

抽象类要被子类继承extends，接口要被类实现implements 。

抽象类可以有构造函数；接口不能有。

接口支持多继承，抽象类只允许单继承。

接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现。

接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量。

抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方法。

1.14-抽象类不是必须要有抽象方法

不需要，抽象类不一定非要有抽象方法。

public abstract class Person{

public static void say() {

System.out.println("HELLO");

}

}

1.15-普通类和抽象类的区别

普通类不能包含抽象方法，抽象类可以包含抽象方法。

抽象类不能直接实例化，普通类可以直接实例化。

1.16-抽象类不能使用 final 修饰

定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类

1.17-String底层实现，不可变的原因

String的底层是使用char数组的，char数组和String类都是被final修饰的，所以不可以改变

1.18-String 不属于基础的数据类型

String 不属于基础类型，String 属于对象。

1.19-String str="str"与 String str=new String("str")的内存分配

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

1.20- String 类的常用方法

length()字符串的长度

charAt() 截取一个字符

equals()和equalsIgnoreCase() 比较两个字符串

compareTo()和compareToIgnoreCase() 比较字符串

concat() 连接两个字符串

replace() 替换

toUpperCase() /toLowerCase() 转换为大小写

trim() 去掉起始和结尾的空格

String test="abcdefg";

String test2=" ABCDEFG ";

System.out.println("字符串长度=" + test.length());

System.out.println("截取一个字符 = " + test.charAt(2));

int compareTo = test.compareTo(test2);

System.out.println("compareTo = " + compareTo);

int compareToIgnoreCase = test.compareToIgnoreCase(test2);

System.out.println("compareToIgnoreCase = " + compareToIgnoreCase);

boolean b = test.equals(test2);

System.out.println("b = " + b);

boolean b1 = test.equalsIgnoreCase(test2);

System.out.println("b1 = " + b1);

String str=test.concat(test2).concat("test");

System.out.println("str = " + str);

str=str.replace("test","idea");

System.out.println("str = " + str);

str=str.toLowerCase();

System.out.println("str = " + str);

str=str.toUpperCase();

System.out.println("str = " + str);

int test2Length=test2.length();

test2=test2.trim();

System.out.println("test2Length2 = " + test2Length);

int test2Length1=test2.length();

System.out.println("test2Length1 = " + test2Length1);

//字符串长度=7

//截取一个字符 = c

//compareTo = 65

//compareToIgnoreCase = 65

//b = false

//b1 = false

//str = abcdefg ABCDEFG test

//str = abcdefg ABCDEFG idea

//str = abcdefg abcdefg idea

//str = ABCDEFG ABCDEFG IDEA

//test2Length2 = 14

//test2Length1 = 7

1.21-String，StringBuilder，StringBuffer的区别？

String是只读字符，值不可以改变的

StringBuffer的值是可以改变的，线程安全

StringBuilder的值是可以改变的，线程不安全

1.22-什么是值传递和引用传递？

值传递是对基本类型变量而言的,传递的是该变量的一个副本,改变副本不影响原来变量.

引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。

一般认为,java内的基础类型数据传递都是值传递. java中实例对象的传递是引用传递

1.23-SimpleDateFormat的作用和用法

SimpleDateFormat的作用是用于设置时间格式的

把日期转换为指定格式的字符串

SimpleDateFormat sdformat = new SimpleDateFormat("yyy y-MM-dd HH:mm:ss");

String text = sdformat .format(new Date());

 

//text = 2020 2020-06-14 16:00:54

把字符串转换为指定格式日期

public static void main(String []args) throws ParseException {

String text = "2020年1月1日 1:11:11";

SimpleDateFormat sdformat= new SimpleDateFormat("yyyy年M月dd日 H:mm:ss");

Date date= sdformat.parse(text);

System.out.println("date = " + date);

}

//date = Wed Jan 01 01:11:11 CST 2020

1.24- java 中 IO 流分类

按功能来分：输入流（input）、输出流（output）。

按类型来分：字节流和字符流。

 

1.25-Java的流

1.26- Files的常用方法

Files.exists()：检测文件路径是否存在。

Files.createFile()：创建文件。

Files.createDirectory()：创建文件夹。

Files.delete()：删除一个文件或目录。

Files.copy()：复制文件。

Files.move()：移动文件。

Files.size()：查看文件个数。

Files.read()：读取文件。

Files.write()：写入文件。

 

1.27-如何创建文件和目录？

File file = new File("D:", "one");

//创建文件夹

file .mkdir();

//创建文件

file .createNewFile();

//删除文件

file .delete();

1.28-面向对象编程的六大原则

1、开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、单一职责原则（Single responsibility principle）

单一职责原则是指：一个类应该只有一个发生变化的原因，即一个类只负责一项职责。

如果一个类有多个职责，这些职责就耦合在了一起。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起会影响复用性。

此原则的核心是解耦和增强内聚性。

1.29-设计模式

​​​​​单例模式（饱汉模式，饥汉模式）

1）构造方法私有化，让除了自己类能创建外其他地方都不可以创建

2）在自己的类中创建一个单实例（饱汉模式一出来就创建单实例，饥汉模式需要的时候才 创建）

3）提供一个方法获取该实例对象（饥汉模式创建时需要进行方法同步）

工程模式：spring的IOC就是使用工程模式

对象的创建交给一个工厂创建

代理模式：Spring的AOP就是使用的动态代理

包装模式

1.30- 运行时异常与一般异常的区别

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

1.31-&和&&的区别

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）

 

1.32-final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时 的其他资源回收，例如关闭文件等。

1.33-error和exception的区别。

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

1.34-Math.round(9.5)等多少? Math.round(-9.5)等多少?

Math.round(9.5) =10

Math.round(-9.5) =-9

数轴上取值时，中间值（0.5）向右取整，所以正 9.5 是往上取整，负 9.5 是直接舍弃。