Java基础知识点整理

1. 面向过程和面向对象

面向过程性能高，面向对象易维护，易复用，易扩展。

2. java 特点

• 面向对象（封装，继承，多态）
• 平台无关性
• 安全可靠
• 支持多线程

3. JVM:Java 虚拟机，是运行 Java 字节码（.class文件）的虚拟机。

   JDK:Java开发工具包

   JRE:Java运行环境

   关系：JDK包含JRE和JAVA的开发工具

   ​ JRE包含JVM和JAVA的核心类库

   

4. JAVA 与C++比较

• 都是面向对象的语言，都支持封装、继承和多态。
• Java 不提供指针来直接访问内存，程序内存更加安全
• Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
• Java 有自动内存管理机制，不需要程序员手动释放无用内存。

5. 重写和重载

重写：子类重新编写父类的方法，方法名相同，参数相同。

重载：方法名相同，参数不同

6. 面向对象的特点：抽象，封装，继承，多态
7. String:不可变的 （可变的含义：指针是否指向新的对象）

​ StringBuilder：可变的，线程不安全，可在单线程中使用

​ StringBuffer： 可变的，线程安全，多线程中使用

8. 自动装箱和拆箱

装箱就是 自动将基本数据类型转换为包装器类型；拆箱就是 自动将包装器类型转换为基本数据类型。

Integer i = 10;  //装箱
int n = i;   //拆箱

9. 接口和抽象类的区别

• 接口的方法默认是 public，所有方法在接口中不能有实现，而抽象类可以有非抽象的方法。
• 一个类可以实现多个接口，但只能实现一个抽象类。
• 抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。
• 接口中基本数据类型为static 而抽类象不是的。

10. 成员变量和局部变量

成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员

变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所

修饰；但是，成员变量和局部变量都能被 fifinal 所修饰。

11. ==与equals()

== : 它的作用是判断两个对象的地址是不是相等。

equals() : 它的作用也是判断两个对象内容是否相等

12. hashcode 和equals

两个obj，如果equals()相等，hashCode()一定相等

两个obj，如果hashCode()相等，equals()不一定相等

HashSet 检查重复 ：先获取hashcode 如果相等，再用equals（) 比较

12. oracle 查询那些表锁

    select * from v$locked_object a, dba_objects b where b.object_id=a.object_id
    

13. 值传递（值调用）和引用传递（引用调用）

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 ，所以一个方法可以修改引用传递所对应的变量值，而不能修改值传递所对应的变量值。

一般认为,java内的传递都是值传递

14. 线程和进程

一个进程可以包含多个线程。

进程是程序执行的基本单位，线程是cpu调度的基本单位。
一般来说，
进程是为了程序的并发执行，线程是为了并发的执行程序！

进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位。

线程的状态：

影响线程的方法：

https://blog.csdn.net/Andya_net/article/details/106206807

package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Mianshi extends  Thread{

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CreateThread createThread = new CreateThread();
        createThread.start();

        NewThread newThread = new NewThread();
        newThread.run();
        Thread thread = new Thread(newThread);
        thread.start();
        
        CreateThreadByOtherWay chy =new CreateThreadByOtherWay();
        chy.CallableThread();

        BasicThreadPool basicThreadPool = new BasicThreadPool();
        basicThreadPool.ThreadPool();

    }


    //继承Thread类
    public static class CreateThread extends Thread{

        @Override
        public void run() {
            System.out.println("通过thread创建了一个线程");
        }
    }

    //实现Runnable接口
    public static class NewThread implements Runnable{
        @Override
        public void run() {
            System.err.println("通过接口Runnable创建线程");
        }
    }

    //通过ExecutorService 和Callable<T>实现有返回值的线程
    public static  class  CreateThreadByOtherWay implements Callable<String> {
        private String num;
        public CreateThreadByOtherWay(String num){
            this.num =num;
        }
        public CreateThreadByOtherWay(){

        }

        @Override
        public String call() throws Exception {
            return num;
        }

        public  void CallableThread () throws ExecutionException, InterruptedException {
            ExecutorService pool = Executors.newFixedThreadPool(5);
            List<Future> list = new ArrayList<>();

            for (int i = 0; i < 10; i++) {
                Callable<String>  chy = new CreateThreadByOtherWay(i+"yyds");
                Future<String> future = pool.submit(chy);
                list.add(future);
            }
            for (Future<String> f:list
            ) {
                System.err.println(f.get());
            }
        }
    }

    //基于线程池创建
    public static class BasicThreadPool {
        public void ThreadPool() {
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 10; i++) {
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " is running !");
                    }
                });
            }
        }
    }
}

15. final

• final 修饰的类无法被继承
• final 修饰的方法无法被重写
• final 修饰的基本类型变量，一旦在初始化之后便不能更改。
• final修饰的实例变量一般添加static修饰 变成静态的

