java八股笔记-1-java基础

java 特点：

1.平台无关性，java 的字节码文件可以在任何安装了 JVM 的系统上运行

2.面相对象，几乎一切都可以抽象为对象，包括类，对象，继承，封装，多态，抽象

抽象：抽象属性，抽象行为

实现抽象的方式有，抽象类，需要靠其子类实现方法；接口

3.内存管理，java 有自己的垃圾回收机制，自动管理内存和不再使用的对象

java 为什么是跨平台的

主要依赖于 JVM

JVM是一个”桥梁“，是一个”中间件“，是实现跨平台的关键，Java代码首先被编译成字节码文件，再由JVM将字节码文件翻译成机器语言，从而达到运行Java程序的目的

不同的平台对于同一个字节码文件翻译出来的机器语言是不同的，同样的 java 代码在不同的平台下的编译结果都是相同的

JDK ,JRE,JVM 的关系：

JRE 是能够运行机器语言所需的最小环境；JDK 是开发，编译，调试，运行 java 程序所需的全部工具和环境

编译性和解释性

编译型语言，在执行程序前编译源代码为字节码文件，执行字节码文件速度快，但是跨平台性较差

解释型语言，在执行的过程中，逐行解释执行源代码，由解释器动态解释并执行代码，跨平台性好，但是执行速度较差

典型的编译型语言如C、C++，典型的解释型语言如Python、JavaScript

 Java既是编译型也是解释型语言，默认采用的是解释器和编译器混合的模式

JVM 是什么

JVM 是 java 虚拟机，主要作用是将字节码翻译为机器语言让程序运行。通过 JVM 这个 “桥梁” 我们可以实现多 “一次编译，多平台运行” 的效果

Java 和 python 的区别

java 在运行时会生成已编译的字节码文件，而 Python 是解释型语言，在翻译的同时执行程序

数据类型

八种基本数据类型：

整数 4 个：long（64）、 int（32）、 short（16）、 byte（8）

byte：一个字节，-128 ~ 127 ，即 -2^7 ~ -2^7-1

浮点数 2 个：double（64）、 float（32） 

布尔 1 个：boolean（8）

字符一个：char（16）

 引用数据类型：

String

数组

类

接口

八种基本数据类型的包装类：除了char的是Character、int类型的是Integer，其他都是首字母大写

char类型是无符号的，不能为负，所以是0开始的

类型转换

int 向 long 转不会丢失数据，但是 long 向 int 转可能会溢出，同理的还有 float 与 double

当目标类型的范围大于源类型时的转换，叫做隐式转换（自动类型转换）；反之叫做显示转换（强制类型转换）

基本类型的引用类含有基本类型与字符串的转换方法 toString、parse...()

double 和 BigDecimal 的区别

只能够表示能够用1/(2^n)的和的任意组合，有一些小数无法以这些组合得到，如 0.1 

而 BigDecimal 在进行计算时，可以指定结果的小数位数，避免了由于浮点数精度问题导致的误差

BigDecimal 的加减乘除操作都作用在对象上，故每一次计算前，需要先创建对应小数的对象：

BigDecimal num1 = new BigDecimal("小数");

装箱和拆箱是什么？ 

装箱（Boxing）和拆箱（Unboxing）是将基本数据类型和对应的包装类之间进行转换的过程。

int -> Integer 装箱

Integer -> int 拆箱

JDK5 之后，编译器就有了自动装箱拆箱的功能

自动装箱的弊端：

Integer 类型的数据并不能进行“运算”操作，故每次都需要自动拆箱。

故在大量的运算操作时，我们通常先手动拆箱，用基本类型进行完全部运算，再装箱，可以优化性能

Java为什么要有Integer？

1.可以将属性和方法封装在 Integer 中，方便对 int 类型的数据操作，如 Integer.parseInt()

2.java 集合的泛型和集合可以装的元素只能为引用数据类型

integer的缓存

Java的Integer类内部实现了一个静态缓存池，用于存储特定范围内的整数值对应的Integer对象。 默认情况下，这个范围是-128至127。当通过Integer.valueOf(int)方法创建一个在这个范围内的整数对象时，并不会每次都生成新的对象实例，而是复用缓存中的现有对象，会直接从内存中取出，不需要新建一个对象。

面向对象是什么？

