<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Slience_L的博客]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/Slience_L</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; Slience_L]]></copyright><item><title><![CDATA[消灭ifelse之策略模式（附源码）]]></title><link>https://blog.csdn.net/Slience_L/article/details/114698825</link><guid>https://blog.csdn.net/Slience_L/article/details/114698825</guid><author>Slience_L</author><pubDate>Fri, 12 Mar 2021 17:50:30 +0800</pubDate><description><![CDATA[我们经常看到下面这种代码，里面成篇的ifelse，看起来非常low，本咸鱼在刚入门时就经常写这样的代码，为此经常被大佬吐槽…日后，你若写出bug，不要将为师供出来就好。。。。
//举例老的if else
if ("xxx".equals(type)) {
    System.out.println("do xxx");
} else if ("yyy".equals(type)) {
    System.out.println("do yyy");
} else if ("zzz".equals(typ]]></description><category></category></item><item><title><![CDATA[消灭ifelse之函数式编程（附源码）]]></title><link>https://blog.csdn.net/Slience_L/article/details/114700537</link><guid>https://blog.csdn.net/Slience_L/article/details/114700537</guid><author>Slience_L</author><pubDate>Fri, 12 Mar 2021 17:49:44 +0800</pubDate><description><![CDATA[接上篇：消灭ifelse之策略模式
函数式编程：
函数是一种最基本的任务，一个大型程序就是一个顶层函数调用若干底层函数，这些被调用的函数又可以调用其他函数，即大任务被一层层拆解并执行。所以函数就是面向过程的程序设计的基本单元。
Java不支持单独定义函数，但可以把静态方法视为独立的函数，把实例方法视为自带this参数的函数。
说到函数编程，就不得不提到java8中lambda表达式。
看一个经典的例子----线程
public static void main(String[] args) {
  new ]]></description><category></category></item><item><title><![CDATA[throws声明的异常会被指定抛出吗？]]></title><link>https://blog.csdn.net/Slience_L/article/details/114521577</link><guid>https://blog.csdn.net/Slience_L/article/details/114521577</guid><author>Slience_L</author><pubDate>Mon, 08 Mar 2021 10:14:39 +0800</pubDate><description><![CDATA[Java允许在方法的后面使用throws关键字对外声明该方法有可能发生异常，在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
比如：
public static void main(String[] args) throws Exception {
        int result = test(4,0);
        System.out.println(result);
        test1(1,2);
    }
    public stati]]></description><category></category></item><item><title><![CDATA[java设计模式之责任链模式（附源码）]]></title><link>https://blog.csdn.net/Slience_L/article/details/114140823</link><guid>https://blog.csdn.net/Slience_L/article/details/114140823</guid><author>Slience_L</author><pubDate>Mon, 01 Mar 2021 18:03:20 +0800</pubDate><description><![CDATA[java设计模式之责任链模式
责任链模式（Chain of Responsibility）是一种处理请求的模式，它让多个处理器都有机会处理该请求，直到其中某个处理成功为止。责任链模式把多个处理器串成链，然后让请求在链上传递：

看这个图是不是特别像过滤器的图，没错过滤器用的就是这个模式，它也叫过滤器模式，

...]]></description><category></category></item><item><title><![CDATA[java设计模式之装饰器模式（附源码）]]></title><link>https://blog.csdn.net/Slience_L/article/details/114266901</link><guid>https://blog.csdn.net/Slience_L/article/details/114266901</guid><author>Slience_L</author><pubDate>Mon, 01 Mar 2021 17:25:28 +0800</pubDate><description><![CDATA[装饰器（Decorator）模式：一种在运行期动态给某个对象的实例增加功能的方法。
Java提供的工具包中，IO相关工具就普遍大量使用了装饰器模式。
举一个艺术字的例子。
定义文本节点接口
public interface TextNode {
	void setText(String text);
	String getText();
}

定义一个抽象的文本修饰器
public abstract class NodeDecorator implements TextNode {

	protected ]]></description><category></category></item><item><title><![CDATA[java设计模式之适配器模式]]></title><link>https://blog.csdn.net/Slience_L/article/details/114141452</link><guid>https://blog.csdn.net/Slience_L/article/details/114141452</guid><author>Slience_L</author><pubDate>Fri, 26 Feb 2021 17:14:20 +0800</pubDate><description><![CDATA[java设计模式之适配器模式
将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
我们举个例子。如果去美国，我们随身带的电器是无法直接使用的，因为美国的插座标准和中国不同，所以，我们需要一个适配器。
在程序设计中，适配器也是类似的。我们已经有一个Task类，实现了Callable接口：
public class Task implements Callable&lt;Long&gt; {
    private long num;
    public T]]></description><category></category></item><item><title><![CDATA[java设计模式之观察者模式]]></title><link>https://blog.csdn.net/Slience_L/article/details/114134300</link><guid>https://blog.csdn.net/Slience_L/article/details/114134300</guid><author>Slience_L</author><pubDate>Fri, 26 Feb 2021 16:34:41 +0800</pubDate><description><![CDATA[java设计模式之观察者模式
最近接触到公司的基线，有一个开放平台的功能，接入了很多第三方接口，有一个多渠道消息推送的功能，最初这块都有不同的后台作为发布渠道，用接口来同步，非常杂乱，后来要做统一入口，即在运营后台编辑好文章发布，会自动推送给app、微信公众号、官网等渠道。作为开放平台，就要能够扩展更多的渠道。
观察者模式就非常适合这种场景----发布，订阅和扩展
观察者模式（Observer）又称发布-订阅模式（Publish-Subscribe：Pub/Sub）。它是一种通知机制，让发送通知的一方（被观]]></description><category></category></item><item><title><![CDATA[Java设计模式之静态代理模式与动态代理模式的区别（附源码）]]></title><link>https://blog.csdn.net/Slience_L/article/details/114091468</link><guid>https://blog.csdn.net/Slience_L/article/details/114091468</guid><author>Slience_L</author><pubDate>Fri, 26 Feb 2021 14:36:59 +0800</pubDate><description><![CDATA[Java设计模式之静态代理模式与动态代理模式的区别
代理模式可以在原有的业务逻辑代码前后设置前后置通知，在前后添加统一处理逻辑，利用代理来处理统一操作。
静态代理：
举一个交班费的例子
public interface Person {
	// 上交班费
	void giveMoney();
}

public class Student implements Person {
	private String name;

	public Student(String name) {
		this.name]]></description><category></category></item></channel></rss>