15. 异常处理

• Throwable是所有错误或异常的父类

• 异常和错误的区别：异常能被程序本身处理，错误是无法处理。

• Throwable 类常用方法： getMessage():返回异常发生时的详细信息，toString():返回异常发生时的简要信息getLocalizedMessage()：返回异常对象的本地化信息，printStackTrace() 在控制台上打印Throwable对象封装的异常信息

• 异常处理方式：抛出异常、使用try catch finally捕获并处理异常。finally：无论是否捕获或处理异常，fifinally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，fifinally 语句块将在方法返回之前被执行

• throw和throws的区别：

  位置不同：throws作用在方法上，后面跟着的是异常的类；而throw作用在方法内，后面跟着的是异常的对象

  功能不同: throws用来声明方法在运行过程中可能出现的异常，throw用来抛出封装了异常信息的对象

• 常见面试题：[https://blog.csdn.net/ThinkWon/article/details/104390689](https://blog.csdn.net/ThinkWon/article/details/104390689

16. Java序列化是不想序列的变量添加transient关键字修饰，只能修饰变量，不能修饰方法和类

17. 键盘输入变量的值的两种方式：

方式一：
Scanner input = new Scanner(System.in); 
String s = input.nextLine(); 
input.close();
方式二：
BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine();    

18. Java 中的IO流

    

    Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

    • InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
    • OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

15. 深拷贝和浅拷贝

浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。

深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容。

15. 集合和工具类
    

16. Servlet生命周期

    1.加载web.xml文件。
    2.通过构造函数创建servlet对象。
    3.通过init方法初始化servlet。
    4.通过service，或者doGet、doPost提供服务。
    5.在重启或关闭时自动对servlet进行销毁。

    • 转发：是服务器行为，地址不变,共享相同的request对象和response对象，一次请求效率高，运用为登录转到相应的模块

      request.getRequestDispatcher("success.jsp").forward(request, response);
      

    • 重定向：是客户端行为，地址改变,各自不同的request对象和response对象，至少两次请求效率低，运用为退出登录返回首页

      response.sendRedirect()
      

Servlet不是线程安全的，多线程并发的读写会导致数据不同步的问题。

Jsp对象：request,response,session,application,out,page,pagecontent,config,exception

include指令来包含其他文件（JSP,HTML）
<%@include file=""%>
include行为动作,插入页面
<jsp:include page="sup/printtexes002.jsp" flush="true"/>

JSP三大指令（page,include taglib），七大动作 jsp:include、jsp:useBean、jsp:setProperty、jsp:getProperty、jsp:forward、jsp:plugin

JSP四种作用域：page、request、session、application

Cookie和Session的区别;

Cookie一般用来保存用户信息，将Token放在Cookie中。Session的主要作用就是通过服务端记录用户的状态。

Cookie数据保存在客户端（浏览器），Session数据保存在服务端

17. static关键字

• 修饰成员变量和成员方法 调用方法：类名.静态变量名 类名.静态方法名（）

• 静态代码块

  static { 
      语句体; 
  }
  {
      //非静态语句块
  }
    //执行顺序：静态代码块—非静态代码块—构造方法
    //非静态代码块与构造函数的区别是： 非静态代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化
  

• 静态内部类：

  package common.lang;
  
  public class Student {
  
      public static class Child{
          
      }
      public static void main(String[] args) {
          Student s = new Student();
          Child c = new Child();
      }
  }
  

  （1）它的创建是不需要依赖外围类的创建

  （2）它不能使用任何外围类的非static成员变量和方法。

• 静态导包

  格式为：import static

18. 反射机制

JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个

对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为

java 语言的反射机制。

获取class的几种方式：

method的invode 方法：

19. ArrayList和LinkedList区别

• ArrayList和LinkedList都是线程不安全，Vector线程安全。
• 底层数据结构：ArrayList是数据对象，LinkedList是双向链表
• 插入和删除是否受元素位置的影响。ArrayList受，LinkedList不受
• ArrayList支持快速随机访问，LinkedList不支持

扩容机制：本质就是每次新添加元素的时候都会判断是否能够容下，如果不够就会发生扩容，计算出新的扩容数组的size后实例化，并将原有数组内容复制到新数组中去，默认情况下，新的容量会是原容量的1.5倍。

20. HashMap和HashTable区别

• HashMap是非线程安全的，效率高于线程安全的HashTable,HashTable基本被淘汰，如果保证线程安全的话可以使用ConcurrentHashMap
• HashMap可以支持Null key 和Null value的，HashTable不支持，报NPException
• 初始容量大小和每次扩充容量大小的不同

21. JVM包括一个类加载器子系统（Class Loader SubSystem）、 运行时数据区（Runtime Data Area）、执行引擎和本地接口库（NativeInterface Library）

内存区域：

类加载器的流程：加载、连接（验证、准备、解析），初始化、卸载

双亲委派机制：

垃圾回收（GC）：

如何确定垃圾：Java采用引用计数法和可达性分析来确定对象是否应该被回收

循环引用：两个对象相互引用，其引用计数一直为 1，因而无法被回收。

垃圾回收算法：

垃圾收集器：

分代收集算法中新生代采用复制算法，老年代采用标记清除算法或标记整理算法

Java中的四种引用类型：强引用（永久有效，是造成Java内存泄漏（Memory Link）的主要原因）、软引用（内存溢出时回收）、弱引用（垃圾回收时一定回收）、虚引用（）

JVM调优：

• 调整调整最大堆内存和最小堆内存 -Xmx –Xms

• 调整新生代和老年代的比值 -XX:NewRatio=4

• 调整Survivor区和Eden区的比值-XX:SurvivorRatio=8，两个Survivor:eden=2:8

• 设置年轻代和老年代,永久区的大小

  -XX:NewSize -XX:NewMaxSize
  -XX:PermSize -XX:MaxPermSize
  

• JVM的栈参数调优;可以通过-Xss：调整每个线程栈空间的大小

22. Spring

（1）模块（Spring 4.x)

