<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Be_nurturing的博客]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/Be_nurturing</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; Be_nurturing]]></copyright><item><title><![CDATA[迪米特法则_6]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/121117144</link><guid>https://blog.csdn.net/Be_nurturing/article/details/121117144</guid><author>Be_nurturing</author><pubDate>Wed, 03 Nov 2021 11:21:03 +0800</pubDate><description><![CDATA[迪米特法则
1.一个对象应该对其他对象保持最少的了解
2.类与类关系越密切，耦合度越大
3.迪米特法则又叫做最少知道原则，即一个类对自己依赖的类知道的越少越好，也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息
4.迪米特法则还有个更简单的定义：只与直接的朋友通信
5.直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖组合，关联，聚合等。其中，我们称出现成员变量，方]]></description><category></category></item><item><title><![CDATA[开闭原则_5]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/121024821</link><guid>https://blog.csdn.net/Be_nurturing/article/details/121024821</guid><author>Be_nurturing</author><pubDate>Thu, 28 Oct 2021 22:44:32 +0800</pubDate><description><![CDATA[开闭原则
基本介绍
1）开闭原则是编程中最基础，最重要的设计原则
2）一个软件实体类，模块和函数应该对扩展开放（对提供方），对修改关闭（对使用方）。用抽象构建框架，用实现扩展细节
3）当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
4）编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则
实现一个绘图的功能代码如下

public class Ocp {
    public static void main(String[] args) {
       ]]></description><category></category></item><item><title><![CDATA[里氏替换_4]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/121004123</link><guid>https://blog.csdn.net/Be_nurturing/article/details/121004123</guid><author>Be_nurturing</author><pubDate>Wed, 27 Oct 2021 22:59:57 +0800</pubDate><description><![CDATA[里氏替换
OO中的继承性的思考和说明
1）继承包含这样一层意义，父类中凡是已经实现好的方法，实际上是设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏
2）继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到的子类的功能都有可能产生故障。
3）问题提出，在编程中，如何正确]]></description><category></category></item><item><title><![CDATA[依赖倒转_3]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120983008</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120983008</guid><author>Be_nurturing</author><pubDate>Tue, 26 Oct 2021 22:49:25 +0800</pubDate><description><![CDATA[依赖倒转原则
基本介绍
1）高层模块不应该依赖底层模块，二者都应该依赖其抽象
2）抽象不应该依赖细节，细节应该依赖抽象
3）依赖倒转（倒置）核心思想是面向接口编程
应用实例
编程完成Person接受消息的功能
方式1分析

1.简单，比较容易想到
2.如果我们获取的对象是微信，短信等，则新增类，同时Person也要新增相应的接受方法
3.解决思路：引入一个抽象的接口IReceiver 表示接受者，这样Person类与接口IReceiver发生依赖，因为Emial,微信 等属于接受的范围， 他们各自实现IRe]]></description><category></category></item><item><title><![CDATA[接口隔离_2]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120982862</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120982862</guid><author>Be_nurturing</author><pubDate>Tue, 26 Oct 2021 22:33:49 +0800</pubDate><description><![CDATA[2 接口隔离原则
客户端不应该依赖它不需要的接口，即一个类对应另一个类的以来应该建立在最小的接口上
类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法。
2.1应用实例
类A通过接口Interface1依赖类B，
类C通过接口Interface1依赖类D，

public class Segregation1 {

    /**
     *  A类通过接口Inteface]]></description><category></category></item><item><title><![CDATA[单一职责_1]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120961626</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120961626</guid><author>Be_nurturing</author><pubDate>Tue, 26 Oct 2021 22:31:36 +0800</pubDate><description><![CDATA[1、单一职责
对类来说，即一个类应该只负责一项职责，如果类A负责两个不同职责：职责1，职责2，当职责1需求变更改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1,A2
1.1应用实例
方式1
public class SingleResponsibility1 {

    public static void main(String[] args) {

        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
]]></description><category></category></item><item><title><![CDATA[ES6_let声明变量以及声明特性01]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120972515</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120972515</guid><author>Be_nurturing</author><pubDate>Tue, 26 Oct 2021 16:07:26 +0800</pubDate><description><![CDATA[基础入门
1.let声明变量以及声明特性
1.1 let声明变量
&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
    &lt;meta charset="UTF-8"&gt;
    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;
    &lt;title&gt;let声明以及生命特性&lt;/title&gt;
&lt;/hea]]></description><category></category></item><item><title><![CDATA[NodeJS_package和NPM_3]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120841086</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120841086</guid><author>Be_nurturing</author><pubDate>Tue, 26 Oct 2021 10:28:42 +0800</pubDate><description><![CDATA[一、包（package）
CommonJS的包规范允许我们将一组相关的模块组合到一起，形成一组完整的工具
CommonJS的包规范有包结构和包描述文件两个部分组成
1.1包结构
用于组织包中的各种文件
包实际上就是一个压缩文件，解压以后还原为目录。符合规范的目录，应该包含如下文件
-package  :描述文件
-bin:可执行二进制文件
-lib:js代码
-doc:文档
-test:单元测试
1.2包描述文件
包描述的相关信息，以供外部读取分析
包描述文件用于表达非代码相关的信息，它是一个 JSON格式]]></description><category></category></item><item><title><![CDATA[NodeJS_文件系统_4]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120966878</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120966878</guid><author>Be_nurturing</author><pubDate>Tue, 26 Oct 2021 10:28:15 +0800</pubDate><description><![CDATA[一、Buffer缓冲区
/**
 *  Buffer(缓冲区)
 *      -Buffer的结构和数组很像，操作的方法也和数组类似
 *      - 数组中不能存储二进制的文件，而buffer就是专门存储二进制数
 *      - 在buffer中存储的都是二进制数据，但是在显示时都是以16进制的形式显示
 *          buffer中每一个元素的范围是从00-ff 0-255
 *          00000000 - ffffffff
 *
 *          计算机 一个0 或一]]></description><category></category></item><item><title><![CDATA[NodeJS_exports和module.exports_2]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120822168</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120822168</guid><author>Be_nurturing</author><pubDate>Tue, 19 Oct 2021 10:20:06 +0800</pubDate><description><![CDATA[exports和module.exports
示例代码
定义一个helloModule模块
exports={
    name:"猪八戒",
    age:28,
    sayName:function () {
        console.log("我是猪八戒");
    }}

，再定义一个另外一个js文件，引用helloModule中的变量和函数看结果
var hello = require("./helloModule");

console.log(hello.name);
conso]]></description><category></category></item><item><title><![CDATA[NodeJS_入门学习_1]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/120720003</link><guid>https://blog.csdn.net/Be_nurturing/article/details/120720003</guid><author>Be_nurturing</author><pubDate>Mon, 18 Oct 2021 10:40:39 +0800</pubDate><description><![CDATA[一、Node.js简介
1.Node.js是一个能够在服务器端运行JavaScript的开放源代码、跨平台JavaScript运行环境。
2.Node采用Google开发的V8引擎运行js代码，使用事件驱动、非阻塞和异步I/O模型等技术来提高性能，可优化应用程序的传输量和规模。
3.Node大部分基本模块都用JavaScript编写。在Node出现之前，JS通常作为客户端程序设计语言使用，以JS写出的程序常在用户的浏览器上运行。
4.Node主要用于编写像Web服务器一样的网络应用，这和PHP和Python]]></description><category></category></item><item><title><![CDATA[NIO介绍]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/119035676</link><guid>https://blog.csdn.net/Be_nurturing/article/details/119035676</guid><author>Be_nurturing</author><pubDate>Fri, 23 Jul 2021 17:04:56 +0800</pubDate><description><![CDATA[一、JAVA NIO 与IO区别
IO                                                NIO
面向流                                    面向缓冲区
阻塞IO                                    非阻塞IO
无                                           选择器	Selector
二、通道和缓冲区
Java NIO系统的核心在于：通道（Channnel）]]></description><category></category></item><item><title><![CDATA[1. 两数之和]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/119004400</link><guid>https://blog.csdn.net/Be_nurturing/article/details/119004400</guid><author>Be_nurturing</author><pubDate>Thu, 22 Jul 2021 18:07:13 +0800</pubDate><description><![CDATA[两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], tar.]]></description><category></category></item><item><title><![CDATA[八、Lambda时间与日期API]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118727190</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118727190</guid><author>Be_nurturing</author><pubDate>Wed, 14 Jul 2021 16:12:59 +0800</pubDate><description><![CDATA[一、使用LocalDate、LocalTime、LocalDateTime
LocalDate、LocalTime、LocalDateTime类的实例时不可变的对象，分别表示使用ISO-8601日历系统的日期、时间、日期和时间，他们提供了简单的日期或时间，并不包含当前时间信息，也不包含与时区相关的信息
public class TestLambda{
	
	public void test(){
		LocalDate ldt = LocalDateTime.now();
		System.out.prin]]></description><category></category></item><item><title><![CDATA[七、Lambda 容器类Optional]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118700923</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118700923</guid><author>Be_nurturing</author><pubDate>Tue, 13 Jul 2021 15:37:12 +0800</pubDate><description><![CDATA[一、Optional 类
Optional 类（java.util.Optional） 是一个容器类，代表一个值存在或不存在 原来用null表示一个值不存在，现在Optional可以更好的表达这个概念，并且可以避免空指针异常
public class TestLambda{
	/**
	* Optional 类常用方法
	* Optional.of(T t) 创建一个Optional实例
	* Optional.empty() 创建一个空Optional实例
	* Optional.foNullable(T]]></description><category></category></item><item><title><![CDATA[六、Lambda Stream归约与收集]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118679804</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118679804</guid><author>Be_nurturing</author><pubDate>Mon, 12 Jul 2021 17:58:40 +0800</pubDate><description><![CDATA[Stream归约与收集
public class TestLambda{

	 List&lt;Employee&gt; emps = Arrays.asList(
            new Employee(101,"张三",18, Employee.Status.VOCATION),
            new Employee(102,"李四",28, Employee.Status.VOCATION),
            new Employee(103,"王五",38, Emplo]]></description><category></category></item><item><title><![CDATA[五、Lambda Stream查找与匹配]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118678044</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118678044</guid><author>Be_nurturing</author><pubDate>Mon, 12 Jul 2021 16:51:30 +0800</pubDate><description><![CDATA[Lambda Stream查找与匹配
public class TestLambda{
	
	/**
	*	终止操作
	* 查找与匹配
	* allMatch -- 检查是否匹配所有元素
	* anyMatch -- 检查是否至少匹配一个元素
	* noneMacth -- 检查是否美哟匹配所有元素
	* findFirst -- 返回第一个元素
	* findAny -- 返回当前流中的任意元素
	* count -- 返回流中的元素的总个数
	* max -- 返回流中最大值
	* min -- 返回流]]></description><category></category></item><item><title><![CDATA[四、Lambda 流Stream]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118673928</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118673928</guid><author>Be_nurturing</author><pubDate>Mon, 12 Jul 2021 15:12:42 +0800</pubDate><description><![CDATA[一、流到底时什么
是数据通道，用于操作数据源（集合、数组等）所生成的元素序列
“集合讲的是数据，流讲的是计算”
注意：
① Stream不会存储元素
② Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
③ Stram操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
/**
* 一、Stream 的三个操作
*   1.创建stream
*   2.中间操作
*   3.终止操作（终端操作）
**/
public class TestStream{
	
	 List&lt;]]></description><category></category></item><item><title><![CDATA[三、Lambda 方法引用与构造器引用]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118607405</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118607405</guid><author>Be_nurturing</author><pubDate>Fri, 09 Jul 2021 16:31:16 +0800</pubDate><description><![CDATA[Lambda 方法引用与构造器引用
public class TestMethodRef{
	/**
	* 一、方法引用：若Lambda 体中的内容有方法已经实现，我们可以使用“方法引用”
	*            （可以理解为方法引用是lambda表达式的另一种表现形式）
	*    主要三种语法格式：
	* 	   ① 对象::实现方法名
	*      ② 类::静态方法名
	*      ③ 类::实例方法名
	*   注意:
	*       ① lambda 体中调用方法的参数列表与返回值类型]]></description><category></category></item><item><title><![CDATA[二、Lambda 四大内置核心函数式接口]]></title><link>https://blog.csdn.net/Be_nurturing/article/details/118606433</link><guid>https://blog.csdn.net/Be_nurturing/article/details/118606433</guid><author>Be_nurturing</author><pubDate>Fri, 09 Jul 2021 15:05:45 +0800</pubDate><description><![CDATA[Lambda 四大内置核心函数式接口
直接上代码
public class TestLambda{
	
	/**1.Consuner&lt;T&gt; 消费型接口
	  *     void accept(T t); 接收一个参数 ，无返回值
	  **/
   @Test
   public void test1(){
		happy(1000,(m)-&gt;System.out.println("每次消费"+ m + "元"));
	}
   
   public void happy(double ]]></description><category></category></item></channel></rss>