java基础学习笔记

置顶 已于 2024-09-03 16:07:56 修改
阅读量140 收藏
点赞数 3
文章标签： java
于 2024-06-08 20:12:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2945090920/article/details/139550655
版权

1.语法篇

循环

正则表达式

数据类型

泛型

数据类型

String

indexof

静态概念

静态代码块

以下代码是使用静态代码块初始化map集合

package com.ztesoft.crmpub.bpm.task.action;

import com.ztesoft.crmpub.bpm.consts.MsgConsts;
import java.util.HashMap;
import java.util.Map;

/**
 * 任务工单动作工厂类
 *
 * <p>该工厂类用于根据消息动作类型创建对应的工单动作实例。</p>
 *
 * @author major
 */
public class youhua {

    // 定义动作与工单动作的映射
    private static final Map<String, IWorkOrderAction> actionMap = new HashMap<>();

    // 静态代码块用于初始化动作映射
    static {
        actionMap.put(MsgConsts.ACTION_WO_NEW, new WorkOrderNewAction());
        actionMap.put(MsgConsts.ACTION_WO_DISPATCH, new WorkOrderDispatchAction());
        actionMap.put(MsgConsts.ACTION_WO_FINISH, new WorkOrderFinishAction());
        actionMap.put(MsgConsts.ACTION_WO_FAIL, new WorkOrderFailAction());
        actionMap.put(MsgConsts.ACTION_WO_WITHDRAW, new WorkOrderWithdrawAction());
        actionMap.put(MsgConsts.ACTION_WO_PULL_BACK, new WorkOrderPullBackAction());
    }

    /**
     * 获取工单动作实例
     *
     * @param msgAction 消息动作类型
     * @return 对应的工单动作实例
     * @throws IllegalArgumentException 如果消息动作类型无效
     */
    public static IWorkOrderAction getWorkOrderAction(String msgAction) {
        IWorkOrderAction workOrderAction = actionMap.get(msgAction);
        if (workOrderAction == null) {
            throw new IllegalArgumentException("Invalid msgAction: " + msgAction);
        }
        return workOrderAction;
    }
}

2.api

3.集合

Map要通过entryset或者keyset或者values获取map的条目流

3.IO流

4.并发编程

反射

关键词


5.面向对象

接口和接口直接用extend继承

2.注意事项

3.语法技巧

静态导入

在 Java 中，你可以通过静态导入（static import）来直接使用另一个类中的静态方法，而无需实例化那个类。这可以使代码更加简洁和易读，特别是在频繁使用某些静态方法时。

设计模式

 单例模式

如何使用

在Java Spring Boot中，单例模式的一个经典应用场景是配置管理类。假设我们需要管理应用的配置信息，并确保这些配置在应用中只有一个实例可用。以下是一个使用单例模式的简单示例：

私有构造方法使得只能有一个实例

package com.example.demo.config;

import org.springframework.stereotype.Component;

@Component
public class AppConfig {

    // 模拟配置属性
    private String appName = "MySpringBootApp";
    private String version = "1.0.0";

    // 私有构造方法，防止外部实例化
    private AppConfig() {}

    public String getAppName() {
        return appName;
    }

    public void setAppName(String appName) {
        this.appName = appName;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }
}

在这个例子中，AppConfig 是一个单例类，它的构造方法是私有的，这样可以防止外部直接实例化它。我们使用 @Component 注解将这个类标记为 Spring 管理的 bean。

在Spring Boot中使用单例模式

Spring Boot 默认会将所有用 @Component、@Service、@Repository 等注解的类注册为单例（除非特别指定为原型模式）。因此，当我们在其他类中注入 AppConfig 时，Spring 会确保每次注入的都是同一个实例。

例如，创建一个控制器类来使用 AppConfig：

package com.example.demo.controller;

import com.example.demo.config.AppConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigController {

    @Autowired
    private AppConfig appConfig;

    @GetMapping("/config")
    public String getConfig() {
        return "App Name: " + appConfig.getAppName() + ", Version: " + appConfig.getVersion();
    }
}

在这个 ConfigController 类中，我们通过 @Autowired 注入了 AppConfig，并在 /config 端点返回配置值。Spring 会自动确保 AppConfig 是单例的，因此所有访问此端点的请求将共享相同的 AppConfig 实例。

模板模式

很多依赖库的设计中经常会用到模板模式 如JdbcTemplate

 

 

 

 

 

 

策略模式
 

 

支付处理中  会有多种不同的支付方式（策略）
 

 

 

工厂模式
 

 

 

1. 简单工厂模式（Simple Factory Pattern）
 