（2）IOC

概念

1.IOC，Inversion of Control，意为控制反转，控制：对对象的创建和管理。反转：对对象的控制由程序转变为框架。

2.将原本在程序中手动创建对象的控制权，交由Spring框架来管理。由 Spring 来负责控制对象的生命周期和对象间的依赖关系。

3.IoC 容器是 Spring 用来实现IoC 的载体，具有依赖注入（DI）功能的容器，可以创建对象的容器。

4种注入方式：构造器注入、属性（set方法）注入，静态工厂注入、实例工厂注入

Bean作用域和生命周期

声明为Bean的注解：@Controller、@Component、@Service、@Repository,Bean注入@Autowired

4中Bean 作用域（scope）：Singleton(单例模式，始终指向同一个对象，线程不安全)、Prototype（原型模式，调用一次实例化创建一次）、Request（作用域web应用的请求范围）、Session（作用域web应用的会话范围）、Global Session（作用于全局会话）

Bean的生命周期：

大致分为四个阶段：实例化 Instantiation属性赋值 Populate初始化 Initialization销毁 Destruction

（3） AOP，Aspect-Oriented Programming

意为面向切面编程，将那些与业务无关，却为业务模块所共同调用的逻辑代码封装起来，以提高代码的复用率，降低模块之间的耦合度。

一般适用于具有横切逻辑的业务上：性能监测、访问控制、事务管理、日志记录

2种代理方式：

JDK动态代理：只提供接口代理，主要类Proxy和InvocationHandler

CGLib(代码生成类库)动态代理：提供类代理

区别：JDK动态代理性能低于CGLib代理
JDK动态代理创建代理对象时比CGLib代理快
如果对象使用的是singleton模式，则建议使用CGLib

Aspect 和AspectJ的区别：Spring AOP属于运行时增强，而AspectJ是编译时增强

​ Spring AOP 基于代理(Proxying)，而AspectJ 基于字节码操作(Bytecode Manipulation)

​ AspectJ 相比于 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单

（4）Spring MVC

常用注解

@Controller
@RestController
@RequestMapping
@GetMapping @PostMapping @DeleteMapping @PutMapping (4.3版新增)
@RequestBody
@ResponseBody
@RequestParam
@PathVariable
@RequestHeader
@CookieVaule

/*
 * Controller返回的是页面，@Controller + @ResponseBody返回的是JSON、XML或其他文本
 * @RestController = @ResponseBody ＋ @Controller，@RestController表示Controller的所有方法上都加了@ResponseBody，即不会返回页面
 *
 * @RequestMapping可以指定GET、POST请求方式
 * @GetMapping等价于@RequestMapping的GET请求方式
 *
 */

（5）事务

特性：ACID(原子性、一致性、隔离性、持久性)

**事务的并发问题：**脏读、不可重复读、幻读

**隔离级别：**未提交读、已提交读、可重复读、串行化

数据库锁机制：解决事务的并发问题

分类：行共享锁定、行独占锁定、表共享锁定、表共享独占、表独占

Spring事务管理方式：

• 编程式事务，在代码中硬编码。(不推荐使用)

• 声明式事务（基于SpringAOP实现，推荐使用）
  XML式
  注解式(@Transactional)

**Spring 事务传播行为：**7种

Propagation_Required，是最常见的默认选择，表示被修饰的方法必须运行在事务中。

其验证可参考https://blog.csdn.net/xuan_lu/article/details/106006755

分布式事务：一次事务操作涉及多个系统通过网络协同完成的过程称为分布式事务,保证分布式系统中不同节点之间的数据一致性

XA两阶段提交协议：1.准备阶段2.提交阶段