java基础知识

文档地址：https://github.com/name365/Blog-Java?tab=readme-ov-file

// 1部分 Java基础程序设计1章 Java概述及开发环境搭建2
2章 简单的Java程序11
3章 Java基础程序设计16
4章 数组与方法60// 2部分 Java面向对象程序设计5章 面向对象（基础篇）88
6章 面向对象（高级篇）170
7章 异常的捕获及处理235
8章 包及访问控制权限252// 3部分 Java应用程序设计9章 多线程266 // 这章跳过不看
10章 泛型307
11章 Java常用类库336 // 第二遍再看
12章 Java IO397 // 这章跳过不看
13章 Java类集491
14章 枚举559
15章 Java反射机制577 // 第二遍再看
16章 Annotion609 // 第二遍再看
17章 Java数据库编程630 // 第二遍再看
18章 图形界面693 // 这章跳过不看
19章 Java网络编程785 // 这章跳过不看
20章 Java新IO801 // 这章跳过不看

基本知识列表

• 数据类型（基本数据类型、引用数据类型）
• 流程控制（if、switch、while）
• 方法（定义、重载、递归）
• 数组
• 类（高内聚低耦合）、接口（契约）、面对对象（继承、封装、多态）
• 异常
  • 抛出异常
  • 捕获异常
  • 异常处理五个关键字：
    • try、catch、 finally、throw、throws

package org.example;import java.util.Scanner;
import java.util.Arrays;public class HelloWorld {public static void main(String[] args) {System.out.println("Hello World!");int a = 2;int[] list = new int[10];int[] myList = {1,2,3,4,6,5};list[0]=1;Arrays.sort(myList);System.out.println(Arrays.toString(myList));int added = add(1, 3);System.out.println(added);}public static int add(int a, int b){return a+b;}}

面对对象

• 面向过程思想
  • 步骤清晰简单，第一步做什么，第二步做什么…
  • 面对过程适合处理一些较为简单的问题。
• 面向对象思想
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
    • 三大特征：
      • 继承
      • 封装
      • 多态
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

堆与栈的关系

值修改与引用修改

方法可以修改传递引用所对应的变量值（指针），而不能修改传递值调用所对应的变量值（值）

当传递方法参数类型为基本数据类型（数字以及布尔值）时，一个方法是不可能修改一个基本数据类型的参数

package github.method;public class HomeWork01 {private static int x = 10;public static void updataeValue(int value){value = 3 * value;System.out.println("value的值:" + value);}public static void main(String[] args) {System.out.println("调用前的值:" + x); //10updataeValue(x);//30,这个方法结束后，参数变量value不再使用，被回收。System.out.println("调用后的值:" + x);//10}}

值传递：

引用传递：

异常：错误+异常

SSM

SSM框架是Spring MVC ，Spring和Mybatis框架的整合，是标准的MVC模式，将整个系统划分为View层，Controller层，Service层，DAO层四层。

• 使用Spring MVC负责请求的转发和视图管理
• Spring实现业务对象管理
• Mybatis作为数据对象的持久化引擎

springMVC

Servlet

参考文档：https://blog.csdn.net/qq_42647903/article/details/109648599

我们如何能通过Web服务器映射的URL访问资源？
- 接收请求
- 处理请求
- 响应请求* 把接收和响应两个步骤抽取成: Web服务器，
* 但处理请求的逻辑是不同的，抽取出来做成 Servlet，交给程序员自己编写。1. Servlet是啥？
servlet接口定义的是一套处理网络请求的规范，实现
* 你初始化时要做什么? init()
* 你销毀时要做什么?destroy()
* 你接受到请求时要做什么?————service()
抽象类 HttpServlet 继承Genericservlet，实现service的get、post方法区分; HttpServlet无法知晓子类想干嘛，所以写成抽象类，要求实现doGet()、doPost()两个方法，当子类重写该方法，整个业务代码就活了2. 那请求怎么来到servlet呢？答案是servlet容器。
比如我们最常用的tomcat,必须把servlet部署到一个容器中，不然servlet不会起作用。3. tomcat才是与客户端直接打交道的家伙，Tomcat = web服务器 + Servlet容器
* Tomcat监听了端口
* 请求过来后，根据url等信息，确定要将请求交给哪个servlet去处理
* 调用那个servlet的service方法，service方法返回一个response对象
* tomcat再把这个response返回给客户端。总的来说，Tomcat已经替我们完成了所有底层抽象操作，并且传入三个对象 ServletConfig、 ServletRequest、 ServletResponse
1.2 Request：
HTTP请求到了Tomcat后，Tomcat通过字符串解析，把各个请求头（ Header),请求地址（URL),请求参数（ Query String）都封装进了Request对象中。1.3 Response：
Servlet逻辑处理后得到结果，最终通过 response. write()方法，将结果写入 response内部的缓冲区。 Tomcat会在 servlet处理结束后，拿到response，遍历里面的信息，组装成HTTP响应发给客户端。