场景：在一个 Web 应用中，我们可能需要根据用户的请求来处理不同类型的消息（如文本消息、图片消息）。我们可以创建一个简单工厂来生成不同的消息处理器。
 

 

// 消息接口
public interface MessageHandler {
    void handleMessage(String message);
}

// 具体消息处理类
@Service("textMessageHandler")
public class TextMessageHandler implements MessageHandler {
    @Override
    public void handleMessage(String message) {
        System.out.println("Handling text message: " + message);
    }
}

@Service("imageMessageHandler")
public class ImageMessageHandler implements MessageHandler {
    @Override
    public void handleMessage(String message) {
        System.out.println("Handling image message: " + message);
    }
}

// 简单工厂类
@Component
public class MessageHandlerFactory {

    @Autowired
    private ApplicationContext applicationContext;

    public MessageHandler getHandler(String type) {
        return (MessageHandler) applicationContext.getBean(type + "MessageHandler");
    }
}

// 控制器类
@RestController
@RequestMapping("/messages")
public class MessageController {

    @Autowired
    private MessageHandlerFactory handlerFactory;

    @PostMapping
    public ResponseEntity<String> processMessage(@RequestParam String type, @RequestParam String message) {
        MessageHandler handler = handlerFactory.getHandler(type);
        handler.handleMessage(message);
        return ResponseEntity.ok("Message processed");
    }
}

 

2. 工厂方法模式（Factory Method Pattern）
 

场景：在一个 Web 应用中，我们可能需要创建不同类型的服务（如用户服务和订单服务），每种服务有不同的实现。我们可以使用工厂方法模式来创建这些服务。
 

// 服务接口
public interface Service {
    void execute();
}

// 具体服务类
@Service
public class UserService implements Service {
    @Override
    public void execute() {
        System.out.println("Executing User Service");
    }
}

@Service
public class OrderService implements Service {
    @Override
    public void execute() {
        System.out.println("Executing Order Service");
    }
}

// 工厂接口
public interface ServiceFactory {
    Service createService();
}

// 具体工厂类
@Component
public class UserServiceFactory implements ServiceFactory {
    @Autowired
    private ApplicationContext applicationContext;

    @Override
    public Service createService() {
        return applicationContext.getBean(UserService.class);
    }
}

@Component
public class OrderServiceFactory implements ServiceFactory {
    @Autowired
    private ApplicationContext applicationContext;

    @Override
    public Service createService() {
        return applicationContext.getBean(OrderService.class);
    }
}

// 控制器类
@RestController
@RequestMapping("/services")
public class ServiceController {

    @Autowired
    private ServiceFactory userServiceFactory;

    @Autowired
    private ServiceFactory orderServiceFactory;

    @GetMapping("/user")
    public ResponseEntity<String> executeUserService() {
        Service service = userServiceFactory.createService();
        service.execute();
        return ResponseEntity.ok("User Service executed");
    }

    @GetMapping("/order")
    public ResponseEntity<String> executeOrderService() {
        Service service = orderServiceFactory.createService();
        service.execute();
        return ResponseEntity.ok("Order Service executed");
    }
}

 

3. 抽象工厂模式（Abstract Factory Pattern）
 

场景：在一个 Web 应用中，我们可能需要创建不同风格的用户界面组件（如现代风格和经典风格的按钮和文本框）。我们可以使用抽象工厂模式来创建这些组件。
 

// 组件接口
public interface Button {
    void render();
}

public interface TextBox {
    void render();
}

// 具体组件类
@Service("modernButton")
public class ModernButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering Modern Button");
    }
}

@Service("classicButton")
public class ClassicButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering Classic Button");
    }
}

@Service("modernTextBox")
public class ModernTextBox implements TextBox {
    @Override
    public void render() {
        System.out.println("Rendering Modern TextBox");
    }
}

@Service("classicTextBox")
public class ClassicTextBox implements TextBox {
    @Override
    public void render() {
        System.out.println("Rendering Classic TextBox");
    }
}

// 抽象工厂接口
public interface UIComponentFactory {
    Button createButton();
    TextBox createTextBox();
}

// 具体工厂类
@Component
public class ModernUIFactory implements UIComponentFactory {
    @Autowired
    private ApplicationContext applicationContext;

    @Override
    public Button createButton() {
        return applicationContext.getBean("modernButton", Button.class);
    }

    @Override
    public TextBox createTextBox() {
        return applicationContext.getBean("modernTextBox", TextBox.class);
    }
}

@Component
public class ClassicUIFactory implements UIComponentFactory {
    @Autowired
    private ApplicationContext applicationContext;