将现实世界中的事物抽象为对象，对象具有属性和行为。面向对象编程就是是通过对象之间的交互完成程序的功能。面向对象有继承，封装，多态的特性。

说说封装继承和多态

封装：封装是将对象的属性和行为放在一块，隐藏对象内部细节，对外只能调用方法来操作对象。这样做能够提高代码的安全性和简易性。还可以增加对象的独立性

继承：子类可以共享父类的属性结构和方法，提高代码的复用性 

多态：子类可以替换父类，指允许不同的类对同一消息做出响应（即同一个接口，使用不同的类执行不同的操作）

多态体现在哪几个方面？ 

1.方法重载：同一个方法名传参不同

2.方法重写：继承实现方法重写

3.实现接口

4.子类和父类之间的转型：

向上转型，用父类型的引用指向子类对象（如直接将子类赋值给父类，可以调用子类重写后的父类方法，但不能调用父类没有的方法）

向下转型，将父类强转为子类，注意可能会有 ClassCastException 异常

多态解决了什么问题?

多态提高了代码的扩展性和复用性，也是很多设计模式，设计原则，编程技巧的基础。比如基于接口的编程，依赖倒置原则，利用多态去除冗余的 if-else。

面向对象的设计原则有哪些？

单一职责原则

开放封闭原则：开放 -> 对扩展开放（即继承）；封闭 -> 对修改封闭

里氏替换原则：子类能够替换掉所有父类对象

接口隔离原则：接口应该要小而专

依赖倒置原则：高层模块不应该依赖于低层模块，二者都应该依赖于抽象；抽象不应该依赖于细节，细节应该依赖于抽象。例如：公司和部门

重载和重写的区别

重载，方法名相同，形参不同

重写，在继承是重写方法

抽象类

包含抽象方法和普通方法以及属性

抽象类可以包含抽象方法，也可以包含普通方法。抽象方法没有具体的实现，只有方法签名，抽象方法也使用 abstract 关键字修饰

不能实例化

不能被直接创建对象

作为基类

抽象类可以继承抽象类，最终需要一个非抽象类来实现抽象类的所有抽象方法

故抽象类通常作为基类，供具体的子类继承或和扩展

final 关键字的作用

1.修饰变量

基本类型：基本类型变量初始化后值不能再被改变

引用类型：引用类型变量指定对象后，该变量不能指向其他对象，但是这个对象本身的内容可以改变

2.修饰方法

final 修饰该方法后，子类不能重写该方法

3.修饰类

final 修饰的类不能被继承

接口能够定义哪些方法？

1.抽象方法

接口的所有方法默认为 public abstract 修饰，被省略

2.普通方法，可以加静态

在 JDK8 以后，java 接口运行写出普通方法，写出其具体实现，并且其实现类也可以重写普通方法

可以给普通方法加上 static 关键字，使得该方法可以直接使用接口名.方法名调用

3.私有方法

在 JDK9 以后，java 允许私有方法在接口中声明

 static 关键字的作用

1.修饰变量

静态变量，随着类的加载初始化，只赋值一次

静态变量是属于整个类的变量，而不是属于某一个对象的

2.修饰方法

静态方法是属于整个类的方法

静态方法中不能直接调用非静态成员，因为静态方法无需创建对象也可以调用，但是非静态成员依赖于具体的对象

3.静态代码块

静态代码块中的代码在类加载时执行，只执行一次

内部类的作用

1.成员内部类

成员内部类，可以调用外部类的所有成员，包括私有成员

2.局部内部类

定义在外部类的方法中，只能在方法中被调用

3.匿名内部类

通常用于创建接口的实现类，在 new 一个接口时后面跟上一个没有类名的类，重写所有接口方法

如：

interface MyInterface {
    void doSomething();
}

class OuterClass {
    void outerMethod() {
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Anonymous inner class implementing interface.");
            }
        };
        myInterface.doSomething();
    }
}

接口后面的大括号及其括号内的整体，就是一个匿名内部类 

4.静态内部类

属于整个类的内部类，能够直接通过类名.类名的形式访问以及创建对象

不能调用外部类的非静态成员

有一个父类和子类，都有静态的成员变量、静态构造方法和静态方法，在我new一个子类对象的时候，加载顺序是怎么样的？

父类的静态成员变量和静态代码块

子类的静态成员变量和静态代码块

父类的构造方法

子类的构造方法