使用Servlet API时，并不直接与底层TCP交互，也不需要解析HTTP协议，因为HttpServletRequest和HttpServletResponse就已经封装好了请求和响应

SpringMVC：基于 Servlet的 Spring Web 框架，

MVC 是 Model、View 和 Controller 的缩写，分别代表 Web 应用程序中的 3 种职责。

• (Model)模型：用于存储数据以及处理用户请求的业务逻辑。(类，包括业务和数据)
• (View)视图：向控制器提交数据，显示模型中的数据。（页面）
• (Controller)控制器：根据视图提出的请求判断将请求和数据交给哪个模型处理，将处理后的有关结果交给哪个视图更新显示。

spring

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

控制反转 IoC(Inversion of Control)

在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

• 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
• 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
• 依赖注入 : 就是利用set方法来进行注入的.
• IOC是一种编程思想，由主动的编程变成被动的接收

// 接口
public interface UserDao {public void getUser();
}//接口实现A
public class UserDaoImpl implements UserDao {@Overridepublic void getUser() {System.out.println("获取用户数据");}
}//service接口
public interface UserService {public void getUser();
}// 困境：每增加一个 UserDaoImpl，UserServiceImpl代码就需要修改（强耦合）
public class UserServiceImpl implements UserService {private UserDao userDao = new UserDaoImpl();//private UserDao userDao = new UserDaoMySqlImpl();//private UserDao userDao = new UserDaoOracleImpl();@Overridepublic void getUser() {userDao.getUser();}
}// 利用第三方set 去注入实际的实现类，这样就实现了解耦
public class UserServiceImpl implements UserService {private UserDao userDao;// 利用set实现，依赖注入public void setUserDao(UserDao userDao) {this.userDao = userDao;}@Overridepublic void getUser() {userDao.getUser();}
}

面向切面 Aop

OOP：Object Oriented Programming，OOP作为面向对象编程的模式，封装、继承和多态。

AOP：Aspect Oriented Programming，意为：面向切面编程。

对于日志，安全，缓存，事务等代码，它们会重复出现在每个业务方法中。使用OOP，我们很难将这些四处分散的代码模块化

BookService关心的是自身的核心逻辑，但整个系统还要求关注日志，安全，缓存，事务等功能，这些功能实际上“横跨”多个业务方法，为了实现这些功能，不得不在每个业务方法上重复编写代码

使用AOP，实际上就是让Spring自动为我们创建一个Proxy，使得调用方能无感知地调用指定方法，但运行期却动态“织入”了其他逻辑，因此，AOP本质上就是一个代理模式。

• 横切关注点：跨越应用程序多个模块的方法或功能，与我们业务逻辑无关的，但是需要关注的部
  分，就是横切关注点，如日志，安全，缓存，事务

在Java平台上，对于AOP的织入，有3种方式：

1. 编译期：在编译时，由编译器把切面调用编译进字节码，这种方式需要定义新的关键字并扩展编译器，AspectJ就扩展了Java编译器，使用关键字aspect来实现织入；
2. 类加载器：在目标类被装载到JVM时，通过一个特殊的类加载器，对目标类的字节码重新“增强”；
3. 运行期：目标对象和切面都是普通Java类，通过JVM的动态代理功能或者第三方库实现运行期动态织入。

最简单的方式是第三种，Spring的AOP实现就是基于JVM的动态代理。由于JVM的动态代理要求必须实现接口，如果一个普通类没有业务接口，就需要通过CGLIB或者Javassist这些第三方库实现。

使用AOP非常简单，一共需要三步：

1. 定义执行方法，并在方法上通过AspectJ的注解告诉Spring应该在何处调用此方法；
2. 标记@Component和@Aspect；
3. 在@Configuration类上标注@EnableAspectJAutoProxy。

@Aspect
@Component
public class LoggingAspect {// 在执行UserService的每个方法前执行:@Before("execution(public * com.itranswarp.learnjava.service.UserService.*(..))")public void doAccessCheck() {System.err.println("[Before] do access check...");}// 在执行MailService的每个方法前后执行:@Around("execution(public * com.itranswarp.learnjava.service.MailService.*(..))")public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {System.err.println("[Around] start " + pjp.getSignature());Object retVal = pjp.proceed();System.err.println("[Around] done " + pjp.getSignature());return retVal;}
}

拦截器有以下类型：

• @Before：这种拦截器先执行拦截代码，再执行目标代码。如果拦截器抛异常，那么目标代码就不执行了；
• @After：这种拦截器先执行目标代码，再执行拦截器代码。无论目标代码是否抛异常，拦截器代码都会执行；
• @AfterReturning：和@After不同的是，只有当目标代码正常返回时，才执行拦截器代码；
• @AfterThrowing：和@After不同的是，只有当目标代码抛出了异常时，才执行拦截器代码；
• @Around：能完全控制目标代码是否执行，并可以在执行前后、抛异常后执行任意拦截代码，可以说是包含了上面所有功能。