    @Override
    public Button createButton() {
        return applicationContext.getBean("classicButton", Button.class);
    }

    @Override
    public TextBox createTextBox() {
        return applicationContext.getBean("classicTextBox", TextBox.class);
    }
}

// 控制器类
@RestController
@RequestMapping("/ui")
public class UIController {

    @Autowired
    private UIComponentFactory modernUIFactory;

    @Autowired
    private UIComponentFactory classicUIFactory;

    @GetMapping("/modern")
    public ResponseEntity<String> renderModernUI() {
        Button button = modernUIFactory.createButton();
        TextBox textBox = modernUIFactory.createTextBox();
        button.render();
        textBox.render();
        return ResponseEntity.ok("Modern UI rendered");
    }

    @GetMapping("/classic")
    public ResponseEntity<String> renderClassicUI() {
        Button button = classicUIFactory.createButton();
        TextBox textBox = classicUIFactory.createTextBox();
        button.render();
        textBox.render();
        return ResponseEntity.ok("Classic UI rendered");
    }
}

 

4.总结
 

  • 简单工厂模式用于根据请求类型创建不同的消息处理器。
  • 工厂方法模式用于创建不同类型的服务，每种服务由一个具体工厂类创建。
  • 抽象工厂模式用于创建一系列相关的用户界面组件（按钮和文本框），不同风格的组件由不同的工厂类创建。
 

 

 

 

适配器模式
 

 

场景
 

假设你有一个旧的服务 LegacyPaymentService，它提供了处理支付的方法，但你希望将它适配到一个新的支付接口 PaymentService，以便在你的应用中使用新接口。
 

 

1. 旧服务接口和实现
 

LegacyPaymentService.java
 

package com.example.legacy;

// 旧服务接口
public interface LegacyPaymentService {
    // 处理旧支付接口的方法
    String processLegacyPayment(double amount);
}

 

LegacyPaymentServiceImpl.java
 

package com.example.legacy;

import org.springframework.stereotype.Service;

// 旧服务的具体实现
@Service
public class LegacyPaymentServiceImpl implements LegacyPaymentService {

    @Override
    public String processLegacyPayment(double amount) {
        // 实际处理支付的逻辑
        return "Processed payment of $" + amount + " with Legacy Payment Service.";
    }
}

 

2. 新服务接口
 

PaymentService.java
 

package com.example.new;

// 新服务接口
public interface PaymentService {
    // 处理支付的方法
    String processPayment(double amount);
}

 

3. 适配器类
 

PaymentServiceAdapter.java
 

package com.example.adapter;

import com.example.legacy.LegacyPaymentService;
import com.example.new.PaymentService;
import org.springframework.stereotype.Component;

// 适配器类，实现新服务接口，并委托旧服务处理逻辑
@Component
public class PaymentServiceAdapter implements PaymentService {

    private final LegacyPaymentService legacyPaymentService;

    // 构造函数注入旧服务
    public PaymentServiceAdapter(LegacyPaymentService legacyPaymentService) {
        this.legacyPaymentService = legacyPaymentService;
    }

    @Override
    public String processPayment(double amount) {
        // 调用旧服务的方法进行处理
        return legacyPaymentService.processLegacyPayment(amount);
    }
}

 

4. 控制器
 

PaymentController.java
 

package com.example.controller;

import com.example.new.PaymentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

// 控制器，处理客户端的 HTTP 请求
@RestController
public class PaymentController {

    private final PaymentService paymentService;

    // 构造函数注入新服务（实际上是适配器）
    @Autowired
    public PaymentController(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    // 处理 GET 请求，调用新服务的方法
    @GetMapping("/process-payment")
    public String processPayment(@RequestParam double amount) {
        // 使用新服务接口处理支付请求
        return paymentService.processPayment(amount);
    }
}

 

 

注释解释
 

  • 旧服务接口 (LegacyPaymentService)：定义了旧系统中现有的接口。
  • 旧服务实现 (LegacyPaymentServiceImpl)：实现了旧接口的方法，包含实际的业务逻辑。
  • 新服务接口 (PaymentService)：定义了新的服务接口，期望提供的支付处理方法。
  • 适配器 (PaymentServiceAdapter)：将旧服务接口适配为新服务接口，内部调用旧服务的实现。
  • 控制器 (PaymentController)：处理 HTTP 请求，使用新服务接口（实际上是适配器）来处理支付请求。
 

 

为什么要有适配器模式
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  我又懂了爱编程
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Java基础 学习笔记 Markdownr版

				
			

			

				

					06-27
				

			

		

		

			
				
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。  1. 面向对象（OOP）：Java的核心是...

			
		

	



                

              
                



	

		

			

				
					
Java基础学习笔记

				
			

			

				

