精华内容
下载资源
问答
  • 千兆光模块和万兆光模块区别

    千次阅读 2020-03-23 20:50:09
    众所周知千兆光模块和万兆光模块的主要区别是它们的传输速率不一样,千兆光模块的传输速率是1000Mbps,而万兆光模块的传输速率是10Gbps。除了传输速率有差异以外,你知道千兆光模块和万兆光模块的其它差异吗?我们从...

    众所周知千兆光模块和万兆光模块的主要区别是它们的传输速率不一样,千兆光模块的传输速率是1000Mbps,而万兆光模块的传输速率是10Gbps。除了传输速率有差异以外,你知道千兆光模块和万兆光模块的其它差异吗?我们从以下几个方便一起了解下。

    一、千兆光模块和万兆光模块的分类区别:

    千兆光模块包括1000Base SFP光模块、BIDI SFP光模块、CWDM SFP光模块、DWDM SFP光模块、SONET/SDH SFP光模块、GBIC光模块这六种。

    万兆光模块包括10G SFP+光模块、BIDI SFP+光模块、CWDM SFP+光模块、DWDM SFP+光模块、10G XFP光模块、BIDI XFP光模块、CWDM XFP光模块、DWDM XFP光模块和10G X2光模块这九种。

    二、千兆光模块和万兆光模块的应用区别:

    千兆光模块应用于千兆以太网、双通道和双向传输的同步光纤网络(SONET),

    而万兆光模块则应用于万兆以太网、STM-64和OC-192速率标准的同步光纤网络(SONET)以及10G光纤通道。

    三、千兆光模块和万兆光模块的参数区别:

    (1)千兆光模块的参数:

    中心波长:千兆光模块的中心波长主要有1310nm、1470nm、1550nm、1330nm-TX/1270nm-RX这几种,其中中心波长是1550nm的光模块是单模光模块,并且它的传输距离可达40km以上。

    传输距离:千兆光模块的传输距离从20km到120km不等,大部分的千兆光模块的传输距离都在100km左右。

    接口:除GBIC千兆光模块的接口是SC双工以外,其余的万兆光模块的接口都是LC双工。

    光纤类型:万兆光模块通常和单模光纤一起使用,所以它的光纤类型为SMF。

    激光器类型:千兆光模块的激光器类型主要有DFB 1550nm、DFB BiDi、DFB 1310nm、DFB CWDM、DFB DWDM这几种。

    DOM功能:千兆光模块中除了GBIC光模块不支持DOM功能以外,其它的千兆光模块均支持DOM功能,这和GBIC光模块是早期的光模块有关。

    (2)万兆光模块的参数:

    中心波长:万兆光模块的中心波长有1470nm、1550nm、1590nm、1330nm-TX/1270nm-RX这几种,其中1330nm-TX/1270nm-RX是BiDi光模块。

    传输距离:万兆光模块的传输距离在20km到80km不等,但是大部分的万兆光模块的传输距离都是80km。

    接口:除XENPAK万兆光模块的接口是SC双工以外,其余的万兆光模块的接口都是LC双工。

    光纤类型:万兆光模块的光纤类型和千兆光模块一样,都是SMF。

    激光器类型:万兆光模块的激光器类型有EML 1550nm、DFB BiDi、EML CWDM、EML DWDM、DFB CWDM这几种,从激光器的类型中我们可以得出它的中心波长或者封装类型的信息。

    DOM功能:万兆光模块都带有DOM功能,这个功能可以帮助网络管理员实时监控光模块的各方面数据,网络管理员也可以通过查看这些数据来确保光模块正常工作。

    小结:

    1)自适应光电模块。

    自适应光转电模块是将10/100/1000Base三种速率集成到CMOS芯片上的模块,可应用于百兆以太网和千兆以太网。

    2)万兆光模块能用在千兆交换机上吗?

    千兆交换机上有万兆拓展口就可以使用万兆光模块,若没有,则不能使用,必须严格按照光模块和交换机上的端口速率来选择合适的光模块。

    在应用中应该选择千兆光模块还是万兆光模块要看您的网络类型,例如您的网络是千兆以太网就要用千兆光模块,万兆以太网则用万兆光模块,通常万兆光模块用在数据中心。

    展开全文
  • 液晶显示模块的分类基本知识

    千次阅读 2013-04-20 10:55:11
    液晶显示模块 液晶显示模块是即“Liquid Crystal Display Module”,简称“LCM”,是一种将液晶显示器件、连接件、集成电路、PCB线路板、背光源、结构件装配在一起的组件。主要完成液晶显示器的连接功能。 ...

    液晶显示模块

    液晶显示模块是即“Liquid Crystal Display Module”,简称“LCM”,是一种将液晶显示器件、连接件、集成电路、PCB线路板、背光源、结构件装配在一起的组件。主要完成液晶显示器的连接功能。

    • 液晶显示模块的分类

      • 一、数显液晶模块

        数显液晶模块是一种由段型液晶显示器件与专用的集成电路组装成一体的功能部件,只能显示数字和一些标识符号。段型液晶显示器件大多应用在便携、袖珍设备上。由于达些设备体积小,所以尽可能不将显示部分设计成单独的部件,即使一些应用领域需要单独的显示组件,那么也应该使其除具有显示功能外,还应具有一些信息接收、处理、存储传递等功能,由于它们具有某种通用的、特定的功能而受市场的欢迎。常见的的数显液晶显示模块有以下几种。

        1.计数模块

        这是一种由不同位数的七段型液晶显示器件与译码驱动器,或再加上计数器装配成的计数显示部件。它具有记录、处理、显示数字的功能。目前我国市场上能够见到的主要产品有由CD4055译码驱动器驱动的单位液晶显示器件显示模块,以及由ICM72ll,ICM7231,ICM7232,CDl4543,UPDl45001,HD44100等集成电路与相应配套的液晶显示器件组装成的4位、6位、8位、10位、12位、16位计数模块。

        2.计量模块

        计量模块是一种有多位段型液晶显示器件和具有译码、驱动、计数、A/D转换功能的集成电路片组装而成的模块。由于所用的集成电路中具有A/D转换功能,所以可以将输入的模拟量电信号转换成数字量显示出来。我们知道任何物理量,甚至化学量(如酸碱度等)都可以转换为模拟电量,所以只要配上一定的传感器,这种模块就可以实现任何量值的碉量和显示,使用起来十分方便。计量模块所用的集成电路型号主要有ICL7106、ICL7116、ICL7126、ICL7136、ICL7135ICL7129等,这些集成电路的功能、特性决定了计量模块的功能和特性。作为计量产品,按规定必须进行计量鉴定。经计量部门批准在产品上贴有计量合格证。

        3.计时模块

        计时模块将液晶显示器件用于计时历史最久,将一个液晶显示器件与一块计时集成电路装配在一起就是一个功能完整的计时器。声于它没有成品钟表的外壳,所以称之为计时模块。计时模块虽然用途很广,但通用、标准型的计时模块却很难在市场上买到,只能到电子钟表生产厂家去选购或定购合适的表芯,计时模块和计数模块虽然外观相似,但它们的的显示方式不同,计时模块显示的数字是由两位一组两位一组的数字组成的.而计数模块每位数字均是连续排列的。由于不少计时模块还具有定时、控制功能,因此这类模块可广泛装配到一些加电、设备上,如收录机、CD机、微波炉、电饭煲等电器上。

        二、液晶点阵字符模块

        液晶点阵字符模块是由点阵字符液晶显示器件和专用的行、列驱动器、控制器及必要的连接件,结构件装配而成的,可以显示数字和西文字符。这种点阵字符模块本身具有字符发生器,显示容量大,功能丰富。一般该种模块最少也可以显示8位1行或16位l行以上的字符。这种模块的点阵排列是由5×7、5×8或5×11的一组组像素点阵排列组成的。每组为1位,每位间有一点的间隔,每行间也有一行的间隔,所以不能显示图形,其规格主要如右表所示:

        一般在模块控制、驱动器内具有已固化好192个字符字模的字符库CGROM,还具有让用户自定义建立专用字符的随机存储器CGRAM,允许用户建立8个5×8点阵的字符。

        三、点阵图形液晶模块

        点阵图形液晶模块也是点阵模块的一种,其特点是点阵像素连续排列,行和列在排布中均没有空隔。因此可以显示了连续、完整的图形。由于它也是有X-Y矩阵像素构成的,所以除显示图形外,也可以显示字符。主要有以下几种类型:

        1.行、列驱动型

        2.行、列驱动-控制型

        3.行、列控制型

    • 液晶显示模块的连接方式

      • 1、斑马条连接

        2、金属插脚连接(PIN

        3、斑马纸连接

        4、热压集成电路芯片(COG)

        5、热压带载封装片

    • 液晶显示模块的主要参数

      • 1、分辨率

        分辨率是一个非常重要的性能指标。它指的是屏幕上水平和垂直方向所能够显示的点数(屏幕上显示的线和面都是由点构成的)的多少,分辨率越高,同一屏幕内能够容纳的信息就越多。对于一台能够支持1280x1024分辨率的CRT来说,无论是320x240还是1280x1024分辨率,都能够比较完美地表现出来(因为电子束可以做弹性调整)。但它的最大分辨率未必是最合适的分辨率,因为如果17寸显示器上到1280x1024分辨率的话,WINDOWS的字体会很小,时间一长眼睛就容易疲劳,所以17寸显示器的最佳分辨率应为1024x768。

        2、对比度

        液晶面板制造时选用的控制IC、滤光片和定向膜等配件,与面板的对比度有关,对一般用户而言,对比度能够达到350:1就足够了,但在专业领域这样的对比度平还不能满足用户的需求。相对CRT显示器轻易达到500:1甚至更高的对比度而言。只有高档液晶显示器才能达到这样如此程度,由于对比度很难通过仪器准确测量,所以挑的时候还是要自己亲自去看才行。

        3、亮度

        液晶是一种介于固态与液态之间的物质,本身是不能发光的,需借助要额外的光源才行。因此,灯管数目关系着液晶显示器亮度。最早的液晶显示器只有上下两个灯管,发展到现在,普及型的最低也是四灯,高端的是六灯。四灯管设计分为三种摆放形式:一种是四个边各有一个灯管,但缺点是中间会出现黑影,解决的方法就是由上到下四个灯管平排列的方式,最后一种是“U”型的摆放形式,其实是两灯变相产生的两根灯管。六灯管设计实际使用的是三根灯管,厂商将三根灯管都弯成“U”型,然后平行放置,以达到六根灯管的效果。

        4、信号响应时间

        响应时间指的是液晶显示器对于输入信号的反应速度,也就是液晶由暗转亮或由亮转暗的反应时间,通常是以毫秒(ms)为单位。要说清这一点我们还要从人眼对动态图像的感知谈起。人眼存在“视觉残留”的现象,高速运动的画面在人脑中会形成短暂的印象。动画片、电影等一直到现在最新的游戏正是应用了视觉残留的原理,让一系列渐变的图像在人眼前快速连续显示,便形成动态的影像。人能够接受的画面显示速度一般为每秒24张,这也是电影每秒24帧播放速度的由来,如果显示速度低于这一标准,人就会明显感到画面的停顿和不适。按照这一指标计算,每张画面显示的时间需要小于40ms。这样,对于液晶显示器来说,响应时间40ms就成了一道坎,低于40ms的显示器便会出现明显的“拖尾”或者“残影”现象,让人有混沌之感。要是想让图像画面达到流畅的程度,则就需要达到每秒60帧的速度。

        5、可视角度

        液晶的可视角度是一个让人头疼的问题,当背光源通过偏极片、液晶和取向层之后,输出的光线便具有了方向性。也就是说大多数光都是从屏幕中垂直射出来的,所以从某一个较大的角度观看液晶显示器时,便不能看到原本的颜色,甚至只能看到全白或全黑。为了解决这个问题,制造厂商们也着手开发广角技术,到目前为止有三种比较流行的技术,分别是:TN+FILM、IPS(IN-PLANE -SWITCHING)和MVA(MULTI-DOMAIN VERTICAL alignMENT)。

    • 液晶显示模块使用注意事项

      • 一、操作注意事项:

        1、显示屏为玻璃制作,请勿施予机械冲击,如从高处坠落等。

        2、若显示屏损坏,内部液晶泄漏,切勿使其进入口中。若沾到衣服或皮肤上,迅速用肥皂和水清洗。

        3、勿对显示屏表面或,一定正确接地。

        c、为了减少产生静电,不要在干燥环境下实施装配及其它工作。

        d、LCD 模块有一层保护显示屏的膜。撕掉这层保护膜时要小心,因为可能会产生静电。

        2、尽量减少电极腐蚀。水滴、潮气凝结或高温环境下的电流可能加速电极腐蚀。

        三、其它

        1、 在低温(低于存贮温度范围)下,液晶凝固会导致方向性缺陷或产生气泡(黑色或白色的)。当液晶模块在低温下受到强烈振动时也会产生气泡。

        2、如果LCD 模块长时间工作且显示相同的图案,该图案就会象幻影一样保留在屏上并会出现细微的对比的差别。若想重新获得正常的工作状态可暂时停止使用一会儿。值得注意的是这种现象不会对性能的可靠性产生不良作用。

    展开全文
  • 本系列前面博客的链接:Java-单机版的书店管理系统(练习设计模块和思想_系列 ) http://blog.csdn.net/qq_26525215/article/details/51136848Java-单机版的书店管理系统(练习设计模块和思想_系列 四(2) ): ...

    本系列前面博客的链接:

    Java-单机版的书店管理系统(练习设计模块和思想_系列 五 )
    http://blog.csdn.net/qq_26525215/article/details/51136848

    Java-单机版的书店管理系统(练习设计模块和思想_系列 四(2) ):
    http://blog.csdn.net/qq_26525215/article/details/51117135

    Java-单机版的书店管理系统(练习设计模块和思想_系列 四(1) ):
    http://blog.csdn.net/qq_26525215/article/details/51116429

    Java-单机版的书店管理系统(练习设计模块和思想_系列 三 ):
    http://blog.csdn.net/qq_26525215/article/details/51099202

    Java-单机版的书店管理系统(练习设计模块和思想_系列 二 ):
    http://blog.csdn.net/qq_26525215/article/details/51089734

    Java-单机版的书店管理系统(练习设计模块和思想_系列 一 ):
    http://blog.csdn.net/qq_26525215/article/details/51073546

    介绍:

    现在写到了进货模块了,这应该是本书店系统最难的模块了吧。

    本次多写了一个工具类:
    把字符串比较的代码抽取出来写了一个类了。因为需要比较的字符串比较多。

    还有进货模块的值对模块,分为了4个部分。
    1、进货值对象
    2、进货查询值对象
    3、进货明细值对象
    4、进货明细查询值对象。

    进货模块表现层的List模块,Add模块。

    数据层模块和逻辑层模块。写好了大部分功能。
    可以执行添加进货。
    list界面有2个list列表,一个是进货列表,一个是进货明细列表。
    这2个表示有联系的!选中进货列表的某一行时,需要在另外一个列表中显示这个进货的明细!

    后期会对列表一的显示改一下的,时间会改成**年
    (取系统时间显示!)
    进货人不会再只显示编号。会直接显示名字的!

    后面有这次增加的代码模块,
    然后,其他模块的源代码可能有部分修改,
    其他模块的源代码百度云链接(CSDN上传文件好像有一天的缓冲期,我刚刚上传的,现在还找不到,只能先贴出百度云的文件的源代码链接):
    (目前我的所有源代码:)
    http://pan.baidu.com/s/1jHOgFqQ

    展示图片:

    部分的代码模块:

    工具类:StringComparison类:

    package cn.hncu.bookStore.util;
    
    /**
     * 工具类
     * 字符串比较
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class StringComparison {
    
        /**
         * @param str1---需要比较的字符串
         * @param str2---被比较的字符串
         * @return--- 返回0 , 2个字符串相同,<br/> 
         *            返回-1,str1和str2不相同,<br/>
         *            返回1,str1是str2的子串(忽略str1两端空格)<br/>
         *            返回2,说明str1为null或者str1全部为空格<br/>
         */
        public static int stringComp(String str1,String str2){
            if(str1==null||!(str1.trim().length()>0)){
                return 2;
            }
    
            //字符串完全相同
            if(str1!=null&&str1.trim().length()>0){
                if(str1.equals(str2)){
                    return 0;
                }
            }
    
            //模糊匹配(忽略两端空格)
            if(str1!=null&&str1.trim().length()>0){
                if(str2.indexOf(str1.trim())!=-1){
                    return 1;
                }
            }
            return -1;
        }
    }
    

    注意一个问题:

    要使用对象流读取文件:

    这个类必须实现Serializable接口!!!!!

    值对象模块:

    进货值对象:InMainModel:

    package cn.hncu.bookStore.in.vo;
    
    import java.io.Serializable;
    
    /**
     * 进货管理值对象封装
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InMainModel implements Serializable, Comparable<InMainModel>{
        //进货单编号
        private String uuid;
        //进货时间
        private long inDate;
        //进货人员编号
        private String inUserId;
    
        /* 
           如果某个字段是外键,同时又需要在当前表中相应表现层显示出用户能看得懂
         的信息,则需要补一个专用于信息显示(给用户看)的字段。
         */
        private String inUserName;
    
        public String getInUserName() {
            return inUserName;
        }
    
        public void setInUserName(String inUserName) {
            this.inUserName = inUserName;
        }
    
        /**
         * 
         * @return ---返回进货单编号(String型)
         */
        public String getUuid() {
            return uuid;
        }
    
        /**
         * 
         * @param uuid---设置进货单编号(String型)
         */
        public void setUuid(String uuid) {
            this.uuid = uuid;
        }
    
        /**
         * 
         * @return---返回进货时间(long型)
         */
        public long getInDate() {
            return inDate;
        }
    
        /**
         * 
         * @param inDate---设置进货时间(long型)
         */
        public void setInDate(long inDate) {
            this.inDate = inDate;
        }
    
        /**
         * 
         * @return---返回进货人员编号(String型)
         */
        public String getInUserId() {
            return inUserId;
        }
    
        /**
         * 
         * @param inUserId---设置进货人员编号(String型)
         */
        public void setInUserId(String inUserId) {
            this.inUserId = inUserId;
        }
    
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
            return result;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            InMainModel other = (InMainModel) obj;
            if (uuid == null) {
                if (other.uuid != null)
                    return false;
            } else if (!uuid.equals(other.uuid))
                return false;
            return true;
        }
    
        @Override
        public String toString() {
            return uuid + ", " + inDate
                    + ", " + inUserId;
        }
    
        @Override
        public int compareTo(InMainModel o) {
            return Integer.parseInt(uuid)-Integer.parseInt(o.uuid);
        }
    
    
    
    }
    

    进货明细值对象类:InDetailModel

    package cn.hncu.bookStore.in.vo;
    
    import java.io.Serializable;
    
    /**
     * 进货明细管理的值对象封装
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InDetailModel implements Serializable{
        //进货明细编号
        private String uuid;
        //进货单编号
        private String inId;
        //图书编号
        private String bookId;
        //进货数量
        private int sumNum;
        //进货总金额
        private double sumMoney;
    
        //为把书名显示给用户看,给bookUuid添加一个bookName属性
        private String bookName;
    
    
    
        public String getBookName() {
            return bookName;
        }
        public void setBookName(String bookName) {
            this.bookName = bookName;
        }
        public String getUuid() {
            return uuid;
        }
        public void setUuid(String uuid) {
            this.uuid = uuid;
        }
        public String getInId() {
            return inId;
        }
        public void setInId(String inId) {
            this.inId = inId;
        }
        public String getBookId() {
            return bookId;
        }
        public void setBookId(String bookId) {
            this.bookId = bookId;
        }
        public int getSumNum() {
            return sumNum;
        }
        public void setSumNum(int sumNum) {
            this.sumNum = sumNum;
        }
        public double getSumMoney() {
            return sumMoney;
        }
        public void setSumMoney(double sumMoney) {
            this.sumMoney = sumMoney;
        }
    
    
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            InDetailModel other = (InDetailModel) obj;
            if (uuid == null) {
                if (other.uuid != null)
                    return false;
            } else if (!uuid.equals(other.uuid))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return uuid +", "+bookName + ", " + sumNum
                    + "本, " + sumMoney + "元";
        }
    
    
    
    
    
    }
    

    进货查询值对象类:InMainQueryModel

    package cn.hncu.bookStore.in.vo;
    
    /**
     * 进货查询值对象封装
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InMainQueryModel extends InMainModel {
    
        //需要查询的最大时间
        private long inDate2;
    
        /**
         * 
         * @return---需要查询的最大时间值
         */
        public long getInDate2() {
            return inDate2;
        }
    
        /**
         * 
         * @param inDate2---设置需要查询的最大时间
         */
        public void setInDate2(long inDate2) {
            this.inDate2 = inDate2;
        }
    
    }
    

    进货明细查询值对象类:InDetailQueryModel

    package cn.hncu.bookStore.in.vo;
    
    /**
     * 进货明细查询值对象封装
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InDetailQueryModel extends InDetailModel {
    
        //需要查询的最大进货数量
        private int sumNum2;
        //需要查询的最大进货金额
        private double sumMoney2;
    
        /**
         * 
         * @return---返回需要查询的最大进货数量
         */
        public int getSumNum2() {
            return sumNum2;
        }
        /**
         * 
         * @param sumNum2---设置需要查询的最大进货数量
         */
        public void setSumNum2(int sumNum2) {
            this.sumNum2 = sumNum2;
        }
    
        /**
         * 
         * @return---返回需要查询的最大进货金额
         */
        public double getSumMoney2() {
            return sumMoney2;
        }
    
        /**
         * 
         * @param sumMoney2---设置需要查询的最大进货金额
         */
        public void setSumMoney2(double sumMoney2) {
            this.sumMoney2 = sumMoney2;
        }
    
    }
    

    进货模块的数据层:

    进货管理数据层接口:InMainDao

    package cn.hncu.bookStore.in.dao.dao;
    
    import java.util.List;
    
    import cn.hncu.bookStore.in.vo.InMainModel;
    import cn.hncu.bookStore.in.vo.InMainQueryModel;
    
    /**
     * 进货管理数据层接口
     * 
     * @author 陈浩翔
     * 
     * @version 1.0
     */
    public interface InMainDao {
    
        /**
         * 创建一个进货数据对象
         * @param inMain---需要创建的进货数据对象
         * @return---true 表示创建成功,false 表示创建失败
         */
        public boolean create(InMainModel inMain);
    
        /**
         * 删除一个进货数据对象
         * @param uuid---进货单的编号-唯一的
         * @return---true表示删除成功, false表示删除失败
         */
        public boolean delete(String uuid);
    
        /**
         * 修改一个进货数据的对象
         * @param inMain---需要修改的进货管理对象
         * @return---true表示修改成功,false表示修改失败
         */
        public boolean update(InMainModel inMain);
    
        /**
         * 根据进货单编号,得到进货对象的其他信息资料
         * @param uuid---进货单编号
         * @return---该对象的其他其他信息资料
         */
        public InMainModel getSingle(String uuid);
    
        /**
         * 
         * @return---所有的进货管理对象信息
         */
        public List<InMainModel> getAll();
    
        /**
         * 查找进货管理对象
         * @param imqm---查找条件!
         * @return---满足查找条件的所有INMainModel对象
         */
        public List<InMainModel> getbyCondition(InMainQueryModel imqm);
    }
    

    进货明细管理数据层接口:InDetailDao

    package cn.hncu.bookStore.in.dao.dao;
    
    import java.util.List;
    
    import cn.hncu.bookStore.in.vo.InDetailModel;
    import cn.hncu.bookStore.in.vo.InDetailQueryModel;
    
    /**
     * 进货明细管理数据层接口
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public interface InDetailDao {
        /**
         * 创建一个进货明细数据对象
         * @param inMain---需要创建的进货明细数据对象
         * @return---true 表示创建成功,false 表示创建失败
         */
        public boolean create(InDetailModel inDetail);
    
        /**
         * 删除一个进货明细数据对象
         * @param uuid---进货明细单的编号-唯一的
         * @return---true表示删除成功, false表示删除失败
         */
        public boolean delete(String uuid);
    
        /**
         * 修改一个进货明细数据的对象
         * @param inMain---需要修改的进货管理明细对象
         * @return---true表示修改成功,false表示修改失败
         */
        public boolean update(InDetailModel inDetail);
    
        /**
         * 根据进货明细单编号,得到进货明细对象的其他信息资料
         * @param uuid---进货明细单编号
         * @return---该对象的其他其他信息资料
         */
        public InDetailModel getSingle(String uuid);
    
        /**
         * 
         * @return---所有的进货明细管理对象信息
         */
        public List<InDetailModel> getAll();
    
        /**
         * 查找进货明细管理对象
         * @param imqm---查找条件!
         * @return---满足查找条件的所有InDetailModel对象
         */
        public List<InDetailModel> getbyCondition(InDetailQueryModel idqm);
    }
    

    进货明细的实现类:InDetailDaoSerImpl

    package cn.hncu.bookStore.in.dao.impl;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import cn.hncu.bookStore.in.dao.dao.InDetailDao;
    import cn.hncu.bookStore.in.dao.factory.InDetailDaoFactory;
    import cn.hncu.bookStore.in.vo.InDetailModel;
    import cn.hncu.bookStore.in.vo.InDetailQueryModel;
    import cn.hncu.bookStore.util.FileIoUtil;
    import cn.hncu.bookStore.util.StringComparison;
    
    /**
     * 进货明细的实现类
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InDetailDaoSerImpl implements InDetailDao{
        //进货明细数据的存储的文件名
        private final String FILE_NAME = "InDetail.txt";
    
        @Override
        public boolean create(InDetailModel inDetail) {
            List<InDetailModel> lists = FileIoUtil.readFormFile(FILE_NAME);
    
            for(InDetailModel model: lists){
                //已经存在这个Uuid,不能添加
                if(model.getUuid().equals(inDetail.getUuid())){
                    return false;
                }
            }
    
            lists.add(inDetail);
            FileIoUtil.write2file(lists, FILE_NAME);
            return true;
        }
    
        @Override
        public boolean delete(String uuid) {
            List<InDetailModel> list = FileIoUtil.readFormFile(FILE_NAME);
            for(InDetailModel model: list){
                //存在,就删除
                if(model.getUuid().equals(uuid)){
                    list.remove(model);
                    FileIoUtil.write2file(list, FILE_NAME);
                    return true;
                }
            }
            return false;
        }
    
        @Override
        public boolean update(InDetailModel inDetail) {
            List<InDetailModel> list  = FileIoUtil.readFormFile(FILE_NAME);
            for(int i=0;i<list.size();i++){
                //找到了,就修改
                if(list.get(i).getUuid().equals(inDetail.getUuid())){
                    list.set(i, inDetail);
                    FileIoUtil.write2file(list, FILE_NAME);
                    return true;
                }
            }
            return false;
        }
    
        @Override
        public InDetailModel getSingle(String uuid) {
            List<InDetailModel> list = FileIoUtil.readFormFile(FILE_NAME);
            for(InDetailModel model : list){
                //找到了,就返回
                if(model.getUuid().equals(uuid)){
                    return model;
                }
            }
            return null;
        }
    
        @Override
        public List<InDetailModel> getAll() {
            return FileIoUtil.readFormFile(FILE_NAME);
        }
    
        @Override
        public List<InDetailModel> getbyCondition(InDetailQueryModel idqm) {
            List<InDetailModel> lists = getAll();
            List<InDetailModel> resulits = new ArrayList<InDetailModel>();
            for(InDetailModel model:lists){
    
                if(StringComparison.stringComp(idqm.getUuid(), model.getUuid())==-1){
                    continue;
                }
    
                if(StringComparison.stringComp(idqm.getInId(), model.getInId())==-1){
                    continue;
                }
    
                if(StringComparison.stringComp(idqm.getBookId(), model.getBookId())==-1){
                    continue;
                }
    
                if(idqm.getSumNum()>0){
                    if(model.getSumNum()<idqm.getSumNum()){
                        continue;
                    }
                }
                if(idqm.getSumNum2()>0){
                    if(model.getSumNum()>idqm.getSumNum2()){
                        continue;
                    }
                }
    
                if(idqm.getSumMoney()>0){
                    if(model.getSumMoney()<idqm.getSumMoney()){
                        continue;
                    }
                }
                if(idqm.getSumMoney2()>0){
                    if(model.getSumMoney()>idqm.getSumMoney2()){
                        continue;
                    }
                }
    
                resulits.add(model);
            }
            return resulits;
        }
    
    }
    

    进货管理的实现类:InMainDaoSerImpl

    package cn.hncu.bookStore.in.dao.impl;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import cn.hncu.bookStore.in.dao.dao.InMainDao;
    import cn.hncu.bookStore.in.vo.InMainModel;
    import cn.hncu.bookStore.in.vo.InMainQueryModel;
    import cn.hncu.bookStore.util.FileIoUtil;
    import cn.hncu.bookStore.util.StringComparison;
    
    /**
     * 进货管理的实现类
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InMainDaoSerImpl implements InMainDao {
    
        private final String FILE_NAME = "InMain.txt";
        @Override
        public boolean create(InMainModel inMain) {
            List<InMainModel> list = FileIoUtil.readFormFile(FILE_NAME);
            for(InMainModel model:list){
                if(model.getUuid().equals(inMain.getUuid())){//存在,则不能添加
                    return false;
                }
            }
            list.add(inMain);
            FileIoUtil.write2file(list, FILE_NAME);
            return true;
        }
    
        @Override
        public boolean delete(String uuid) {
            List<InMainModel> list = FileIoUtil.readFormFile(FILE_NAME);
            for(InMainModel model:list){
                if(model.getUuid().equals(uuid)){//存在,则删除
                    list.remove(model);
                    FileIoUtil.write2file(list, FILE_NAME);
                    return true;
                }
            }
            return false;
        }
    
        @Override
        public boolean update(InMainModel inMain) {
            List<InMainModel> list = FileIoUtil.readFormFile(FILE_NAME);
            for(int i=0;i<list.size();i++){
                InMainModel model = list.get(i);
                if(model.getUuid().equals(inMain.getUuid())){//存在,则修改
                    list.set(i, inMain);
                    FileIoUtil.write2file(list, FILE_NAME);
                    return true;
                }
            }
            return false;
        }
    
        @Override
        public InMainModel getSingle(String uuid) {
            List<InMainModel> list = FileIoUtil.readFormFile(FILE_NAME);
            for(InMainModel model:list){
                if(model.getUuid().equals(uuid)){//存在,则返回
                    return model;
                }
            }
            return null;
        }
    
        @Override
        public List<InMainModel> getAll() {
            return FileIoUtil.readFormFile(FILE_NAME);
        }
    
        @Override
        public List<InMainModel> getbyCondition(InMainQueryModel imqm) {
            List<InMainModel> lists = FileIoUtil.readFormFile(FILE_NAME);
            List<InMainModel> results = new ArrayList<InMainModel>();
            for(InMainModel model : lists){
    
                if(StringComparison.stringComp(imqm.getUuid(), model.getUuid())==-1){
                    continue;
                }
    
                if(StringComparison.stringComp(imqm.getInUserId(), model.getInUserId())==-1){
                    continue;
                }
    
                if(imqm.getInDate()>0){
                    if(model.getInDate()<imqm.getInDate()){
                        continue;
                    }
                }
                if(imqm.getInDate2()>0){
                    if(model.getInDate()>imqm.getInDate2()){
                        continue;
                    }
                }
                results.add(model);
            }
            return results;
        }
    
    }
    

    new 一个进货明细的实现类:InDetailDaoFactory

    package cn.hncu.bookStore.in.dao.factory;
    
    import cn.hncu.bookStore.in.dao.dao.InDetailDao;
    import cn.hncu.bookStore.in.dao.impl.InDetailDaoSerImpl;
    
    /**
     * 工厂方法----new 一个进货明细的实现类
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InDetailDaoFactory {
    
        public static InDetailDao getInDetailDao(){
            return new InDetailDaoSerImpl();
        }
    }
    

    new 一个进货实现类:InMainDaoFactory

    package cn.hncu.bookStore.in.dao.factory;
    
    import cn.hncu.bookStore.in.dao.dao.InMainDao;
    import cn.hncu.bookStore.in.dao.impl.InMainDaoSerImpl;
    
    /**
     * 工厂方法---new 一个进货实现类
     * @author 陈浩翔
     * @version 1.0
     */
    public class InMainDaoFactory {
    
        public static InMainDao getInMainDao(){
            return new InMainDaoSerImpl();
        }
    }
    

    进货模块的逻辑层:

    逻辑层的接口:InMainEbi

    package cn.hncu.bookStore.in.business.ebi;
    
    import java.util.List;
    import java.util.Map;
    
    import cn.hncu.bookStore.in.vo.InDetailModel;
    import cn.hncu.bookStore.in.vo.InDetailQueryModel;
    import cn.hncu.bookStore.in.vo.InMainModel;
    import cn.hncu.bookStore.in.vo.InMainQueryModel;
    
    /**
     * 
     * @author 陈浩翔
     * @version 1.0
     */
    public interface InMainEbi {
    
        /**
         * 创建一个进货模块数据-
         * @param inMain---进货数据
         * @param inDetails---进货明细数据
         * @return---返回true表示创建成功,false表示创建失败
         */
        public abstract boolean create(InMainModel inMain,List<InDetailModel> inDetails);
    
        /**
         * 
         * @return---返回所有的进货模块(包括进货明细)的集合
         */
        public abstract Map<InMainModel, List<InDetailModel>> getAll();
    
        /**
         * 
         * @param imqm---进货管理需要查找的条件
         * @param idqm---进货明细需要查找的条件
         * @return---满足条件的所有进货数据的Map集合
         */
        public abstract Map<InMainModel, List<InDetailModel>> getByCondition(InMainQueryModel imqm,InDetailQueryModel idqm);
    
    }
    

    逻辑层接口的实现类:InMainEbo

    package cn.hncu.bookStore.in.business.ebo;
    
    import java.util.List;
    import java.util.Map;
    import java.util.TreeMap;
    
    import cn.hncu.bookStore.book.business.ebi.BookEbi;
    import cn.hncu.bookStore.book.business.factory.BookEbiFactory;
    import cn.hncu.bookStore.common.UuidModelConstance;
    import cn.hncu.bookStore.common.uuid.dao.dao.UuidDao;
    import cn.hncu.bookStore.common.uuid.dao.factory.UuidDaoFactory;
    import cn.hncu.bookStore.in.business.ebi.InMainEbi;
    import cn.hncu.bookStore.in.dao.dao.InDetailDao;
    import cn.hncu.bookStore.in.dao.dao.InMainDao;
    import cn.hncu.bookStore.in.dao.factory.InDetailDaoFactory;
    import cn.hncu.bookStore.in.dao.factory.InMainDaoFactory;
    import cn.hncu.bookStore.in.vo.InDetailModel;
    import cn.hncu.bookStore.in.vo.InDetailQueryModel;
    import cn.hncu.bookStore.in.vo.InMainModel;
    import cn.hncu.bookStore.in.vo.InMainQueryModel;
    
    public class InMainEbo implements InMainEbi{
        //注入dao
    
        InMainDao inMainDao = InMainDaoFactory.getInMainDao();
        InDetailDao inDetailDao = InDetailDaoFactory.getInDetailDao();
        UuidDao uuidDao = UuidDaoFactory.getUuidDao();
        BookEbi bookEbi = BookEbiFactory.getBookEbi();
    
        @Override
        public boolean create(InMainModel inMain, List<InDetailModel> inDetails) {
            //1存储inMain信息///
            //补全inMain中的数据
            //需要:inUuid,inDate,inUserUuid   已组织:inUserUuid
            //还缺(需补):inUuid,inDate
            String inUuid = uuidDao.getNextUuid(UuidModelConstance.IN_MAIN);
            inMain.setUuid(inUuid);
            inMain.setInDate(System.currentTimeMillis());
            inMainDao.create(inMain);
    
             //2存储inDetail信息///
            for(InDetailModel model:inDetails){
                //补全每一个inDetail中的数据
                //需要:inDetailUuid,inMainUuid,bookUuid,sumNum,sumMoney   已组织:bookUuid,sumNum
                //还缺(需补):inDetailUuid,inMainUuid,sumMoney
                model.setUuid(uuidDao.getNextUuid(UuidModelConstance.IN_DETAIL));
                model.setInId(inUuid);
    
                double sumMoney = model.getSumNum() * bookEbi.getSingle(model.getBookId()).getInPrice();
                model.setSumMoney(sumMoney);
                inDetailDao.create(model);
            }
            return true;
        }
    
        @Override
        public Map<InMainModel, List<InDetailModel>> getAll() {
            Map<InMainModel,List<InDetailModel>> map = new TreeMap<InMainModel, List<InDetailModel>>();
    
            List<InMainModel> inMains = inMainDao.getAll();
    
            for(InMainModel inMain: inMains ){
                //查询条件值对象的创建
                InDetailQueryModel idqm = new InDetailQueryModel();
                String inUuid = inMain.getUuid();
                idqm.setInId(inUuid);
    
                List<InDetailModel> details = inDetailDao.getbyCondition(idqm);
    
                map.put(inMain, details);
            }
    
            return map;
        }
    
        @Override
        public Map<InMainModel, List<InDetailModel>> getByCondition(
                InMainQueryModel imqm, InDetailQueryModel idqm) {
            // TODO Auto-generated method stub
            return null;
        }
    
    }
    

    具体实现类的工厂方法:InMainEbiFactory

    package cn.hncu.bookStore.in.business.factory;
    
    import cn.hncu.bookStore.in.business.ebi.InMainEbi;
    import cn.hncu.bookStore.in.business.ebo.InMainEbo;
    
    /**
     * 工厂方法
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InMainEbiFactory {
        public static InMainEbi getInMainEbi(){
            return new InMainEbo();
        }
    }
    

    进货模块的表现层:

    List主界面:InListPanel

    /*
     * InListPanel.java
     *
     * Created on __DATE__, __TIME__
     */
    
    package cn.hncu.bookStore.in.ui;
    
    import java.awt.event.ActionEvent;
    import java.util.List;
    import java.util.Map;
    
    import javax.swing.JFrame;
    import javax.swing.event.ListSelectionEvent;
    
    import cn.hncu.bookStore.in.business.factory.InMainEbiFactory;
    import cn.hncu.bookStore.in.vo.InDetailModel;
    import cn.hncu.bookStore.in.vo.InMainModel;
    
    /**
     * 
     * @author 陈浩翔
     *
     * @version 1.0
     */
    public class InListPanel extends javax.swing.JPanel {
    
        private JFrame mainFrame = null;
        private Map<InMainModel, List<InDetailModel>> map;
    
        /** Creates new form InListPanel */
        public InListPanel(JFrame mainFrame) {
            this.mainFrame = mainFrame;
            initComponents();
            map = InMainEbiFactory.getInMainEbi().getAll();
            myInitData();
        }
    
        private void myInitData() {
            jListInMain.setListData(map.keySet().toArray());
        }
    
        /**
         * This method is called from within the constructor to initialize the form.
         * WARNING: Do NOT modify this code. The content of this method is always
         * regenerated by the Form Editor.
         */
        //GEN-BEGIN:initComponents
        // <editor-fold defaultstate="collapsed" desc="Generated Code">
        private void initComponents() {
    
            jLabel1 = new javax.swing.JLabel();
            btnToAdd = new javax.swing.JButton();
            jScrollPane1 = new javax.swing.JScrollPane();
            jListInMain = new javax.swing.JList();
            jScrollPane2 = new javax.swing.JScrollPane();
            jListInDetail = new javax.swing.JList();
            jLabel2 = new javax.swing.JLabel();
    
            setMinimumSize(new java.awt.Dimension(800, 600));
            setLayout(null);
    
            jLabel1.setFont(new java.awt.Font("微软雅黑", 1, 48));
            jLabel1.setForeground(new java.awt.Color(204, 0, 0));
            jLabel1.setText("\u8fdb\u8d27\u5217\u8868");
            add(jLabel1);
            jLabel1.setBounds(260, 0, 230, 80);
    
            btnToAdd.setFont(new java.awt.Font("Dialog", 1, 24));
            btnToAdd.setForeground(new java.awt.Color(0, 204, 204));
            btnToAdd.setText("\u8f6c\u5230\u6dfb\u52a0");
            btnToAdd.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    btnToAddActionPerformed(evt);
                }
            });
            add(btnToAdd);
            btnToAdd.setBounds(100, 460, 160, 70);
    
            jListInMain.setFont(new java.awt.Font("宋体", 1, 18));
            jListInMain.setForeground(new java.awt.Color(102, 102, 0));
            jListInMain.setModel(new javax.swing.AbstractListModel() {
                String[] strings = { "" };
    
                public int getSize() {
                    return strings.length;
                }
    
                public Object getElementAt(int i) {
                    return strings[i];
                }
            });
            jListInMain
                    .addListSelectionListener(new javax.swing.event.ListSelectionListener() {
                        public void valueChanged(
                                javax.swing.event.ListSelectionEvent evt) {
                            jListInMainValueChanged(evt);
                        }
                    });
            jScrollPane1.setViewportView(jListInMain);
    
            add(jScrollPane1);
            jScrollPane1.setBounds(50, 110, 320, 300);
    
            jListInDetail.setFont(new java.awt.Font("宋体", 1, 18));
            jListInDetail.setForeground(new java.awt.Color(102, 102, 0));
            jListInDetail.setModel(new javax.swing.AbstractListModel() {
                String[] strings = { "" };
    
                public int getSize() {
                    return strings.length;
                }
    
                public Object getElementAt(int i) {
                    return strings[i];
                }
            });
            jScrollPane2.setViewportView(jListInDetail);
    
            add(jScrollPane2);
            jScrollPane2.setBounds(400, 110, 370, 300);
    
            jLabel2.setFont(new java.awt.Font("Dialog", 1, 14));
            jLabel2.setForeground(new java.awt.Color(51, 0, 204));
            jLabel2.setText("\u8fdb\u8d27\u660e\u7ec6\u5217\u8868\uff1a");
            add(jLabel2);
            jLabel2.setBounds(480, 80, 110, 30);
        }// </editor-fold>
        //GEN-END:initComponents
    
        protected void jListInMainValueChanged(ListSelectionEvent evt) {
            InMainModel inMain = (InMainModel) jListInMain.getSelectedValue();
            List<InDetailModel> details = map.get(inMain);
            //System.out.println(map);
            //System.out.println(inMain);
            jListInDetail.setListData(details.toArray());
        }
    
        protected void btnToAddActionPerformed(ActionEvent evt) {
            mainFrame.setContentPane(new InAddPanel(mainFrame));
            mainFrame.validate();
        }
    
        //GEN-BEGIN:variables
        // Variables declaration - do not modify
        private javax.swing.JButton btnToAdd;
        private javax.swing.JLabel jLabel1;
        private javax.swing.JLabel jLabel2;
        private javax.swing.JList jListInDetail;
        private javax.swing.JList jListInMain;
        private javax.swing.JScrollPane jScrollPane1;
        private javax.swing.JScrollPane jScrollPane2;
        // End of variables declaration//GEN-END:variables
    
    }

    添加进货界面类:InAddPanel

    /*
     * InAddPanel.java
     *
     * Created on __DATE__, __TIME__
     */
    
    package cn.hncu.bookStore.in.ui;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.swing.JFrame;
    import javax.swing.JOptionPane;
    import javax.swing.plaf.ListUI;
    
    import cn.hncu.bookStore.book.business.ebi.BookEbi;
    import cn.hncu.bookStore.book.business.factory.BookEbiFactory;
    import cn.hncu.bookStore.book.vo.BookModel;
    import cn.hncu.bookStore.in.business.factory.InMainEbiFactory;
    import cn.hncu.bookStore.in.vo.InDetailModel;
    import cn.hncu.bookStore.in.vo.InMainModel;
    import cn.hncu.bookStore.user.business.factory.UserEbiFactory;
    import cn.hncu.bookStore.user.vo.UserModel;
    
    /**
     * 
     * @author 陈浩翔
     * 
     * @version 1.0
     */
    public class InAddPanel extends javax.swing.JPanel {
    
        private JFrame mainFrame = null;
    
        private List<InDetailModel> details = new ArrayList<InDetailModel>();
    
        /**
         * Creates new form InAddPanel
         * 
         * @param mainFrame
         */
        public InAddPanel(JFrame mainFrame) {
            this.mainFrame = mainFrame;
            initComponents();
            jtxArea.setEditable(false);
            myInitData();
        }
    
        private void myInitData() {
            // 1完成combBook组合框中数据的初始化
            // 访问book模块,把其中的图书获取出来,并把书名填写到combBook组合框中
            // 我们是UI层,只能访问(对方的)逻辑层
            List<BookModel> books = BookEbiFactory.getBookEbi().getAll();
            for (BookModel book : books) {
                combBook.addItem(book.getUuid() + "," + book.getName());
                // 若想更精确地控制每本书显示的信息,可以修改Book的toString()方法
            }
    
            // 2完成combUser组合框中数据的初始化
            /*
             * 模块之间的交接太深(细节太多了,功能可实现,但从开发技术或设计思想来讲不可取) 
              List<UserModel> users =UserEbiFactory.getUserEbi().getAll(); for(UserModel user: users){
              if(user.getType()==UserTypeEnum.IN.getType()){
              combUser.addItem(user.getName()); } }
             */
    
            List<UserModel> users = UserEbiFactory.getUserEbi().getAllIn();
            for (UserModel user : users) {
                combUser.addItem(user.getName());
            }
    
        }
    
        /**
         * This method is called from within the constructor to initialize the form.
         * WARNING: Do NOT modify this code. The content of this method is always
         * regenerated by the Form Editor.
         */
        //GEN-BEGIN:initComponents
        // <editor-fold defaultstate="collapsed" desc="Generated Code">
        private void initComponents() {
    
            jLabel1 = new javax.swing.JLabel();
            jLabel4 = new javax.swing.JLabel();
            tfdInNum = new javax.swing.JTextField();
            jLabel5 = new javax.swing.JLabel();
            jLabel6 = new javax.swing.JLabel();
            combUser = new javax.swing.JComboBox();
            combBook = new javax.swing.JComboBox();
            jScrollPane1 = new javax.swing.JScrollPane();
            jListDetails = new javax.swing.JList();
            jLabel7 = new javax.swing.JLabel();
            btnAddDetail = new javax.swing.JButton();
            jScrollPane2 = new javax.swing.JScrollPane();
            jtxArea = new javax.swing.JTextArea();
            btnBack = new javax.swing.JButton();
            btnMainAdd = new javax.swing.JButton();
    
            setMinimumSize(new java.awt.Dimension(800, 600));
            setLayout(null);
    
            jLabel1.setFont(new java.awt.Font("微软雅黑", 1, 48));
            jLabel1.setForeground(new java.awt.Color(204, 0, 0));
            jLabel1.setText("\u6dfb\u52a0\u8fdb\u8d27");
            add(jLabel1);
            jLabel1.setBounds(270, 0, 210, 60);
    
            jLabel4.setFont(new java.awt.Font("微软雅黑", 0, 18));
            jLabel4.setText("\u56fe\u4e66\u540d\u79f0:");
            add(jLabel4);
            jLabel4.setBounds(50, 100, 90, 30);
    
            tfdInNum.setFont(new java.awt.Font("Dialog", 1, 18));
            tfdInNum.setAutoscrolls(false);
            add(tfdInNum);
            tfdInNum.setBounds(140, 170, 150, 30);
    
            jLabel5.setFont(new java.awt.Font("微软雅黑", 0, 18));
            jLabel5.setForeground(new java.awt.Color(255, 51, 51));
            jLabel5.setText("  \u8fdb\u8d27\u660e\u7ec6\u5217\u8868\uff1a");
            add(jLabel5);
            jLabel5.setBounds(10, 220, 140, 30);
    
            jLabel6.setFont(new java.awt.Font("微软雅黑", 0, 18));
            jLabel6.setText("\u8fdb\u8d27\u4eba\uff1a");
            add(jLabel6);
            jLabel6.setBounds(480, 420, 80, 30);
    
            combUser.setFont(new java.awt.Font("Dialog", 1, 14));
            combUser.setModel(new javax.swing.DefaultComboBoxModel(
                    new String[] { "请选择..." }));
            add(combUser);
            combUser.setBounds(550, 420, 150, 30);
    
            combBook.setFont(new java.awt.Font("Dialog", 1, 14));
            combBook.setModel(new javax.swing.DefaultComboBoxModel(
                    new String[] { "请选择..." }));
            add(combBook);
            combBook.setBounds(140, 100, 150, 30);
    
            jListDetails.setFont(new java.awt.Font("Dialog", 1, 14));
            jListDetails.setForeground(new java.awt.Color(255, 51, 51));
            jListDetails.setModel(new javax.swing.AbstractListModel() {
                String[] strings = { "" };
    
                public int getSize() {
                    return strings.length;
                }
    
                public Object getElementAt(int i) {
                    return strings[i];
                }
            });
            jScrollPane1.setViewportView(jListDetails);
    
            add(jScrollPane1);
            jScrollPane1.setBounds(20, 262, 410, 210);
    
            jLabel7.setFont(new java.awt.Font("微软雅黑", 0, 18));
            jLabel7.setText("\u8fdb\u8d27\u6570\u91cf\uff1a");
            add(jLabel7);
            jLabel7.setBounds(50, 170, 90, 30);
    
            btnAddDetail.setFont(new java.awt.Font("Dialog", 1, 14));
            btnAddDetail.setForeground(new java.awt.Color(0, 204, 204));
            btnAddDetail.setText("\u6dfb\u52a0\u5230\u660e\u7ec6");
            btnAddDetail.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    btnAddDetailActionPerformed(evt);
                }
            });
            add(btnAddDetail);
            btnAddDetail.setBounds(480, 280, 120, 60);
    
            jtxArea.setColumns(20);
            jtxArea.setFont(new java.awt.Font("Dialog", 1, 14));
            jtxArea.setForeground(new java.awt.Color(0, 153, 51));
            jtxArea.setRows(5);
            jtxArea.setText("\u64cd\u4f5c\u8bf4\u660e\uff1a\n1\u3001\u9009\u62e9\u56fe\u4e66\u540d\u79f0\uff0c\u586b\u5199\u8fdb\u8d27\u6570\u91cf\u3002\n2\u3001\u518d\u70b9\u51fb\u4e0b\u65b9\u7684\u6dfb\u52a0\u5230\u660e\u7ec6\u6309\u94ae\uff0c\n      \u6dfb\u52a0\u6570\u636e\u5230\u8fdb\u8d27\u660e\u7ec6\u5217\u8868\uff0c\n      \u5982\u679c\u8fd8\u6709\u56fe\u4e66\uff0c\u91cd\u590d\u524d\u9762\u7684\u64cd\u4f5c\u3002\n3\u3001\u6700\u540e\u70b9\u51fb\u6dfb\u52a0\u6309\u94ae\u3002");
            jScrollPane2.setViewportView(jtxArea);
    
            add(jScrollPane2);
            jScrollPane2.setBounds(440, 100, 340, 140);
    
            btnBack.setFont(new java.awt.Font("Dialog", 1, 24));
            btnBack.setForeground(new java.awt.Color(0, 204, 204));
            btnBack.setText("\u8fd4\u56de");
            btnBack.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    btnBackActionPerformed(evt);
                }
            });
            add(btnBack);
            btnBack.setBounds(530, 510, 120, 60);
    
            btnMainAdd.setFont(new java.awt.Font("Dialog", 1, 24));
            btnMainAdd.setForeground(new java.awt.Color(0, 204, 204));
            btnMainAdd.setText("\u6dfb\u52a0");
            btnMainAdd.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    btnMainAddActionPerformed(evt);
                }
            });
            add(btnMainAdd);
            btnMainAdd.setBounds(120, 510, 120, 60);
        }// </editor-fold>
        //GEN-END:initComponents
    
        private void btnMainAddActionPerformed(java.awt.event.ActionEvent evt) {
            //1收集参数 
            String inUserName = combUser.getSelectedItem().toString();
            if(combUser.getSelectedIndex()==0){
                JOptionPane.showMessageDialog(mainFrame, "请选择用户类型!");
                return ;
            }
            //System.out.println(inUserName);
    
            String inUserUuid = UserEbiFactory.getUserEbi().getUserByName(inUserName).getUuid();
    
            //2组织参数
            InMainModel inMain = new InMainModel();
            inMain.setInUserId(inUserUuid);
            inMain.setInUserName(inUserName);//设置:专为外键显示而补的数据
    
            //3调用逻辑层
            //System.out.println(inMain);
            //System.out.println(details);
            InMainEbiFactory.getInMainEbi().create(inMain, details);
    
            //4返回到结果页面
            mainFrame.setContentPane( new InListPanel(mainFrame));
            mainFrame.validate();
    
        }
    
        private void btnAddDetailActionPerformed(java.awt.event.ActionEvent evt) {
            //1收集参数
            String str = combBook.getSelectedItem().toString();
    
            //防范未选择图书
            if (combBook.getSelectedIndex() == 0) {
                JOptionPane.showMessageDialog(mainFrame, "请选择图书!");
                return;
            }
            String strs[] = str.split(",");
            String bookUuid = strs[0];
            String bookName = strs[1];
            //      System.out.println(bookName);
            //      System.out.println(bookUuid);
    
            int sumNum = 0;
            try {
                sumNum = Integer.parseInt(tfdInNum.getText());
                if (sumNum < 0) {
                    throw new NumberFormatException();
                }
            } catch (NumberFormatException e) {
                JOptionPane.showMessageDialog(mainFrame, "进货数量格式错误!");
                return;
            }
    
            //2组织
            InDetailModel detail = new InDetailModel();
            detail.setBookId(bookUuid);
            detail.setSumNum(sumNum);
            //为显示给用户看,补的数据
            detail.setBookName(bookName);
    
            //3添加到List当中---真正的明细数据是details,界面上的只是回显信息
            details.add(detail);
            echoDetails();
        }
    
        private void echoDetails() {
            String echoStrs[] = new String[details.size()];
    
            for (int i = 0; i < details.size(); i++) {
                InDetailModel detail = details.get(i);
                echoStrs[i] = "《" + detail.getBookName() + "》,"
                        + detail.getSumNum() + "本";
            }
            jListDetails.setListData(echoStrs);
        }
    
        private void btnBackActionPerformed(java.awt.event.ActionEvent evt) {
            back();
        }
    
        private void back() {
            mainFrame.setContentPane(new InListPanel(mainFrame));
            mainFrame.validate();
        }
    
        //GEN-BEGIN:variables
        // Variables declaration - do not modify
        private javax.swing.JButton btnAddDetail;
        private javax.swing.JButton btnBack;
        private javax.swing.JButton btnMainAdd;
        private javax.swing.JComboBox combBook;
        private javax.swing.JComboBox combUser;
        private javax.swing.JLabel jLabel1;
        private javax.swing.JLabel jLabel4;
        private javax.swing.JLabel jLabel5;
        private javax.swing.JLabel jLabel6;
        private javax.swing.JLabel jLabel7;
        private javax.swing.JList jListDetails;
        private javax.swing.JScrollPane jScrollPane1;
        private javax.swing.JScrollPane jScrollPane2;
        private javax.swing.JTextArea jtxArea;
        private javax.swing.JTextField tfdInNum;
        // End of variables declaration//GEN-END:variables
    
    }

    好了,这个模块也算是完成了一半了,接下来的就是进货的查询界面没写了。
    还有list界面的那个显示问题。
    下一个系列会解决的!

    展开全文
  • CSS模块化() 模块化设计

    千次阅读 2014-03-25 10:49:54
    6. 模块化设计 6.1 样式的作用域──页面重构中的模块化设计(一) 模块化设计我已经提过很多了,都是跟模块化相关的,不过之前一直没有讲到具体实现方面的内容,只是一些思维。这次重点讲一下实现方面的内容,权...

    6. 模块化设计

    6.1 样式的作用域──页面重构中的模块化设计(一)

    模块化设计我已经提过很多了,都是跟模块化相关的,不过之前一直没有讲到具体实现方面的内容,只是一些思维。这次重点讲一下实现方面的内容,权当到目前为止我对模块化的一些总结整理。

    要做好模块化,我觉得理解好样式的作用域是很重要的。写过程序的同学应该都知道,变量是有作用域的(不知道的同学自己去问谷歌,这里就不作解释了),样式的定义也同样存在着作用域的问题,即定义的作 用范围,很容易就能理解,如下面的p的作用域:

     CODE:

    /*作用域:全局*/ p{text-indent:2em;}

     

     CODE:

    /*作用域:.demo这个类中*/ .demo p{color:#000000;}

        样式选择器的优先级是学习样式的基础知识,一起简单回顾下:

    ● 标签的权值为0,0,0,1

    ● 类的权值为0,0,1,0

    ● 属性选择的权值为0,0,1,1

    ● ID的权值为0,1,0,0

    ● important的权值为最高1,0,0,0

    使用的规则也很简单,就是 选择器的权值加到一起,大的优先;如果权值相同,后定义的优先 。虽然很简单,但如果书写的时候没有注意,很容易就会导致CSS的重复定义,代码冗余。从上面我们可以得出两个关键的因素:

    1权值的大小跟选择器的类型和数量有关

    2样式的优先级跟样式的定义顺序有关

    了解样式的权值后有什么作用呢?比如可以这样用:举一个最简单的例子

    CODE:

    body{color:#555555;}.demo{color:#000000;}

     

    CODE:

    <p>这里的文字颜色受全局定义的影响</p>

    <div class="demo"><p>这里的文字颜色受类demo定义的影响</p></div>

    <p class="demo">这里的文字颜色受类demo定义的影响</p>

    知道了样式的权值,你就知道上面例子的表现是怎样的了。进一步的应用,就是模块化了。

    再来说说作用域,相信大家很容易就会想到全局公共这些词,关注过模块化的同学应该都知道,网上说得最多的一种模块化,就是像 headerfooter这样的以大区域划分。在去年web标准交流会(页面重构合理化讨论)上,克军提出了样式的三层架构”——公共规则层、公共模 块层、项目层。这些都有它们适用的范围,而且最大的优点是容易理解和应用。这里也不再作重诉了,上面已经讲过。

    我在这一块的划分上,有点类似克军的样式的三层架构,有一点小的差别,我是以作用域来分的: 公共级(全局)、栏目级 (局部公共)、页面级 。如何划分这个作用域呢?很简单,全局的global就是公共级的;只在栏目中用到的局部global是属于栏目级的;只影响单个页面的就是属于页面 级的了。

    最后几点要特别注意的:

    除了标签选择器之外,哪些类是使用于公共级、栏目级中的,如

     CODE:

    .tx_hit{color:#FF0000 !important;}

    的适用范围是公共级的,应该放于全局的定义中。但,如果它只影响于某个栏目,那么就应该把它放于栏目级的作用域中。

    ● 标签选择器一般属于栏目定义,有时会用于公共级作用域中,除了最基础的reset之外,应尽可能少使用在公共级定义中

    ● 可继承的属性定义使用时须注意影响的范围,特别是在标签选择器中使用时

    ● 同类选择器无加权

    接下来的内容就是以这个为基础的,希望大家能理解样式的作用域,对于后继内容的理解会很有帮助。

    6.2 栏目级作用域──页面重构中的模块化设计(二)

    在《 样式的作用域── 页面重构中的模块化设计(一)》中,我将样式的作用域分为了三个部分:公共级(全局)、栏目级(局部公共)、页面级。公共级(全局)容易理解,即影响站点中所有页面。简单解释下栏目级(局部公共)和页面级:

    页面级

    可分为两种情况:在多个页面间,页面级作用域指针对某一单独的页面定义;在同一个页面中,页面级作用指针对某 一标签的定义。它将决定最终的页面效果。

    栏目级(局部公共)

    介于全局与单个页面之间的一个作用 域,影响一个栏目(或某区域)。通常以某一类选择符做为开始,以包含选择符的方式将样式定义限定在某一区域中。

     CODE:

    /* 只影响demo这个区域 */

    .demo a{...}

    .demo p{...}

    .demo .title{...}

    需要消化下的内容,决定一个样式定义是属于哪个作用域的因素有以下两点:

    样式定义所在样式文件中的位置。(同样的一个定义,放在不同的位置,所影响的范围会有所不同。)

    HTML中绑定demo这个类的标签位置。(同样一个类,绑定在body标签和绑定在页面中某个标签上,所影响的范围也会不同。)

    在一个站点中,可能会分为几个不同的栏目,同一个栏目中,一般风格会保持一致。而不同的栏目间,相似的风格则不一定会相同。即使是全站通用的模 块,如翻页,也可能会因为栏目的不同而会有一些差异,比如链接的颜色等等。使用栏目级的样式定义,能很好的减少代码的冗余,提高模块的复用性。

    另外需要在思维上注意的一点,以作用域划分,并不意味着有着对应的文件,可能有些同学会习惯的以为一个作用域就应该对应着一个文件。比如一个小的 栏目,可能只有两三个页面,这时我们就不一定需要再把栏目级的定义单独出来一个文件,而是与页面级的定义一起放在一个文件里,像这样:

    CODE:

    /* S 栏目级定义 */

    .class{...}

    /* E 栏目级定义 */

    /* S 页面级定义 */

    .page{...}

    /* E 页面级定义 */

     

    6.3 继承──页面重构中的模块化设计(三)

    前面我们了解了 样式的作用域的分类  栏目级作用域。在权值中,还有一个很重要的因素,需要做下补充,起因是这样的,有个同学在CSS森林群里问了个问题:根据样式权值两个关键的因素

    权值的大小跟选择器的类型和数量有关

    样式的优先级跟样式的定义顺序有关

    可以知道,如果10个标签选择器的权值应该比一个类选择的权值高,像这样:

     CODE:

    div div div div div div div div div div div{color:blue;}

    .c10{color:red;}

     

    CODE:

    <div class="c1">

      <div class="c2">

        <div class="c3">

          <div class="c4">

            <div class="c5">

              <div class="c6">

                <div class="c7">

                  <div class="c8">

                    <div class="c9">

                      <div class="c10">

                         <div>这段文字是什么颜色?</div>

                      </div>

                    </div>

                  </div>

                </div>

              </div>

            </div>

          </div>

        </div>

      </div>

    </div>

    先别急着看 答案 ,分析下。意料之中?如果 这样 呢?

    CODE

    div{color:blue;}

    .c10{color:red;}

    是不是跟想的不太一样?难道前面所说的权值是有问题的?前面讲的权值并没有问题,不过漏了一个重要的规则: 继承的权值小于 0,0,0,1

    样式的继承

    指被包在内部的标签将拥有外部标签的样式性质。

    继承最大的意义在于可以减少重复的定义,比如要定义整个页面的文本颜色,只需要定义bodycolor样式,body里的所有标签都会继承 bodycolor定义。是不是很方便?方便是相对的,当你想要为body内部分标签定义另一种文本颜色时,继承也许会成为增加重复定义、降低性能的祸 首。

    并不是所有的样式定义都具有继承的性质,整理了一下常用有继承性的定义, 这些定义在使用的时候要比较注意。

    简单分析下上面的例子,最后一部分的代码:

     CODE

    <div class="c10">

        <div>这段文字是什么颜色?</div>

    </div>

     

    当定义了c10后,根据权值,类定义的权值是0,0,1,0,应该是比div这个定义0,0,0,1要高的,但由于div是直接定义到标签上的, 比起从c10的定义中继承来的定义权值更高。稍微改下就清楚了:

    CODE:

    <div class="c1">

      <div class="c2">

        <div class="c3">

          <div class="c4">

            <div class="c5">

              <div class="c6">

                <div class="c7">

                  <div class="c8">

                    <div class="c9">

                      <div class="c10">

                         <p>这段文字是什么颜色?</p>

                         <div>这段文字是什么颜色?</div>

                      </div>

                    </div>

                  </div>

                </div>

              </div>

            </div>

          </div>

        </div>

      </div>

    </div>

     

     修改后的例子 可以看到,p标签继承了c10的定义,显示为红色。因此,在使用标签选择器的时候,应特别注意它的作用域,个人的建议是,除了最基本的reset之外,在 公共作用域中最好不要使用标签选择器,在栏目级作用域中也应尽可能的少用。

    常用有继承性的样式定义:

    ● text-indent

    ● text-align

    ● layout-flow

    ● writing-mode

    ● line-break

    ● white-space

    ● word-wrap

    ● list-style

    ● list-style-image

    ● list-style-position

    ● list-style-type

    ● font

    ● font-style

    ● font-variant

    ● font-weight

    ● font-size

    ● line-height

    ● font-family

    ● color

    ● text-transform

    ● letter-spacing

    ● word-spacing

    6.4 模块化的核心思想──页面重构中的模块化设计(四)

    有不少同学觉得前面的内容过于简单了,对于 样式的作用域的分类  栏目级作用域  继承等内容的确十分基础,不过基础还是很重要的。下面就一起进入这个系列真正的主题——“模块化吧。

    早在Qzone4.0的页面架构中已经在项目中开始摸索提高代码复用的方法,只不过当时并没有很清晰的认识到模块化这个思想。从去年的《 从宜家的家具设计 讲模块化》开始,模块化成了我主要的一个学习方向。借着无数的提问、思考、讨论,渐渐形成了一个比较清晰的、较为完整的方案。后面的内容,更多的是出于我在实际项 目中总结出来的方法,虽然已经尽可能为出现的问题提供了解决方法,不过还是少不了会有些我没遇到过或没考虑到的,欢迎各位指出。

    首先来了解下页面重构中模块化的核心思想: HTMLCSS通过一定的规则进行分类、组合,以达到特定HTMLCSS在特 定范围内最大程度的复用。 有三个关键词: 规则  特定范围  最大程度的复用 。怎么理解呢?

    规则

    编写模块时需要遵循的规范

    特定范围

    模块可使用的范围。与样式的作用域有关,大部分模块的使用范围仅仅是某一个栏目或站点。

    最大程度的复用

    做最少的修改即可重复使用。很多同学都把复用理解成不用修改的直接使用,但在页面 制作中,由于实际的项目环境,基本是不可能做到一个模块走天下的。不同的栏目会有不同的需求,大家应该都多少有所体会,我就不多讲了。

    从实际出发,才能最终服务于实际。我们知道一个HTML标签可以绑定多个样式,所以我们可以这样去定义一个模块:

    CODE:

    <div class="class-a class-b class-c">

        ...

    </div>

    不少同学已经知道这个方法了,而且还很形像的称之为拼样式。这样的定义很容易引出其它的问题,比如样式类的个数多少个适合?样式类如何命名? 等等。下面讲下我的方法,从前面我们学到的样式作用域及模块化的核心思想,我们可以把样式进行一个分类,像这样:

     CODE:

    .mode-a{/* 定义一个模块 */}

    .type-a{/* 模块中的差异化定义 */}

    .mode-name{/* 针对单个模块的个性化定义 */}

     

    CODE:

    <div class="mode-a type-a mode-name">

        ...

    </div>

    上面的“mode-a”,我称它叫为基类“type-a”扩展类“mode-name”模块名,作用分别是:

    基类

    (基础样式)模块的基础表现。包含了模块中大部分的状态。

    扩展类

    (扩展样式)用于对使用基类的模块进行小范围的修改

    模块名

    模块在某一作用域中的唯一名称。

    这里有一个 简单的例子 可以帮助理解。

    也有同学主张用ID去表示模块名,我认为这种方式扩展性比较差,而且很容易与开发的ID冲突,不过也不失为一个方法。

    6.5 基类、扩展类──页面重构中的模块化设计(五)

    基类  扩展类 是这个系列的主要内容,上一篇《 模块化的核心思想──页面重构中的模块 化设计(四)》中只是简单提了一下,我们再深入的来了解下它们。

    一般所使用的模块化的方法,就是以某一个类做为定义的开始,比如:

     CODE:

    /* S 图片列表 */

    .pic_lists li,

    .pic_lists li img{float:left;width:122px;height:122px;margin-bottom:8px;}

    .pic_lists li{list-style:none;margin:0 0 0 6px;text-align:center;}

    .pic_lists li .pic{display:block;border:1px solid #476081;}

    /* E 图片列表 */

    /* S mtv列表 */

    .mtv_lists{width:930px;height:130px;}

    .mtv_lists li,

    .mtv_lists li img{float:left;width:120px;margin-bottom:8px;}

    .mtv_lists li{list-style:none;margin:0 10px 0 0;text-align:center;}

    .mtv_lists li img{height:90px;border:1px solid #476081;}

    .mtv_lists li .pic{display:block;width:120px;height:90px;margin-bottom:8px;}

    /* E mtv列表 */

     

    这个例子: 两个列表模块 。这种方式是比较常见的,可以很好的将一个模块独立出来。如果使用新学习到的方法来写这两个列表模块,应该是怎样?

    基类(基础样式)模块的基础表现。包含了模块中大部分的状态。也就是说,当出现多个类似的模块时,基类包含了这些模块的大部分的效果(或者理解为公共的部分),在基类的基础上,我们可以通过添加很少的代码 ——扩展类,来达到所需要要效果。像这样:

    CODE:

    /* S 列表 基类 */

    .mode_lists li,

    .mode_lists li img{float:left;width:122px;margin-bottom:8px;}

    .mode_lists li{list-style:none;margin:0 10px 18px 0;text-align:center;}

    .mode_lists li img{border:1px solid #476081;}

    /* E 列表 基类 */

    /* S 图片列表 */

    .pic_lists li,

    .pic_lists li img{height:122px;}

    .pic_lists li{margin:0 0 8px 6px;}

    .pic_lists li .pic{display:block;border:1px solid #476081;}

    /* E 图片列表 */

    /* S mtv列表 */

    .mtv_lists{width:930px;height:130px;}

    .mtv_lists li,

    .mtv_lists li img{width:120px;height:90px;}

    .mtv_lists li .pic{display:block;margin-bottom:8px;}

    /* E mtv列表 */

     

    可能你会觉得这样的样式不就多写了,还得把原先的模块类变成两个。的确不是所有的模块都值得这样去做,于是我们可以得到一种偷懒的作法,把其 中一个模块直接变成基类。对于经常会被使用的模块,像图片列表、播放列表等,这种写法在代码的复用和效率会有一定的提高。一般情况下只需要做下简单的修改 即可应用,来看一个复杂些的例子:

    一个带头像的消息列表(A

     

    看看这两个图,在脑中先想想如果是你,你要怎么实现。……5分钟过去了……差不多有方案了,按上面的思路,基类是包含了大部分的效果的,也就是说 基类应该能满足大部分效果的需要,两个模块间差异的地方,可以通过扩展类来完成。当然前提是这两个模块有能找到类似的点,能够形成基类。

    在这两个模块中,我们不难看出,A模块和B模块在信息的部分是很类似的,虽然B模块的列表不需要A模块的评论部分,但这并不影响B模块的表现。所 以我们可以把这两个模块看成的类似模块。另个,以哪个为基类呢?从满足大部分效果这个要求来看,很明显A模块做为基类是要比B模块做为基类更合适的,如果 用B模块做基类,那么需要写更多的扩展类来满足A的需要。另外还有一个重要的点,之所以选择A模块为基类,是因为A在栏目中被更多的页面使用。

    OK,来看看A模块怎么实现(样式部分):

     CODE:

    /* S 消息 基类 */

    .mode_message{position:relative;padding:8px 3px 8px 48px;

    border-bottom:1px solid #DAECF6;_zoom:1;line-height:1.3;}

    .mode_message .user_info{position:absolute;left:3px;top:10px;}

    .mode_message .user_info .pic img{width:35px;height:35px;}

    .mode_message .mode_message_cont{color:#797979;

    word-break:normal;word-wrap:break-word;}

    .mode_message .mode_message_cont .info{display:block;zoom:1;}

    .mode_message .mode_message_cont .info .music_name{color:#22639B;}

    .mode_message .mode_message_cont .info .op_music{display:none;}

    .mode_message .mode_message_cont .info:hover .op_music,

    .mode_message .mode_message_cont .info.hover .op_music{display:block;position:absolute;right:5px;top:7px;

    background-color:#FFFFFF;}

    .mode_message .msg{padding:2px 0;word-break:normal;word-wrap:break-word;}

    .mode_message .mode_message_cont .op{margin-bottom:3px;}

    .mode_message .time{display:inline-block;*display:inline;*zoom:1;font-size:10px;}

    .mode_message .msg .p_zt_l,.mode_message .msg .p_zt_r{display:inline-block;*display:inline;*zoom:1;

    width:13px;height:8px;background:url(img/_g_other.png) no-repeat -17px -17px;

    vertical-align:text-middle;*vertical-align:middle;}

    .mode_message .msg .p_zt_r{background-position:0 -28px;}

    .mode_message .write_back .cont{margin-bottom:2px;padding:5px;background-color:#EAF6FA;_zoom:1;}

    .mode_message .write_back .cont .cont{border-left:1px solid #ABCFE1;}

    .mode_message .write_back .cont .zt{*overflow:hidden;}

    .mode_message .write_back .cont .zt2{*padding-right:6px;}

    .mode_message .write_back .cont .zt textarea{width:100%;height:40px;padding:0 2px;

    border:1px solid #D1E1EC;line-height:20px;color:#4F4F4F;}

    .mode_message .write_back .cont .zt .normal textarea{height:23px;color:#B1B4B8;}

    .mode_message .write_back .cont .zt .normal .op{display:none;}

    .mode_message .write_back .cont .op{margin:5px 0 0;}

    .mode_message .write_back .cont .op .bt_v2{padding:0 2px;vertical-align:middle;}

    .mode_message .write_back .cont .zt{width:98.5%;*width:99.9%}

    .mode_message:nth-last-child(1){border-bottom:none;}

    /* E 消息 基类 */

     

    别忘了提示条,虽然是用于模块中,但它应该是可以被更广泛使用的模块,因此我把它单独提了出来:

    CODE:

    /* S 提示条 基类 */

    .mode_hint{position:relative;margin:3px 0;padding:5px;

    background-color:#FFFEAB;color:#000000;_zoom:1;}

    .mode_hint .op{position:absolute;right:8px;top:5px;}

    .mode_hint .op a{color:#000000;}

    /* E 提示条 基类 */

    还有像按钮、全局定义这些内容,就不列出了。完整的可以看: 基类、扩展类实例 。例子中可以看到,扩展类的定义很少,只是一些简单的定义,像B模块:

     CODE:

    /* S 消息 扩展 */

    .message_nopic{padding-left:0;}

    /* E 消息 扩展 */

    只需要一句,将头像去掉即可。

    6.6 CSS模块的注释——页面重构中的模块化设计(六)

    从前面的内容我们已经知道,样式是可以分成各个模块去写的,如何表示各个模块的作用及它们之间的关系呢?CSS的注释是不二的选择。

    与普通的注释不同,模块的注释需要一些更详细的内容,比如:功能说明、模块版本、关联信息等等。 像 《基类、扩展类──页面重构中的模块化设计(五)》中例子的注释,显然是比较简单的。为了减少不必要的沟通,我们可以使用较为固定的格式去完成这个注释。

    举个例子:

     CODE:

    /**

      * @name:mode_name

      * @author:ghostzhang

      * @version:1.0

      * @type:基类

      * @explain:Demo

      */

    .mode_name{...}

    .mode_name h2{

        ...

    }

    .mode_name .cont{

        ...

    }

    /* @end **/

    /**

      * @name:mode_name_b

      * @author:ghostzhang

      * @version:1.0

      * @type:扩展类

      * @explain:Demo

      * @dependent:mode_name

      */

    .mode_name_b{...}

    .mode_name_b h2{

        ...

    }

    .mode_name_b .cont{

        ...

    }

    /* @end **/

     

    从注释中就可以知道mode_name_bmode_name_a之间的关系。

    主要的关键字有:

    @name

    标明模块的名称

    @author

    标明模块的作者

    @version

    标明该模块的版本

    @explain

    功能说明

    @relating

    标明该关联的模块

    @dependent

    标明该所依赖的模块

    @type标明该模块的类型:公共、基类、扩展类

    需要注意的规则:

    “/**”标记模块的开始

    “/**”到第一个“*/”作为模块相关信息的说明,包含关键字

    关键字以==@==开头,“:”后开始到“*”的内容为相关的值,即:

    @关键字:*

    “/* @end **/”标记模块的结束

    模块注释内不可嵌套

    提供了一个小工具( cssModeCODE: )帮助大家填写样式模块的注释。

     

    展开全文
  • tensorflow学习笔记——keras模块

    千次阅读 2018-07-16 11:03:13
    本文基于tensorflow官网教程(https://tensorflow.google.cn/guide/keras),机器环境为ubuntu14.04LTS+tensorflow1.8.01.Keras模块配置 Keras模块是tensorflow提供的一个高级api,主要有以下优点:用户友好,一致...
  • 总的来说可以分文两大:USB IP、OTG IP。这两种 IP又可以进行更进一步的细分,如下图: USB IP: 仅可作为全速或低速的USB设备; USB+ IP: 是针对USB IP的扩展版本,同样仅可作为全速或低速的USB设备,但是ST...
  • 学习本篇文章后会了解到:类的创建,为对象添加属性,对象的初始化,自定义对象的输出,类属性和类方法的创建。 1. 类的定义与格式 类是对一群具有相同特征或者行为的事物的一个统称。 类是一个模块,是...
  • 公众号“素质云笔记”定期更新博客内容: THULAC 四款python中中文分词的尝试。尝试的有:jieba、SnowNLP...四款都有分词功能,本博客只介绍作者比较感兴趣、每个模块的内容。jieba在这不做介绍,可见博客:...
  • 前面已经完成了整个工程大部分模块,接下来进入整合联调以及模拟测试模块。 测试模块主要任务就是代替服务器给出我们需要的数据。因为我们本来的计划是封装成类库通过服务器调用获取,其调用的接口无非就是叫分、...
  • 【重构】重构概要--大重构模块

    千次阅读 2013-06-07 10:17:34
    如果一个的功能模块太少,这个很小,可以将内联化,将这个合并到其它功能类似的中。 隐藏委托关系移除中间人 :当用户通过一个调用另一个时,要使用另一个的功能的时候,为了实现更好的封装,可以...
  • 解铃还须系铃人,既然是在内核中出了问题,还是需要在内核中寻找办法,解决这问题的前提是对内核卸载模块的精确理解,流程都理解透了,害怕找不到原因吗?原因都找到了,办法肯定是有的!(这也是我从公司学习到的...
  • 不知不觉中,我们的Glide系列教程已经到了第篇了,距离第一篇Glide的基本用法发布已经过去了半年的时间。在这半年中,我们通过用法讲解源码分析配合学习的方式,将Glide的方方面面都研究了个遍,相信一直能看到...
  • 我们应该创建新的模块(在原有的模块基础之上)来达到修改扩展功能的目的。Odoo提供了一种继承机制,允许第三方模块扩展现有模块,或者官方的或者来自社区的,这种继承修改可从任意层次来开展,从数据模型到业务...
  • 手把手带你撸一个校园APP():新闻中心模块

    千次阅读 多人点赞 2020-02-09 15:35:45
    手把手带你撸一个校园APP():失物招领&二手交易模块 手把手带你撸一个校园APP(七):图说校园模块 手把手带你撸一个校园APP(八):校园通讯录模块 手把手带你撸一个校园APP(九):课程表模块(模拟登陆...
  • Python之urllib爬虫-request模块和parse模块详解

    千次阅读 多人点赞 2021-03-10 09:10:52
    urllib是Python中用来处理URL的工具包,本文利用该工具包进行爬虫开发讲解,毕竟爬虫应用开发在Web互联网数据采集中十分重要。...request模块 访问URL Request 其他 parse模块 解析URL 转义URL robots.txt文件
  • Pygame详解():image 模块

    万次阅读 多人点赞 2019-01-11 16:01:13
    用于图像传输的 Pygame 模块。 函数 pygame.image.load() — 从文件加载新图片 pygame.image.save() — 将图像保存到磁盘上 pygame.image.get_extended() — 检测是否支持载入扩展的图像格式 pygame....
  • 深入 NumPy 模块# 来源:NumPy Biginner's Guide 2e ch6矩阵的逆import numpy as npA = np.mat("0 1 2;1 0 3;4 -3 8") print "A\n", A ''' A [[ 0 1 2] [ 1 0 3] [ 4 -3 8]] '''# 求解矩阵的...
  • 易语言的模块可以封装成程序集的模块,或者类模块,从大漠的角度,我们可以封装成单线程的模块多线程的模块。 类模块 集模块 免注册 免查杀模块 多线程模块 创建调用 模块方法名称 视频源码链接 类模块集...
  • 千兆万兆光转电模块

    千次阅读 2019-05-09 14:37:51
    根据光转电模块速率的不同可以分为百兆光转电模块、千兆光转电模块、万兆光转电模块以及自适应光转电模块,其中千兆光转电模块与万兆光转电模块的应用最为广泛。 千兆光转电模块有1000Base SFP电口模...
  • 模块隔离原理

    千次阅读 2016-09-10 16:41:53
    一个加载器事实上也对应了一个命名空间,换句话说,同一个被不同加载器加载会产生两个class对象,在jvm内部会通过系统字典维护class对象类名以及加载器的关系。 假设A由MN分别加载,则其在jvm里的...
  • 模块化编程的大原则

    千次阅读 2019-02-17 19:22:13
    的职能要单一: 遵循单一职责原则。分别建立两个T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险 里氏替换原则...
  • UEFI工程模块文件-驱动模块前言 在UEFI中,驱动分为两:一是符合UEFI的驱动模型的驱动,模型的类型为UEFI_DRIVER,称为UEFI驱动;另一是不遵循UEFI驱动模型的驱动,称为DXE驱动。下面介绍的是UEFI驱动工程...
  • 作者:feasycom ...蓝牙作为一种近距离通信技术,目前已大量应用于各种移动终端,物联网,健康医疗,智能家居等行业,而蓝牙模块由于集成了蓝牙协议栈,射频部分天线,因此也受到广大设备厂家青睐,...
  • 本系列前面博客的链接...http://blog.csdn.net/qq_26525215/article/details/51190696Java-单机版的书店管理系统(练习设计模块和思想_系列 ) http://blog.csdn.net/qq_26525215/article/details/51169277Java-单机
  • .fitpartial_fit进行训练的区别 可以看出即使训练的顺序迭代的次数一样但准确率仍然有区别。 #coding=utf-8 ''' Created on 2017-12-6 ''' from sklearn.neural_network import MLPClassifier ...
  • 五类线(CAT5):传输频率为100MHz,用于语音传输最高传输速率为100Mbps的数据传输,主要用于100BASE-T10BASE-T网络。这是最常用的以太网电缆,该电缆增加了绕线密度,外套一种高质量的绝缘材料,现在5线...
  • 在前面几篇文章中我们分享了使用Jquery EasyUI来进行ASP.NET项目的开发的相关方法,每一个模块都有其共用性,细细理解与掌握,我相信使用EasyUI进行开发还是相当方便的。 每篇文章,我们力求通俗易懂。 接下来我分享...
  • 在虚拟机中,对于任何一个的唯一性是由加载它的加载器这个的全限定名共同确定的,每一个加载器都有一个独立的命名空间。这里需要注意的是,对于相同全限定名的,如果加载器不同,会影响到的Class...
  • 设计模式之之间的关系和六大原则1 之间的关系1.1 继承关系1.2 实现关系1.3 依赖关系1.4 关联关系1.5 聚合关系1.6 组合关系1.7 总结2 大原则2.1 单一职责原则2.2 开放-封闭原则2.3 依赖倒转原则2.4 里氏代换...
  • 设计模式分类以及大设计原则(汇总篇)

    千次阅读 多人点赞 2018-05-22 22:36:28
    创建型模式,共种: 单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。 结构型模式,共七种: 适配器模式、装饰者模式、代理模式、门面模式(外观模式)、桥梁模式、组合模式、享元模式。 行为型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 191,762
精华内容 76,704
关键字:

五类和六类模块的区别