Mybatis

参考文档：https://www.cnblogs.com/diffx/p/10611082.html

JDBC

Java为关系数据库定义了一套标准的访问接口：JDBC（Java Database Connectivity）

使用Java程序访问数据库时，Java代码并不是直接通过TCP连接去访问数据库，而是通过JDBC接口来访问，而JDBC接口则通过JDBC驱动来实现真正对数据库的访问。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;public class JDBCTest {public static void main(String[] args) throws Exception {Connection connection = null;PreparedStatement prepareStatement = null;ResultSet rs = null;try {// 加载驱动Class.forName("com.mysql.jdbc.Driver");// 获取连接String url = "jdbc:mysql://127.0.0.1:3306/ssmdemo";String user = "root";String password = "123456";connection = DriverManager.getConnection(url, user, password);// 获取statement，preparedStatementString sql = "select * from tb_user where id=?";prepareStatement = connection.prepareStatement(sql);// 设置参数prepareStatement.setLong(1, 1l);// 执行查询rs = prepareStatement.executeQuery();// 处理结果集while (rs.next()) {System.out.println(rs.getString("userName"));System.out.println(rs.getString("name"));System.out.println(rs.getInt("age"));System.out.println(rs.getDate("birthday"));}} finally {// 关闭连接，释放资源if (rs != null) {rs.close();}if (prepareStatement != null) {prepareStatement.close();}if (connection != null) {connection.close();}}}
}

Mybatis

整体架构

• 配置mybatis-config.xml 全局的配置文件 (1、数据源，2、外部的mapper)
• 创建SqlSessionFactory
• 通过SqlSessionFactory创建SqlSession对象
• 通过SqlSession操作数据库 CRUD
• 调用session.commit()提交事务
• 调用session.close()关闭会话

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;import java.io.InputStream;public class MybatisTest {public static void main(String[] args) throws Exception {// 指定全局配置文件String resource = "mybatis-config.xml";// 读取配置文件InputStream inputStream = Resources.getResourceAsStream(resource);// 构建sqlSessionFactorySqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);// 获取sqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();try {// 操作CRUD，第一个参数：指定statement，规则：命名空间+“.”+statementId// 第二个参数：指定传入sql的参数：这里是用户idUser user = sqlSession.selectOne("MyMapper.selectUser", 1);System.out.println(user);} finally {sqlSession.close();}}
}

SpringBoot

依赖关系：spring5 -> spring boot > spring cloud

• Spring 最初利用“工厂模式”(DI)和“代理模式”(AOP)解耦应用组件。
• 大家觉得挺好用，于是按照这种模式搞了一个 MVC 框架,用于开发 web 应用(SpringMVC)。
• 然后有发现每次开发都要搞很多依赖，写很多样板代码很麻烦，于是搞了一些懒人整合包,这套就是 Spring Boot

Spring Boot是一个基于 Spring 的框架，旨在简化 Spring 应用的配置和开发过程，通过自动配置和约定大于配置的原则，使开发者能够快速搭建独立、生产级别的应用程序。

Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用

快速创建项目

参考文档：

• 教程
• springBoo教程

运行原理

Maven项目，我们一般从pom.xml文件探究起；

启动器 spring-boot-starter

• 依赖

  <dependency>        								<groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId>
  </dependency>
  

• springboot-boot-starter-xxx，说白了就是Springboot的启动场景

• 比如spring-boot-starter-web，他就会帮我们自动导入web的所有依赖

• springboot会将所有的功能场景，都变成一个个的启动器

• 我们要使用什么功能，就只需要找到对应的启动器就好了start

主程序

默认的主启动类

//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {public static void main(String[] args) {//该方法返回一个ConfigurableApplicationContext对象//参数一：应用入口的类； 参数二：命令行参数 SpringApplication.run(SpringbootApplication.class, args);}
}

自动加载配置

• SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

• 进入这个注解：可以看到上面还有很多其他注解！

  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan(excludeFilters = {@Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}
  ), @Filter(type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class}
  )}
  )
  public @interface SpringBootApplication {// ......
  }
  

1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
3. 以前我们需要自动配置的东西，现在springboot帮我们做了
4. 整合JavaEE，整体解决方案和自动配置的东西都在springboot-autoconfigure的jar包中；
5. 它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器中
6. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并自动配置，@Configuration（javaConfig） ；
7. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

run 方法流程实例

配置文件

配置文件的作用 ：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；

• yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！

package nuc.ss.pojo;@Component  //注册bean到容器中
public class Dog {private String name;private Integer age;//有参无参构造、get、set方法、toString()方法  
}@Component //注册bean
public class Dog {@Value("阿黄")private String name;@Value("18")private Integer age;
}@SpringBootTest
class Springboot02ConfigApplicationTests {@Autowiredprivate Dog dog;@Testvoid contextLoads() {System.out.println(dog);}}