深拷贝和浅拷贝

浅拷贝，两个对象的值都指向同一个对象

深拷贝，将一个对象的所有数据都拷贝到另一个新的对象中

对象的深拷贝：

MyClass obj1 = new MyClass();
MyClass obj2 = (MyClass) obj1.clone();

什么是泛型？

允许在类，接口，方法定义时使用类型参数，使得这些代码可以适用于不同的数据类型，提高了代码的可重用性和类型安全性

new 出的对象什么时候回收？

java 的垃圾回收器会周期性检测不再被引用的对象，并将其回收释放内存

什么是反射？

动态获取信息以及动态调用对象的方法

常用到的反射：

1.加载数据库驱动

2.加载配置文件

java 异常处理有哪些？

处理方式1：try catch 捕获异常后处理

处理方式2：直接在方法中声明抛出异常类型

try{return “a”} fianlly{return “b”}这条语句返回啥?

fianlly 中的 return 会覆盖 try 中的 return ，故返回 "b"

== 与 equals() 有什么区别？

对于字符串，== 比较两个字符串的地址，equals() 比较两个字符串的内容

对于非字符串，默认都是比较两个元素的地址，若对 equals() 方法进行重写后可以改变比较内容

StringBuffer 和 StringBuilder 的区别？

String 对象一旦创建就无法改变了，只能创建新的对象覆盖原来的对象，若需要对 String 进行大量的修改操作，可以使用 StringBuffer 和 StringBuilder 来提高性能

StringBuffer 是线程安全的，StringBuild 去掉了线程安全的部分以减少开销

java 中的 Stream 流

Stream 流是 1.8 的新特性，实现对集合的复杂操作

Stream 流的操作流程：

创建 Stream 对象：通常通过 .stream() 的方法创建

中间操作

终止操作

常用中间方法：

filter(条件表达式) 过滤流中的元素，只保留满足 true 的元素

map() 将每个元素映射为另一个元素，变成一个新的流

//将字符串集合变成每个字符串长度的集合
StringList.stream().map(String::length).collect(Collectors.toList());

sorted()  默认自然排序，也可以用 Comparator 修改排序规则

distinct() 去除流中的重复元素

limit(long) 截取流中的前几个元素，得到新的流

skip(long) 跳过流的前几个元素，得到新的流

常用终止方法：

forEach(Consumer) 让每一个元素都执行指定的操作

list.stream().forEach(System.out::println);//控制条输出每一个元素

 collect(Collector) 将流中的元素都手机到一个集合中

reduce(BinaryOperator) 对流中的元素进行归约操作，得到最终结果

list.stream().reduce(0,Integer::sum);//得到所有元素的累加值

count() 返回流中元素个数

anyMatch(条件表达式) 判断流中是否存在任意一个满足条件的元素，返回 true 或 false 

 java 中的 "::" 是什么，有什么用？

"::" 是方法引用的操作符

1.类名::静态方法名

Integer::sum：用于计算两个整数的和。

Math::max：返回两个数中的较大值。

Math::min：返回两个数中的较小值。

Arrays::sort：对数组进行排序。

2.对象::方法名

只要能够通过 对象.方法名() 调用的方法都可以使用

3.类名::对应实例方法名

String::toUpperCase可以将任意字符串转换为大写形式。

String::toLowerCase可以将任意字符串转换为小写形式。

String::trim可以去除任意字符串两端的空白字符。

String::substring可以从任意字符串中提取子字符串。

序列化和反序列化是什么？

java 中，常见的序列化有将对象转换为 json 格式的字符串，反序列化将 json 字符串重新封装为对象

java 中有自动序列化和反序列化功能，自动序列化有 无法跨语言，容易被攻击等缺点

可以使用 FastJson 等框架来代替 java 的序列化

单例模式是什么？

是一种设计模式，确保一个类只有一个实例，通常以 static 关键字修饰

代理模式是什么？

当你需要操作一个对象却无法直接访问，或者需要在访问这个对象的前后做一些额外的操作是，使用代理模式代理该对象

适配器模式是什么？

适配器模式可以作为两个不兼容的接口的桥梁，使得不兼容的两个接口可以协同工作

怎么让集合多条件排序？

改写 Collection.sort() 的排序方法，可以使用 lombda 表达式或者在方法外定义一个 Comparable 指定排序规则