					04-17
				

			

		

		

			
				
Java基础学习笔记中详细介绍了Java编程语言的一些基础知识，主要包括数组的声明与操作、方法的定义与使用、循环结构、静态成员的概念、Java的基本数据类型、类的定义与成员变量的封装、构造方法以及Java的包结构等...

			
		

	



                


  
              

                


	

		

			

				
					
java基础学习笔记.doc

				
			

			

				

					10-08
				

			

		

		

			
				
以上是Java基础学习笔记中涉及的关键知识点，涵盖了输入输出、对象创建、随机数生成、数组和集合的使用以及字符串操作。这些是学习Java编程时的基础内容，深入理解和熟练运用这些知识将有助于进一步学习更复杂的Java...

			
		

	





	

		

			

				
					
JAVA基础学习笔记

				
			

			

				

					04-23
				

			

		

		

			
				
【JAVA基础学习笔记】  在Java编程的初学者阶段，了解并掌握基础知识是非常关键的。首先，我们要进行JAVA环境的搭建，这包括安装JDK（Java Development Kit），它包含了JRE（Java Runtime Environment）和JVM（Java ...

			
		

	



		

			
		



	

		

			

				
					
JavaScript ArrayBuffer的读写与类型转换

				
			

			

				

					白瑕 的博客
				

				

					10-01
					
					403
					
				

			

		

		

			
				
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.

			
		

	





	

		

			

				
					
spring-boot 整合 mybatis

				
			

			

				

					m0_72168501的博客
				

				

					09-29
					
					510
					
				

			

		

		

			
				
spring boot 整合 mybatis

			
		

	





	

		

			

				
					
Java内存布局

				
			

			

				

					阿呆的专栏
				

				

					10-01
					
					781
					
				

			

		

		

			
				
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。

			
		

	





	

		

			

				
					
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）

				
			

			

				

					customer08的博客
				

				

					09-30
					
					1150
					
				

			

		

		

			
				
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。

			
		

	





	

		

			

				
					
C#基础：掌握控制流语句，构建灵活的程序逻辑

				
			

			

				

					学习和分享
				

				

					09-28
					
					319
					
				

			

		

		

			
				
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。

			
		

	





	

		

			

				
					
进程管理工具：非daemon进程管理工具supervisor

				
			

			

				

					happy_king_zi的博客
				

				

					09-29
					
					1102
					
				

			

		

		

			
				
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。

			
		

	





	

		

			

				
					
Java - LeetCode面试经典150题 - 哈希表 (二)

				
			

			

				

					心如冰清，天塌不惊
				

				

					09-28
					
					898
					
				

			

		

		

			
				
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。

			
		

	





	

		

			

				
					
【RocketMQ】RocketMQ应用难点

				
			

			

				

					记录一名在读研究生的学习笔记、感悟、开发产物
				

				

					09-30
					
					860
					
				

			

		

		

			
				
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。

			
		

	





	

		

			

				
					
C语言中的日志机制：打造全面强大的日志系统

				
			

			

				

					极客代码
				

				

					09-30
					
					407
					
				

			

		

		

			
				
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。

			
		

	





	

		

			

				
					
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)

				
			

			

				

					音符犹如代码的博客
				

				

					09-29
					
					324
					
				

			

		

		

			
				
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。

			
		

	





	

		

			

				
					
JAVA开源项目 旅游管理系统 计算机毕业设计

					
最新发布

				
			

			

				

					as230627的博客
				

				

					10-03
					
					1021
					
				

			

		

		

			
				
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。


			
		

	





	

		

			

				
					
【hot100-java】【合并两个有序链表】

				
			

			

				

					m0_73629042的博客
				

				

					09-30
					
					382
					
				

			

		

		

			
				
记忆中，两个指针合并即可。

			
		

	





	

		

			

				
					
Java中ResultSet接口的详细介绍

				
			

			

				

					2301_77032029的博客
				

				

					09-28
					
					452
					
				

			

		

		

			
				
ResultSet接口是Java JDBC API中的一个核心接口，用于表示从数据库查询返回的结果集。它允许用户遍历查询结果，并从中提取数据。ResultSet接口代表从数据库查询返回的结果集，它提供了以下功能：遍历结果集：允许用户向前或向后移动指针，以便访问结果集中的每一行。

			
		

	





	

		

			

				
					
[C++][程序退出]详细讲解

				
			

			

				

					SnowK博客
				

				

					09-30
					
					2806
					
				

			

		

		

			
				
[C++][程序退出]详细讲解

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值