20天深度复习JavaSE的详细笔记(二十)——XML、解析、设计模式等

左手的ㄟ右手 2023-10-02 21:12 16阅读 0赞

#### 文章目录 ####

*  Demo20-XML、解析、设计模式等
 *   *  1.XML
     *   *  1.1认识XML
         *  1.2XML的语法规则
         *  1.3XML文档约束方式
         *   *  1.3.1认识XML文档约束
             *  1.3.2DTD约束
             *  1.3.3schema约束
         *  1.4XML解析技术
         *   *  1.4.1认识XML解析技术
             *  1.4.2Dom4J解析XML文件
             *  1.4.3案例实战
         *  1.5XML检索技术:Xpath
         *   *  1.5.1认识Xpath
             *  1.5.2案例实战
     *  2.设计模式
     *   *  2.1工厂模式
         *  2.2装饰模式

## Demo20-XML、解析、设计模式等 ##

### 1.XML ###

#### 1.1认识XML ####

1.XML概述:

*  XML是可扩展标记语言（eXtensible Markup Language）的缩写，它是是一种数据表示格式，可以描述非常复杂的数据结构，常用于传输和存储数据
    
     *  为什么叫做可扩展呢:因为里面的标签可以任意定义
    
    > <?xml version="1.0" encoding="UTF-8"?> 张三 李四
    > 
    > 北京  
    > 2022-11-11 11:11:11
    > 
    >   
    > 武汉  
    > 广州  
    >

2.XML的创建:

*  就是创建一个XML类型的文件，要求文件的后缀必须使用xml，如hello\_world.xml

3.XML的几个特点和使用场景:

*  一是纯文本，默认使用UTF-8编码；二是可嵌套
 *  如果把XML内容存为文件，那么它就是一个XML文件
 *  XML的使用场景:
    
     *  **XML内容经常被当成消息进行网络传输**
     *  **或者作为配置文件用于存储系统的信息**

#### 1.2XML的语法规则 ####

1.XML文件的语法规则:

*  XML文件的后缀名为：xml
 *  文档声明必须是第一行
    
    > <?xml version="1.0" encoding="UTF-8" ?>
    > 
    > version：XML默认的版本号码、该属性是必须存在的
    > 
    > encoding：本XML文件的编码

2.XML的标签(元素)规则:

*  标签由一对尖括号和合法标识符组成: ，必须存在一个根标签，有且只能有一个。
 *  标签必须成对出现，有开始，有结束:
    
     *  特殊的标签可以不成对，但是必须有结束标记，如:  
        
 *  标签中可以定义属性，属性和标签名空格隔开,属性值必须用引号引起来
 *  标签需要正确的嵌套
    
    > 张三

3.XML的其他组成:

*  XML文件中可以定义注释信息：<!– 注释内容 -->
 *  XML文件中可以存在以下特殊字符

![在这里插入图片描述][f6edcf2faf7c49f49645f4bef264166a.png_pic_center]

*  XML文件中可以存在CDATA区: <!\[CDATA\[ …内容… \]\]>

<?xml version="1.0" encoding="UTF-8" ?>
    
    <student>
        <name>女儿国王</name>
        <sex>女</sex>
        <hobby>唐僧，追唐僧</hobby>
        <info>
            <age>30</age>
            <addr>女儿国</addr>
        </info>
        <sql>
            select * from user where age < 18 && age > 10
            <![CDATA[
                    select * from user where age < 18
            ]]>
        </sql>
    </student>

#### 1.3XML文档约束方式 ####

##### 1.3.1认识XML文档约束 #####

问题：由于XML文件可以自定义标签，导致XML文件可以随意定义，程序在解析的时候可能出现问题,这时就需要文档约束了

什么是文档约束:

*  是用来限定xml文件中的标签以及属性应该怎么写
    
     *  以此强制约束程序员必须按照文档约束的规定来编写xml文件

文档约束的分类:

*  DTD
 *  schema

##### 1.3.2DTD约束 #####

> 认识即可,以后开发中人家会把DTD约束发过来,我们按人家规定的编写xml即可

需求:利用DTD文档约束，约束一个XML文件的编写

分析:

*  编写DTD约束文档，后缀必须是.dtd
    
    > <!ELEMENT 书架 (书+)> <!ELEMENT 书 (书名,作者,售价)> <!ELEMENT 书名 (\#PCDATA)> <!ELEMENT 作者 (\#PCDATA)> <!ELEMENT 售价 (\#PCDATA)>
    > 
    > "书+"代表"书"这个标签必须有一个或以上
 *  在需要编写的XML文件中导入该DTD约束文档
 *  按照约束的规定编写XML文件的内容
    
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE 书架 SYSTEM "data.dtd">
        <书架>
            <书>
                <书名>精通JavaSE加强</书名>
                <作者>dlei</作者>
                <售价>很贵</售价>
            </书>
            <书>
                <书名></书名>
                <作者></作者>
                <售价></售价>
            </书>
        </书架>

XML的文档约束-DTD的作用和问题:

*  可以约束XML文件的编写
 *  **不能约束具体的数据类型**,如:
    
    > <售价>很贵</售价>

##### 1.3.3schema约束 #####

> 认识即可,以后开发中人家会把schema约束发过来,我们按人家规定的编写xml即可

文档约束:

*  schema可以约束具体的数据类型，约束能力上更强大。
 *  schema本身也是一个xml文件，本身也受到其他约束文件的要求，所以编写的更加严谨
    
     *  也就是说其他文件可以约束schema,同时schema也可以约束xml文件

需求:利用schema文档约束,约束一个xml文件编写

分析:

*  编写schema约束文档，后缀必须是.xsd
 *  在需要编写的XML文件中导入该schema约束文档
 *  按照约束内容编写XML文件的标签。

data.xsd:

<?xml version="1.0" encoding="UTF-8" ?>
    <schema xmlns="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.itcast.cn"
            elementFormDefault="qualified" >
        
        <element name='书架'>
            
            <complexType>
                
                <sequence maxOccurs='unbounded'>
                    <element name='书'>
                        
                        <complexType>
                            <sequence>
                                <element name='书名' type='string'/>
                                <element name='作者' type='string'/>
                                <element name='售价' type='double'/>
                            </sequence>
                        </complexType>
                    </element>
                </sequence>
            </complexType>
        </element>
    </schema>

hello\_world\_schema.xml:

<?xml version="1.0" encoding="UTF-8" ?>
    <书架 xmlns="http://www.itcast.cn"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.itcast.cn data.xsd">
        
        <书>
            <书名>神雕侠侣</书名>
            <作者>金庸</作者>
            <售价>399.9</售价>
        </书>
        <书>
            <书名>神雕侠侣</书名>
            <作者>金庸</作者>
            <售价>19.5</售价>
        </书>
    
    </书架>

xml的文档约束schema的优点:

*  可以约束xml文件的标签内容格式,以及具体的数据类型
 *  本身也是xml文件，格式更严谨

#### 1.4XML解析技术 ####

##### 1.4.1认识XML解析技术 #####

1.XML的数据的作用是什么，最终需要怎么处理?

*  存储数据、做配置信息、进行数据传输
 *  最终需要被程序进行读取，解析里面的信息

2.什么是XML解析

*  使用程序读取XML中的数据
    
     *  **需要用XML解析器才能读取XML数据**,那为什么我们不自己解析XML中的数据呢:
        
         *  需要用io流读取xml中数据,再判断前后标签拿到标签中内容,工作量很大,所以我们这里就要用java或第三方公司为我们开发的技术:XML解析器

3.两种解析方式:

*  SAX解析(一行一行的读,一行一行的解析)
 *  DOM解析(将整个XML文件读到内存中,将它当成一个树来解析)

4.DOM方式常见的解析工具:

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>JAXP</td> 
   <td>SUN公司提供的一套XML的解析的API</td> 
  </tr> 
  <tr> 
   <td>JDOM</td> 
   <td>JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作</td> 
  </tr> 
  <tr> 
   <td><strong>dom4j(常用)</strong></td> 
   <td><strong>是JDOM的升级品，用来读写XML文件的。具有性能优异、功能强大和极其易使用的特点，它的性能超过sun公司官方的dom技术，同时它也是一个开放源代码的软件，Hibernate也用它来读写配置文件</strong></td> 
  </tr> 
  <tr> 
   <td>jsoup</td> 
   <td>功能强大DOM方式的XML解析开发包，尤其对HTML解析更加方便</td> 
  </tr> 
 </tbody> 
</table>

5.DOM解析解析文档对象模型:

![在这里插入图片描述][c2b6add144be4276b6792b508942d351.png_pic_center]

**Element对象,Attribute对象,Text对象都是Node对象,都实现了Node接口**

##### 1.4.2Dom4J解析XML文件 #####

需求:使用Dom4J把一个XML文件的数据进行解析

分析:

*  下载Dom4J框架
 *  在项目中创建一个文件夹:lib
 *  将dom4j-2.1.3.jar文件复制到lib文件夹
 *  在jar文件上点右键,选择:Add as Library->点击OK
 *  在类中导包使用

Dom4J解析XML得到Document对象:

SAXReader类:

<table> 
 <thead> 
  <tr> 
   <th>构造器/方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public SAXReader()</td> 
   <td>创建Dom4J的解析器对象</td> 
  </tr> 
  <tr> 
   <td>Document read(String url)</td> 
   <td>加载XML文件成为Document对象</td> 
  </tr> 
 </tbody> 
</table>

Document类:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Element getRootElement()</td> 
   <td>获得根元素对象</td> 
  </tr> 
 </tbody> 
</table>

Element类:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>List elements()</td> 
   <td>得到当前元素下所有子元素</td> 
  </tr> 
  <tr> 
   <td>List elements(String name)</td> 
   <td>得到当前元素下指定名字的子元素返回集合</td> 
  </tr> 
  <tr> 
   <td>Element element(String name)</td> 
   <td>得到当前元素下指定名字的子元素,如果有很多名字相同的返回第一个</td> 
  </tr> 
  <tr> 
   <td>String getName()</td> 
   <td>得到元素名字</td> 
  </tr> 
  <tr> 
   <td>String attributeValue(String name)</td> 
   <td>通过属性名直接得到属性值</td> 
  </tr> 
  <tr> 
   <td>String elementText(子元素名)</td> 
   <td>得到指定名称的子元素的文本</td> 
  </tr> 
  <tr> 
   <td>String getText()</td> 
   <td>得到文本</td> 
  </tr> 
 </tbody> 
</table>

Contacts.xml:

<?xml version="1.0" encoding="UTF-8"?>
    <contactList>
        <contact id="1" vip="true">
            <name>   潘金莲  </name>
            <gender>女</gender>
            <email>panpan@itcast.cn</email>
        </contact>
        <contact id="2" vip="false">
            <name>武松</name>
            <gender>男</gender>
            <email>wusong@itcast.cn</email>
        </contact>
        <contact id="3" vip="false">
            <name>武大狼</name>
            <gender>男</gender>
            <email>wuda@itcast.cn</email>
        </contact>
        <user>
        </user>
    </contactList>

解析Contacts.xml:

public class Dom4JHelloWorldDemo1 {
        
        @Test
        public void parseXMLData() throws Exception {
        
            // 1、创建一个Dom4j的解析器对象，代表了整个dom4j框架
            SAXReader saxReader = new SAXReader();
    
            // 2、把XML文件加载到内存中成为一个Document文档对象
            // Document document = saxReader.read(new File("xml-app\\src\\Contacts.xml")); //需要通过模块名去定位,这种方式和模块名耦合了,一旦模块名改了,这里的路径也就需要改变
    
            // 注意: getResourceAsStream中的/是直接去src下寻找文件
            InputStream is = Dom4JHelloWorldDemo1.class.getResourceAsStream("/Contacts.xml");
            Document document = saxReader.read(is);
    
            // 3、获取根元素对象
            Element root = document.getRootElement();
            System.out.println(root.getName());
    
            // 4、拿根元素下的全部子元素对象(一级)
             List<Element> sonEles =  root.elements();
            for (Element sonEle : sonEles) {
        
                System.out.println(sonEle.getName());
            }
    
            // 拿某个子元素
            Element userEle = root.element("user");
            System.out.println(userEle.getName());
            // 默认提取第一个子元素对象 (Java语言。)
            Element contact = root.element("contact");
            // 获取子元素文本方式一:
            System.out.println(contact.elementText("name"));
            // 去掉前后空格
            System.out.println(contact.elementTextTrim("name"));
            // 获取子元素文本方式二:
            Element email = contact.element("name");
            System.out.println(email.getText());
            // 去掉前后空格
            System.out.println(email.getTextTrim());
    
            //获取元素属性值:
            //方式一:根据属性对象获取属性值
            Attribute idAttr = contact.attribute("id");
            System.out.println(idAttr.getName() + "-->" + idAttr.getValue());
            //方式二:直接提取属性值
            System.out.println(contact.attributeValue("id"));
        }
    }

##### 1.4.3案例实战 #####

需求:利用Dom4J的知识，将Contact.xml文件中的联系人数据封装成List集合，其中每个元素是实体类Contact。打印输出 List 中的每个元素。

![在这里插入图片描述][12401d4a3b43410d93fe5e45dd272be2.png_pic_center]

![在这里插入图片描述][4567b79954074a5baabcb5e5ba26da46.png_pic_center]

public class Dom4JTest2 {
        
        @Test
        public void parseToList() throws Exception {
        
            // 需求：解析XML中的数据成为一个List集合对象。
            // 1、导入框架（前面已经导入过了）
            // 2、创建SaxReader对象
            SAXReader saxReader = new SAXReader();
            // 3、加载XML文件成为文档对象Document对象。
            Document document = saxReader.read(
                Dom4JTest2.class.getResourceAsStream("/Contacts.xml"));
            // 4、先拿根元素
            Element root = document.getRootElement();
            // 5、提取contact子元素
            List<Element> contactEles = root.elements("contact");
            // 6、准备一个ArrayList集合封装联系人信息
            List<Contact> contacts = new ArrayList<>();
            // 7、遍历Contact子元素
            for (Element contactEle : contactEles) {
        
                // 8、每个contact子元素都是一个联系人对象
                Contact contact = new Contact();
                contact.setId(Integer.valueOf(contactEle.attributeValue("id")));
                contact.setVip(Boolean.valueOf(contactEle.attributeValue("vip")));
                contact.setName(contactEle.elementTextTrim("name"));
                contact.setGender(contactEle.elementTextTrim("gender").charAt(0));
                contact.setEmail(contactEle.elementText("email"));
                // 9、把联系人对象数据加入到List集合
                contacts.add(contact);
            }
            // 10、遍历List集合
            for (Contact contact : contacts) {
        
                System.out.println(contact);
            }
        }
    }

#### 1.5XML检索技术:Xpath ####

##### 1.5.1认识Xpath #####

1.如果需要从XML文件中检索需要的某个信息(如name)怎么解决?

*  Dom4J需要进行文件的全部解析,然后再寻找数据(很麻烦)
 *  所以我们用Xpath技术做信息检索

2.Xpath介绍:

*  XPath在解析XML文档方面提供了一独树一帜的路径思想，更加优雅，高效
 *  XPath使用路径表达式来定位XML文档中的元素节点或属性节点
    
    > /元素/子元素/孙元素
    > 
    > //子元素//孙元素

3.Xpath的四大检索方案:

*  绝对路径
    
     *  采用绝对路径获取从根节点开始逐层的查找/contactList/contact/name节点列表并打印信息

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/根元素/子元素/孙元素(最开始的/代表文件)</td> 
   <td>从根元素开始，一级一级向下查找，不能跨级</td> 
  </tr> 
 </tbody> 
</table>

*  相对路径
    
     *  先得到根节点contactList
     *  再采用相对路径获取下一级contact 节点的name子节点并打印信息

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>./子元素/孙元素</td> 
   <td>从当前元素开始，一级一级向下查找，不能跨级</td> 
  </tr> 
 </tbody> 
</table>

*  全文检索
    
     *  直接全文搜索所有的name元素并打印

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>//contact</td> 
   <td>找contact元素，无论元素在哪里</td> 
  </tr> 
  <tr> 
   <td>//contact/name</td> 
   <td>找contact，无论在哪一级，但name一定是contact的子节点</td> 
  </tr> 
  <tr> 
   <td>//contact//name</td> 
   <td>contact无论在哪一种，name只要是contact的子孙元素都可以找到</td> 
  </tr> 
 </tbody> 
</table>

*  属性查找
    
     *  在全文中搜索属性，或者带属性的元素

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>//@属性名</td> 
   <td>查找属性对象，无论是哪个元素，只要有这个属性即可</td> 
  </tr> 
  <tr> 
   <td>//元素[@属性名]</td> 
   <td>查找元素对象，全文搜索指定元素名和属性名</td> 
  </tr> 
  <tr> 
   <td>//元素//[@属性名=‘值’]</td> 
   <td>查找元素对象，全文搜索指定元素名和属性名，并且属性值相等</td> 
  </tr> 
 </tbody> 
</table>

##### 1.5.2案例实战 #####

需求:使用Dom4J把一个XML文件的数据进行解析

分析:

*  导入jar包(dom4j和jaxen-1.1.2.jar)，Xpath技术依赖Dom4j技术
 *  通过dom4j的SAXReader获取Document对象
 *  利用XPath提供的API,结合XPath的语法完成选取XML文档元素节点进行解析操作

Document中与Xpath相关的API如下:

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Node selectSingleNode(“表达式”)</td> 
   <td>获取符合表达式的唯一元素(如果有多个那么只返回第一个)</td> 
  </tr> 
  <tr> 
   <td>List selectNodes(“表达式”)</td> 
   <td>获取符合表达式的元素集合</td> 
  </tr> 
 </tbody> 
</table>

public class XPathDemo {
        
        /**
         1.绝对路径: /根元素/子元素/子元素。
         */
        @Test
        public void parse01() throws Exception {
        
            // a、创建解析器对象
            SAXReader saxReader = new SAXReader();
            // b、把XML加载成Document文档对象
            Document document = saxReader.read(
                XPathDemo.class.getResourceAsStream("/Contacts2.xml"));
            // c、检索全部的名称
            List<Node> nameNodes = document.selectNodes("/contactList/contact/name");
            for (Node nameNode : nameNodes) {
        
                Element  nameEle = (Element) nameNode;
                System.out.println(nameEle.getTextTrim());
            }
        }
    
        /**
         2.相对路径： ./子元素/子元素。 (.代表了当前元素)
         */
        @Test
        public void parse02() throws Exception {
        
            // a、创建解析器对象
            SAXReader saxReader = new SAXReader();
            // b、把XML加载成Document文档对象
            Document document = saxReader.read(
                XPathDemo.class.getResourceAsStream("/Contacts2.xml"));
            Element root = document.getRootElement();
            // c、检索全部的名称
            List<Node> nameNodes = root.selectNodes("./contact/name");//(哪个Node对象调用selectNodes,这个小数点就代表哪个Node对象)
            for (Node nameNode : nameNodes) {
        
                Element  nameEle = (Element) nameNode;
                System.out.println(nameEle.getTextTrim());
            }
        }
    
        /**
         3.全文搜索：
         //元素  在全文找这个元素
         //元素1/元素2  在全文找元素1下面的一级元素2
         //元素1//元素2  在全文找元素1下面的全部元素2
         */
        @Test
        public void parse03() throws Exception {
        
            // a、创建解析器对象
            SAXReader saxReader = new SAXReader();
            // b、把XML加载成Document文档对象
            Document document = saxReader.read(
                XPathDemo.class.getResourceAsStream("/Contacts2.xml"));
            // c、检索数据
            //List<Node> nameNodes = document.selectNodes("//name");//能找到"我是西门庆"
            // List<Node> nameNodes = document.selectNodes("//contact/name");//不能找到"我是西门庆"
            List<Node> nameNodes = document.selectNodes("//contact//name");//能找到"我是西门庆"
            for (Node nameNode : nameNodes) {
        
                Element  nameEle = (Element) nameNode;
                System.out.println(nameEle.getTextTrim());
            }
        }
    
        /**
         4.属性查找。
         //@属性名称  在全文检索属性对象。
         //元素[@属性名称]  在全文检索包含该属性的元素对象。
         //元素[@属性名称=值]  在全文检索包含该属性的元素且属性值为该值的元素对象。
         */
        @Test
        public void parse04() throws Exception {
        
            // a、创建解析器对象
            SAXReader saxReader = new SAXReader();
            // b、把XML加载成Document文档对象
            Document document =
                    saxReader.read(XPathDemo.class.getResourceAsStream("/Contacts2.xml"));
            // c、检索数据
            List<Node> nodes = document.selectNodes("//@id");
            for (Node node : nodes) {
        
                Attribute attr = (Attribute) node;
                System.out.println(attr.getName() + "===>" + attr.getValue());
            }
    
            // 查询name元素（包含id属性的）
    //      Node node = document.selectSingleNode("//name[@id]");
            Node node = document.selectSingleNode("//name[@id=888]");
            Element ele = (Element) node;
            System.out.println(ele.getTextTrim());
        }
    }

### 2.设计模式 ###

#### 2.1工厂模式 ####

什么是工厂模式:

*  之前我们创建类对象时, 都是使用new 对象的形式创建,在很多业务场景下也提供了不直接new的方式
 *  工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一， 这种类型的设计模式属于创建型模式，它提供了一种获取对象的方式

工厂设计模式的作用:

*  对象通过工厂的方法创建返回，工厂的方法可以为该对象进行加工和数据注入
 *  可以实现类与类之间的解耦操作(核心思想)

public abstract class Computer {
        
        private String name;
        public abstract void start();
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
    }
    
    public class Huawei extends Computer{
        
        @Override
        public void start() {
        
            System.out.println(getName() + "开机了，展示了华为的菊花图标~~~~");
        }
    }
    
    public class Mac extends Computer{
        
        @Override
        public void start() {
        
            System.out.println(getName() + "以非常优雅的方法启动了，展示了一个苹果logo");
        }
    }
    
    public class FactoryPattern {
        
        public static Computer createComputer(String info){
        
            switch (info){
        
                case "huawei":
                    Computer c = new Huawei();
                    c.setName("huawei pro 16");
                    return c;
                case "mac":
                    Computer c2 = new Mac();
                    c2.setName("MacBook pro");
                    return c2;
                default:
                    return null;
            }
        }
    }
    
    public class FactoryDemo {
        
        public static void main(String[] args) {
        
            Computer c1 = FactoryPattern.createComputer("huawei");
            c1.start();
            Computer c2 = FactoryPattern.createComputer("mac");
            c2.start();
        }
    }

*  怎么理解工厂设计模式的作用中"可以实现类于类之间的解耦":
    
     *  就这个案例而言,以后我们我们有一个专门管理电脑实例对象的类FactoryPattern,修改任意一个电脑实例对象的属性值都是在这个类完成的,而不再像以前那样需要在类FactoryDemo中完成,所以说实现了类于类之间的耦合

#### 2.2装饰模式 ####

什么是装饰模式:

*  创建一个新类，包装原始类，从而在新类中提升原来类的功能

装饰模式的作用:

*  在不改变原类的基础上, 动态地扩展一个类的功能,例如:
    
    > InputStream(抽象父类)
    > 
    > FileInputStream(实现子类，读写性能较差)
    > 
    > BufferedInputStream(实现子类，装饰类，读写性能高)

具体步骤:

*  定义父类
 *  定义原始类,继承父类,定义功能
 *  定义装饰类,继承父类,包装原始类,增强功能
    
     *  装饰类只有也继承父类了,才能代表装饰类和原始类有相同的功能,总不能原始类里面方法名是read,装饰类里面方法名是read2吧

public abstract class InputStream {
        
        public abstract int read();
        public abstract int read(byte[] buffer);
    }
    
    public class FileInputStream extends InputStream{
        
        @Override
        public int read() {
        
            System.out.println("低性能的方式读取了一个字节a");
            return 97;
        }
        @Override
        public int read(byte[] buffer) {
        
            buffer[0] = 97;
            buffer[1] = 98;
            buffer[2] = 99;
            System.out.println("低性能的方式读取了一个字节数组：" + Arrays.toString(buffer));
            return 3;
        }
    }
    
    public class BufferedInputStream extends InputStream{
        
        private InputStream is;
        public BufferedInputStream(InputStream is){
        
            this.is = is;
        }
        @Override
        public int read() {
        
            System.out.println("提供8KB的缓冲区，提高读数据性能~~~~");
            return is.read();
        }
        @Override
        public int read(byte[] buffer) {
        
            System.out.println("提供8KB的缓冲区，提高读数据性能~~~~");
            return is.read(buffer);
        }
    }
    public class DecoratorPattern {
        
        public static void main(String[] args) {
        
            InputStream is = new BufferedInputStream(new FileInputStream());
            System.out.println(is.read());
            System.out.println(is.read(new byte[3]));
        }
    }

[f6edcf2faf7c49f49645f4bef264166a.png_pic_center]: https://img-blog.csdnimg.cn/f6edcf2faf7c49f49645f4bef264166a.png#pic_center
[c2b6add144be4276b6792b508942d351.png_pic_center]: https://img-blog.csdnimg.cn/c2b6add144be4276b6792b508942d351.png#pic_center
[12401d4a3b43410d93fe5e45dd272be2.png_pic_center]: https://img-blog.csdnimg.cn/12401d4a3b43410d93fe5e45dd272be2.png#pic_center
[4567b79954074a5baabcb5e5ba26da46.png_pic_center]: https://img-blog.csdnimg.cn/4567b79954074a5baabcb5e5ba26da46.png#pic_center