项目报告
XXX陶瓷工厂的进销存管理系统的设计与实现
时代在进步，我们的生产生活方式当然也要相对应的做出改变了。在今天这样一个信息化的时代，计算机软件已经广泛的被用于日常的办公，仓库的库存管理，企业的人员以及资产管理，文字的编辑处理，电子表格的广泛应用以及各种人事管理，财务管理等等方面，可以说计算机软件已经是我们日常生活中不可或缺的一部分了。使用计算机来完成工作效率远比传统的人工作业高得多。众所周知，中国是世界上四大文明古国之一，在英语中中国和瓷器有着相同的拼写这样足可以见陶瓷是我国文明的发展史上一个极为重要的组成部分，这样的发明不仅仅对于中国来说，对于世界来说也做出了极大的贡献，有着非常独特和重要的意义，但是我国的陶瓷生产企业仍是以传统的人工管理模式进行，这样工作容易出错且效率极低。所以根据XXX陶瓷工厂提供的需求，设计此XXX陶瓷工厂的进销存管理系统，以帮助陶瓷工厂达到自动化办公，节约管理成本，提高效率的目的。
本XXX陶瓷工厂的进销存管理系统是基于eclipse开发环境，前台采用的是Swing 和 AWT 相关组件进行的GUI设计，后台使用的是SQL Server数据库。且该XXX陶瓷工厂的进销存管理系统共分为六大模块，分别为基础信息管理模块，进货模块，销售模块，查询统计模块，库存管理模块和系统管理模块，其中基础信息管理模块涉及到客户，原料商品，供应商，产品信息的管理和维护；进货模块涉及到原料商品的进货和退货；销售模块是负责产品的销售和销售退货；查询统计模块则负责查询一些基础信息；库存管理模块完成原料商品的出库，产品的入库，库存盘点和价格修改；系统管理模块涉及到操作员管理和密码修改。总体而言，该六大功能模块设计合理，功能全面，同时界面友好，非常符合我国陶瓷工厂的进销存管理需求。
XXX陶瓷工厂的进销存管理系统；java；SQL Server数据库
目录
摘要............................................................ i
Abstract....................................................... ii
1 绪 论........................................................ 1
1.1本课题的研究背景............................................ 1
1.2国内外研究现状.............................................. 1
1.3本课题的重要工作............................................ 2
1.4选题意义.................................................... 3
2 开发工具的选择............................................... 4
2.1开发工具Eclipse的介绍...................................... 4
2.2 SQLServer数据库介绍........................................ 4
2.3 swing组件与功能............................................ 5
3 可行性分析................................................... 6
3.1经济可行性.................................................. 6
3.2技术可行性.................................................. 6
3.3管理可行性.................................................. 6
3.4法律可行性.................................................. 7
4 需求分析..................................................... 8
4.1功能需求.................................................... 8
4.2性能需求.................................................... 8
4.3 需求分析的结果............................................. 10
5 系统总体设计................................................ 11
5.1业务流程................................................... 11
5.2系统功能模块图............................................. 12
5.3系统流程................................................... 13
5.4系统类图................................................... 13
6 数据库设计.................................................. 15
6.1数据库的逻辑设计........................................... 15
6.2数据库的物理设计........................................... 17
7 详细设计与系统实现.......................................... 20
7.1系统的流程图............................................... 20
7.2登陆模块的实现............................................. 20
7.3基础信息管理模块的实现..................................... 22
7.4进货管理模块............................................... 23
7.5销售管理模块............................................... 26
7.6查询统计模块............................................... 27
7.7库存管理模块............................................... 29
7.8系统管理................................................... 31
8 系统测试.................................................... 33
8.1登陆功能测试：............................................. 33
8.2进货功能测试............................................... 34
8.3查询统计功能测试........................................... 36
8.4库存管理功能测试........................................... 37
8.5系统管理功能测试........................................... 38
总 结.......................................................... 40
致 谢.......................................................... 42
1 绪 论
1.1本课题的研究背景
伴随着全球化的经济的发展，世界上陶瓷产品的需求量与日俱增，而我国作为陶瓷生产的大国自然不能放过这样一个时代的机遇，陶瓷产品的订单越来愈多，同时我国的陶瓷工业的规模逐年扩大，再这样的情况下，传统的陶瓷工厂的进销存管理模式却已经成为整个陶瓷工业的重要组成部分，成为了我国陶瓷工厂进一步成长，进一步扩大规模，获取利益的绊脚石。旧的管理经营模式已经无法满足我国陶瓷工厂日益扩大的生产需求了。伴随着现代计算机技术的飞快普及和各种软件的不断发展，几乎所有的陶瓷企业和工厂已经无法忽视计算机这种辅助工具为自己带来的经济效益了。陶瓷工厂可以利用计算机来提升自己的工作效率、对工厂产品和原材料的库存进行管理，也可以通过不同的产品的效率来判断哪一种产品才是最畅销的，针对性的生产产品，避免不必要的浪费，从而增加工厂的效益，因此，尽快建立一个功能齐备的专门为陶瓷工厂设计的进销存管理系统，完善一个现代陶瓷企业的信息化管理机制，使现代陶瓷工厂库存管理和维护工作变的更加规范，更加系统，更加有效率是十分必要的。
这个课题是在我研究了我国众多的陶瓷生产及加工企业的现实需求，同时结合了工厂生产中所遇到的一些实际的问题还有收获来设计的。基于这些，我针对XXX陶瓷工厂 的进销存管理系统在系统设计还有开发等方面做了重点的研究。主要是研究了开发系统的过程中将会涉及到的一系列软件和硬件的平台的国际化的规范，系统的数据库的结构和完整性的设计。我这样做的主要目的是为了能够从技术手段的角度来阐述怎样解决我国现代的陶瓷生产厂家如何从原来传统的人工管理模式向现代化的信息化的管理模式的转变，除此之外还有陶瓷工厂的进销存系统在陶瓷工厂管理信息化中所起到的重要作用。
1.2国内外研究现状
目前，国外陶瓷企业的信息化状况的分布是这样的：在大型陶瓷企业中，一般都会使用进销存管理系统来进行管理；在中型陶瓷企业中，进销存管理系统正在被重视并在实际生产中创造价值，在这种陶瓷企业中，进销存管理已经不再是传统的分散的单店式的非常分散的管理模式了，它越来越向着更加集中的更加方便管理的模式靠拢；对于小型的企业来说，很少有企业涉足这块，即便是有所了解也是仅仅处在表面的层次，无论是思想观念还是信息系统的建设都非常的不成熟，还需要一些时间来慢慢的探索，认识，进步。国外的这些进销存管理系统的使用情况对应着各种不同的企业，有着丰富的经验可供借鉴，但是，这些国外的软件和生产管理经验并不是能够完全符合我国的国情的，而且我国自主研发的一系列进销存管理软件大都是功能单一的，很少有这种专门为了我国陶瓷工厂量身定制的，建立适合我国的陶瓷工厂特点的进销存管理系统，是工厂以高效率，低成本立足市场，为其自身的发展提供条件的重要课题。
1.3本课题的重要工作
伴随着我国经济的快速发展，中国陶瓷工厂的规模逐年扩大，传统的进销存管理模式使得陶瓷工厂的管理越来越复杂和繁重。本陶瓷工厂的进销存管理系统是面向国内陶瓷工厂，为了加强产品和原料管理，从而更好地对库存进行科学的监督和管理，使陶瓷工厂员工的工作更加高效和轻松而开发。该陶瓷工厂的进销存管理系统是以精确、实际、真实的陶瓷生产体系为基础，提供了对陶瓷生产原材料数量、类型、批号等的全面管理。系统能随时提供产品的库存、进销存的详细信息，还能非常好的管理和维护供应商，客户的信息。从而提高资源的利用率，方便快捷的对各种重要信息进行更新和维护等。
陶瓷工厂的进销存管理系统主要设计和实现以下内容：
(1) 基础信息管理：该模块主要负责对系统中的基础信息进行更新和维护。主要包括四个功能。其一，客户信息管理，此功能可以将客户的基本信息进行保存，之后还可以对其进行维护。其二，商品信息管理，此功能可以对商品即原材料进行保存和维护，还完成了将不同的商品与其各自的对应供应商进行匹配的功能需求。其三，供应商的信息的管理，此功能可以将供应商的基本信息进行保存，之后还可以对其进行维护。其四，产品信息管理，此功能可以对工厂生产的产品进行定义和维护。
(2)进货管理：进货管理这个模块又分为两个小模块，分别是进货单和进货退货功能这两个小功能。其中进货单功能是本模块的核心功能，主要完成了从对应的供应商处进入原材料，这里面还维护了经手人等字段，可以在将来需要的时候查明每一笔入库的来龙去脉。而进货退货功能也是在研究了大量的现实中陶瓷工厂的具体进货流程后提出的这样一个个性化，实用性极高的小功能。主要是考虑到了在现实进货中不可能每一次的进货都尽如人意，出现残次品的概率是极高的，所以一定会有将原材料退货的需求的，在这个功能中可以将第一步通过进货单入库的原材料再次出库。
(3)销售管理：在销售管理这个大模块中也是分为了两个小的功能，分别是销售单，销售退货功能。销售单指的是将生产好的产品卖给对应的有需求的客户，从而获取效益，这个功能也是本系统中最重要的一个功能，没有这个功能，整个系统的收益将无从谈起。相应的说，销售退货功能完成的功能主要是将卖出去的产品通过退货的渠道再次入库。这么做的原因是考虑到了各个客户需求是有很大的可能会变更的，或者我们的产品出现了残次品，无法满足客户的需求，在这两种情况下就需要用到这个功能，将销售出去的产品再次入库。
(4)查询管理：该模块主要负责对工厂核心信息的查询，因为在实际生产中，无论客户，供应商，原料还是产品都会有很多，所以将基础信息的查询功能拿出来专门做成一个模块，这么做是符合实际的生产场景的。具体来说，主要完成了各个具体信息的模糊查询和完全匹配查询，除此之外比较有特色的是我给每一种基础信息都维护了一个对应的简称字段。而且简称字段也提供了模糊查询和完全匹配查询这两种功能，更加方便也更加的人性化，利于日常工作的开展。
(5)库存管理：该模块是本系统中最重要的功能，因为本系统是一个陶瓷工厂的进销存管理系统，和传统的仓库管理系统区别很大，本系统中我们要对原材料进行加工后销售陶瓷成品所以在本模块中加入了商品出库，产品入库，库存盘点，价格修改等功能。
(6)系统管理：该模块是对工厂中的所有操作员进行管理的模块，在使用这个模块的时候我将会对此操作进行鉴权，具体的来说就是，所有的角色都可以修改自己的密码，但是只有系统管理员才有权限增加新的操作员。
1.4选题意义
现代计算机技术的进步，不仅仅改变了我们的生活方式，同时我们的工作方式也变得更加科学和高效，怎样才能够让我国传统的陶瓷企业更快速的，更准确的获取到市场的需求，更好的反应市场的变化，已是中国陶瓷工厂首当其冲的必须要面对的问题，因此设计和实现一整套完整的针对性更强的实用的现代陶瓷工厂进销存管理系统就显得刻不容缓了，在本次毕业设计中我秉承了良好的治学之风，除了严格按照毕业设计进度表来进行我的系统设计工作，我还与指导老师进行了非常深刻的讨论，老师的建议让我的系统功能更加的完善，性能更加的卓越。同时这个项目也是一个会对实际生产生活产生很大的影响的真正能够创造效益优化企业管理的项目，所以对基层生产厂家的调研、研究工作就成了重中之重，我要为最终能够完成一个成功的软件而努力。
2 开发工具的选择
2.1开发工具Eclipse的介绍
2.1.1Eclipse简介
Eclipse 这个工具是我开始接触编程就一直使用的工具，它本身也是开源的，在在校学习和日常的实习工作中，使用最为广泛。Eclipse这个工具可扩展性是非常好的，工作中可以通过安装不同的插件来引入各种的实用的功能，让开发与测试变得更加紧密，也更加的方便。最值 得一提的是，Eclipse 工具本身还附带了Java语言的JDK工具（Java Development Kit，JDK）这是一个标准的插 件的集合。Eclipse的主要项目包括三个组成的部分，分别是Eclipse项目、Eclipse技术项目还有Eclipse工具项目。更具体的来说，Eclipse Platform、CDT、JDT以及PDE这四个部分共同组成了现在这个成熟的Eclipse工具。JDT主要是可以支持Java的开发测试工作，CDT主要是用来完成C语言的开发及测试、PDE则是可以用来支持插件的开发和测试，最后Eclipse Platform是一个有很好的开放性的可扩展的IDE工具，它提供了一个通用的开发平台，同时提供了一个让建造模块和构造模块集成，并行对的软件开发工具的基础。
2.2 SQLServer数据库介绍
2.2.1SQLServer数据库的简介
SQLServer 数据库是我现在在实习工作中使用的一个数据库。它是由美国的Microsoft 微软公司推出的一款应用广泛的关系型的数据库系统。SQL Server是一个可以根据每一个用户的个性化需求完成定制、性能在众多的数据库中也算是非常的卓越的、为分布式客户机/服务器计算需求来 设计的数据库管理系统，通过使用SQLServer数据库我们还能完美的使用WindowsNT，应为他与SQL Server完成了非常好的有机结合，提供了一种可靠的基于事 务的企业级的信息管理系统方案。同时，因为之前在校期间学习的时候学习过SQLServer 数据库，比较熟悉，所以此次毕业设计我选择用SQLServer作为后台的数据库。
2.2.2 SQLServer数据库的优势
1.SQLserver数据库拥有高性能的设计，这样做我们就可以非常充分的利用WindowsNt的各种优势来优化我们数据。
2.SQLserver数据库的系统管理模式十分的先进，它可以运行Windows图形化管理工具，除此之外，它还支持本地的还有远程的系统管理和配置。
3.事务处理功能非常的先进，它采取了各种办法来保证了数据的完整性还有数据库的安全，让我们可以更方便的处理数据。
4.SQLServer数据库可以对多处理器结构进行解析，它的存储结构也更加的科学，能完美的运行ODBC，除此之外，它还拥有自主的SQL语言。他的各种强大的，实用的功能为广大开发者和用户提供了一个安全，性能出众的数据库平台。.
2.3 swing组件与功能
Java. awt 包含用于创建用户界面和绘制图形图像的所有类。在AWT术语中，诸如按钮或滚动条之类的用户界面对象称为组件。Component 类是所有AWT组件的父类。当用户与组件交互时，一些组件激发事件。AWTEvent 类及其子类用于表示AWT 组件能够激发的事件。容器是一个可以包含组件和其他容器的组件。容器还可以具有布局管理器，用来控制容器中组件的可视化布局。AWT 包带有几个布局管理器类和一个接口，此接口可用于构建自己的布局管理器。而swing组件则是在awt组件基础上优化出来的轻量级组件。Swing组件位于javax.swing包中，此包提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。此次毕业设计，我便采用Swing组件在进行前台的GUI界面设计，并用java.awt.event事件监听实现系统用户与本系统的动态交互。
3 可行性分析
3.1经济可行性
经济可行性研究是对我国众多的陶瓷工厂的经营状况和是否愿意为此系统来进行投资完成了详细的分析，对此为我国陶瓷工厂量身定做的系统的建设及运行还有后期维护的费用做了大致的估算，同时还对系统建 成后可能和一定会取得的经济和社会的效益进行评估。再加上本系统是为现实中实际的陶瓷工厂员工提供实用性强，可操作性强的自动化的办公内容，登陆了本系统后，就可以使用对应权限的系统功能了，系统的成本大部分都集中在了系统工程软件的开发工作上了，当这个系统投入到实际的运行中后即可以为人们节约大量的宝贵时间和精力，完成的工作也更加的安全，准确。它所能够带来的方便及效益远远大于系统软件的开发成本。在经济上完全可行。
3.2技术可行性
本系统采用Eclipse开发工具等当今使用最广的开源框架等技术应用到模块制作当中，结合陶瓷工厂的进销存管理系统的特点，设计基于java (swing组件)开发的。其中：前台用Swing 组件技术以及awt event事件响应实现前台GUI界面的开发以及相应得事件响应，后台采用了SQL Server数据库来完成相关数据的存储，二者之间的联系则采用SQL相关增删改语句编写成java类来实现，这三大部分尽量发挥各自的特点充分协调工作。再此基础上，我对本系统的各个模块进行了详细的分析，尽可能让它们做到模块独立，高内聚低耦合，让今后的维护工作更加的可行，所以在技术层面是可行的。
3.3管理可行性
本陶瓷工厂的进销存管理系统是由六大各具特色，缺一不可的模块共同组建完成的，开发完成并实际投入运行后，日常工作中的维护与管理也是非常简单快捷的。于此同时，系统开发中我将不同的功能分为不同的模块，在一个模块中功能尽可能的单一，这样会使后期维护工作成本更低且更容易完成，代码编写中我严格的遵守了代码的编写的规范，让本系统的代码更容易让人理解。对于完成同样工作的进程来说，采用启动一个程序，同时开启多个子进程的设计模式。值得一提的是在本系统中，具体的设计是将所有的对功能的操作都让操作员来完成，系统管理员很少，或者完全不参与系统的日常运行。将系统管理员的功能独立出来，让他全心全意的投入到对操作员的管理之中去。这种将两个角色分开的做法，使得整个系统更易于维护和管理，可以保证每一个操作员都是管理员仔细挑选之后的，而且如果出了问题，系统管理员也可以快速地定位到是哪一个操作员，让责任更明确具体。
3.4法律可行性
因为这个系统如果投入使用的话，一定会产生资金上的来往，这样有可能会让人钻空子违反法律法规。所以，在本系统的需求分析，代码开发，功能测试，包括之后的运行维护过程中，我都严格的遵守了我国的所有的相关法律法规。在此基础上，我还积极的相应国家的号召，让这个系统完全的贴合了我国的经济现状，让它为我国众多的陶瓷工厂做出贡献。所以在法律层面，它是完全可行的。
4 需求分析
4.1功能需求
1. 基础信息管理：该模块主要负责对系统中的基础信息进行更新和维护。
1.1客户信息管理，通过这个功能，我们可以实现对所有客户信息的增删改查，可以查看每一个客户的详细信息，利用这些信息，从而更有针对性的推荐我们的产品，这样的成功率一定是更高的。
1.2商品信息管理，此功能可以对商品即原材料进行保存和维护，还可以将不同的原材料和不同的供应商进行匹配。
1.3供应商信息管理，此功能可以将供应商的基本信息进行保存，之后还可以对其进行维护。
1.4产品信息管理，使用此功能我们可以对工厂中新增的产品进行添加，在这里添加后我们就可以实际进行生产操作了。
2. 进货管理：该模块主要负责对工厂所需原材料资源的维护工作，包括进货、退货等，实现了进货阶段对原材料入库的增删操作。
3. 销售管理：该模块主要管理工厂对陶瓷产品的销售，和退货，实现了销售阶段对产品出入库的增删操作。
4. 查询管理：该模块主要负责对基础信息的查询，因为在实际生产中，无论客户，供应商，原料还是产品都会有很多，所以将基础信息的查询功能拿出来专门做成一个模块，符合实际的生产场景。
5. 库存管理：该模块是本系统最核心的功能，因为本系统是一个工厂的进销存管理系统，和传统的进销存管理有些不同，本系统中我们要对原材料进行加工后销售陶瓷成品所以在本模块中加入了商品出库，产品入库，库存盘点，价格修改等功能。
6. 系统管理：该模块是对工厂中的员工进行管理的模块，在这个模块中希望将基础功能的操作和操作员的管理分离开来。在本系统中的所有的角色都是可以对自己的密码进行修改的，但是如果想添加新的操作员的话，只能通过系统管理员来完成，也只
4.2性能需求
进过仔细的调研后，我发现一个满足一下几条需求的系统才可以长期，稳定，安全，高效的运行起来：
1、要及时的和准确的处理系统信息
在设计一个陶瓷工厂的进销存管理系统的时候，我最先考虑的就是这个系统处理信息要及时更要准确。这是每一个系统都需要做到的最基础的性能。在本系统设计之初，我就已经充分的考虑到了这个系统现在的和将来的需要承受的最大的和平时的工作量，本系统的性能是完全能够满足我国陶瓷工厂的对信息处理的需求的。
2、要可以扩充系统功能
陶瓷工厂的进销存管理系统在开发过程中，我已经充分考虑到了以后系统的可扩充性。举个例子来说，陶瓷工厂的规模随着需求的增长会变得越来越大，程序的查询需求也在不断地变化，要对应的设计全称查询和简称查询，还有模糊查询等等。所有这些，都要求系统提供很多的可以进行功能的调整和扩充的接口。而要实现这一点，要利用系统的开放性来实现，就是说系统应是一个开放系统，可以自己分析需求，根据需求来对系统模块进行增加和替换，如果当前的功能不能满足实际的需要的话，也是可以对原有系统进行升级换代的。
3、所有的功能都必须易于操作上手
陶瓷工厂的进销存管理系统是直接为工厂的操作员服务的，要考虑到这些员工并不了解程序的流程，要设计易用的界面，让各位操作员更有效率的为工厂服务，而不是把时间浪费在熟悉系统上。
4、系统的标准性
陶瓷工厂的进销存管理系统，在具体的设计和部署时需要用到很多的软件和硬件产品，这些必须要符合国际标准。只有符合了国际的统一的标准，我们的工程才能更好的运转，也有利于后期的测试以及运行维护等等工作的开展。
5、系统的响应速度
考虑到实际生产中操作员的需求，本陶瓷工厂的进销存管理系统的数据库对信息处理的响应时间设为秒级。因为日常出入库工作不能马虎，如果系统的响应时间非常的长就有产生脏数据的风险。同时，在进行数据查询的时候，数据库的响应时间应该更短，这样才能拿到最新的数据，更全面，更准确。
6、系统要足够的安全
我们这个系统是为了现实中的陶瓷工厂使用而设计的，所以系统要足够的安全才能让人们放下心来使用，安全性包括多个方面，在这个系统中，我们最注重的有两个方面。一个就是，数据要易于维护，且不能产生脏数据，这个问题我们通过SQLserver数据库的良好的性能解决了，另一个问题就是要避免SQL注入攻击，这个问题我通过前后台的数据的校验来解决了。所以说我们这个系统的安全性很高，是一个能够让人方心使用的系统。
4.3 需求分析的结果
经过详细的需求分析后，我得出这样的结论：
在本XXX陶瓷工厂的进销存管理系统中，我们需要的主要的用户有两个，一个是系统操作员，在日常的工作中也是系统管理员来对系统进行操作，还有数据的维护。另一个角色是系统管理员，这个角色也可以进行系统的操作，但是一般不这么做，基础的功能全部交给操作员来完成，它拥有系统操作员的所有权限，但是，他也可以对操作员进行管理，这个是操作员不具备的权限，只有系统管理员才有权限进行此操作。
下面是系统的用例图：
图4.1 操作员的用例图
图4.1 系统管理员的用例图
5 系统总体设计
5.1业务流程
根据需求分析得到的陶瓷工厂进销存业务处理流程，经过我的仔细研究后，首先确定了目标系统的业务流程，其处理流程如图5.1
|
系统用户验证 |
|
操作员 |
登陆
信息维护
|
基本信息增删改查操作 |
|
进货 |
原材料入库
原材料出库
|
生产产品 |
|
销售 |
|
库存管理 |
产品入库 产品
图5.1 XXX陶瓷工厂的进销存管理系统的业务流程
针对整个系统的业务流程，现具体描述其主要的功能如下：
1、用户登录：当前系统对当前的登录的用户做合法性的检查同时完成系统的鉴权工作，让不同的角色完成不同的工作。
2、基本信息维护：维护供应商，客户，商品，产品等系统的基础信息，这些是完成整个系统的最基础的数据，缺一不可。
3、进货：生产陶瓷产品所必须的原材料将通过这个功能从其对应的供货商处买来，在设置好对应的信息后将其入库。
4、原材料出库：原材料放在仓库中是不能生产产品的，所以我们要先将原材料从库存中拿出来需要的数量，去完成陶瓷产品的生产工作。
5、产品入库：生产了不同的产品后将其分类入库。
6、库存管理：查看库存并对其进行管理，可以更改产品的价格。
7、销售：生产产品就是为了将其销售产生效益，通过这个功能可以将对应的产品买个各自需要的客户，如果产品有缺陷的话，也可以通过这个功能完成产品的退货。
5.2系统功能模块图
本系统主要分为基础信息管理模块，进货管理模块，销售管理模块，查询统计模块，库存管理模块，系统管理模块等六大模块。基础信息管理能够维护客户，商品，供应商，产品的基本信息进货管理能够进行商品的购买入库和退货；销售管理能够进行产品的出库和退货；查询统计能够对基础信息进行查询；库存管理能够进行原材料出库，产品入库，库存盘点，价格调整；系统管理能够新增操作员和修改密码。
下面是本系统的功能模块图：
|
XXX陶瓷工厂的进销存管理系统 |
|
基础信息管理 |
|
销售管理 |
|
进货管理 |
|
查询统计 |
|
库存管理 |
|
系统管理 |
|
基础信息的更新与维护 |
|
进货 |
|
进货退货 |
|
销售 |
|
销售退货 |
|
信息查询 |
|
商品出库 |
|
产品入库 |
|
库存盘点 |
|
价格修改 |
|
修改密码 |
|
操作员管理 |
图5.2 XXX陶瓷工厂进销存管理系统功能模块图
5.3系统流程
依据软件工程基本原理，综合以上分析给出系统流程如图5.3所示
图5.3 第一次登陆系统时的系统的处理流程
说明: 用户通过登陆界面登陆系统时，第一次使用系统时需要进行供应商，商品类别，客户，产品类别的创建，即将所有基本信息依次录入系统，第一次使用系统时同样要初始化库存，将现有的库存情况录入系统，接下来当发生库存变更时，对库存进行相应的修改，使用完成后退出系统即可。
5.4系统类图
在本系统中，主要的类有：
用 户 类：这个类通过权限又分为系统管理员和操作员，系统管理员可以添加新的操作员，但是普通的操作员是没有进行这个操作权限的。
供应商类：这个类是操作员进行维护的，供应商类的主键将作为商品类的外键存在，供应商会生产陶瓷原材料，即商品。让后将不同的商品与供应商对应起来完成入库操作。
商 品 类：这个类是陶瓷的原材料类，操作员通过进货将商品入库，当需要生产陶瓷产品的时候，通过商品出库操作完成出库。
产 品 类：这个类就是工厂生产出来的不同产品的类，操作员将它维护在库存中，当有客户需要购买产品时，操作员通过销售操作完成出库。
客 户 类：这个类顾名思义就是工厂的客户，他会购买我们的产品，给我们创造效益，所以要很好的维护。
库 存 类：这个类是用来维护工厂的库存的，同时包括商品和产品两种，操作员可以通过库存盘点来清点库存，也可以通过价格调整操作来修改库存中商品和产品的价格。
下面是系统的类图：
图5.5系统类图
6 数据库设计
6.1数据库的逻辑设计
依据数据库设计的方法，可按照本系统数据特点设计相应的实体关系可知，该XXX陶瓷工厂进销存管理系统一共涉及到6个实体，其对应的实体关系图如下所示：
用户实体是维护了系统中所有的角色，他可以进行所有的操作，但是它不与其他的实体产生关系，具体如下图所示：
图6.1用户实体图
供应商实体与原材料实体之间的关系是每一个供应商可以为陶瓷工厂提供多种原材料，某一种特定的原材料也可以通过多个供应商来提供。但是由不同的供应商来提供的原材料其质量也会不同，所以这两种原材料是两种不同的原材料，他们之间的关系是一对多。具体关系如下图所示：
图6.2原材料与供应商的ER图
客户与产品之间的关系是一个客户可以同时选择购买多个产品，他们之间的关系是一对多的关系，具体的关系如下图所示：
图6.3客户与产品的ER图
库存实体是用来存储产品与原材料的真实的仓库只有一个，所以库存也只有一个，在这个库存中可以存储多个产品，同时也可以存储多个原材料，所以这三个实体之间的关系是库存与产品一对多，库存与原材料一对多。具体如下图所示：
图6.4产品，原材料与库存的ER图
XXX陶瓷工厂的进销存管理系统主要涉及到6个表，即产品信息表、商品信息表、库存信息表、供应商信息表、客户信息表、用户信息表。
产品信息表：生产的产品的信息主要在这张表中维护。新的产品添加后就会存储到这张表中。包括id、产品名称和产地。其中id是主键，非空且唯一。
商品信息表：生产的产品的原材料的信息主要在这张表中维护。新的商品添加后就会存储到这张表中。包括id、商品名称、产地和供应商。其中id是主键，非空且唯一。
库存信息表：库存的信息主要在这张表中维护。库存的具体情况会保存在这张表中。包括id、名称、单价、库存数量等。其中id是主键，非空且唯一。
供应商信息表：原材料的额供应商的信息主要在这张表中维护。新的供应商信息添加后就会存储到这张表中。包括id、名称、简称、地址、邮箱、联系人等。其中id是主键，非空且唯一。
客户信息表：工厂的客户的信息主要在这张表中维护。新的客户信息添加后就会存储到这张表中。包括id、名称、简称、地址、邮箱、联系人等。其中id是主键，非空且唯一。
用户信息表：工厂的所有操作员的信息和系统管理员的信息主要在这张表中维护。新的操作员新建后就会存储到这张表中。包括名称、登录名、密码、权限等。其中名称是主键，非空且唯一。
6.2数据库的物理设计
数据库设计是指对于一个给定的应用环境，构造最优的数据库模式，我们需要建立一个适合的数据库及其应用系统，使之能够有效地存储和维护数据，满足特定的用户的应用需求。在设计陶瓷工厂的进销存管理系统时，主要从模块组成、数据连接、功能实现、应用意义等方面着手，在设计数据库时要充分考虑数据库的安全性和高效性，尽可能的减少数据冗余，同时保证数据的完整性。
数据库的设计中一般来说有五种范式，第五范式（5NF）在设计的过程中又被人们称为完美范式，但是，在日常的开发中很难做到第五范式那么完美，一般来讲，我们需要做到的是第三范式，就是说我们在数据库中维护的各种表不可以有冗余的字段，还有在同一个表中的各个字段不可以有相互的函数依赖关系。冗余字段就是说一个字段在我这个表中已经保存过了，那么久就不能在其他的表中再去维护它了，如果需要用到这个字段的话，则可以通过各个表间的关联来得到。函数的依赖性指的就是一个表中的各个字段不可以有相互之间的计算关系，举个例子，假如一个表中既有单价字段，又有数量字段，那么就不应该有产品总价这个字段，在需要的时候将这两个字段的值取出来后，再去计算，这样可以降低数据库的维护成本同时还可以减少由于表间的相互关联使用，来造成的功能服务速度降低等问题了。这就是大家口中的第三范式。
在数据库建表的时候需要考虑到最好不要将用户能够输入的字段作为一个表的主键，这样做的话可以有效的规避风险，更好的维护数据库系统的完整性。
在数据库设计之初我们一定要足够的谨慎，尽可能的把所有可能会发生的场景都考虑进去，可以在表中添加一些备用字段，以便将来扩充业务所需。
程序一旦开始编码，就应当尽可能的避免再对数据库表的字段进行修改了，因为这样修改后很可能会引入新的问题，很多的时候新引入的问题还很难被发现，当被发现的时候很可能就已经造成了不可挽回的损失了，所以数据库的设计要在一开始就想好，尽可能的避免后期修改表结构。
下面我要画上本系统的E-R图，如图6.7所示。E-R图描述了当前现实世界到计算机机器的二进制世界的这样一个中间层次的图。所以说，它是一种概念模型。这种概念模型对信息世界的抽象分析是有极大的帮助的，我们可以利用这种工具完成用户和程序员之间的沟通，所以他也具有非常强的语义表达能力，传达知识更加的直接，清晰准确。同时让用户理解起来也更加的简单，更直观。
图6.7表之间的关系
7 详细设计与系统实现
7.1系统的流程图
图7.1总体流程图
说明：用户登陆系统时，系统判断用户的级别，如果为系统管理员，则可以进行操作员管理以及基本信息管理，销售管理，进货管理，库存管理，查询统计，更改密码，系统管理员点击退出按钮时，退出系统。如果是操作员，则可以进行相应的基本信息管理，销售管理，进货管理，库存管理，查询统计，更改密码，操作员点击退出按钮时，退出系统。
7.2登陆模块的实现
该模块是整个陶瓷工厂进销存管理系统的入口，通过登陆时输入不同的信息让系统分辨出不同的角色，从而能够有不同的操作权限。
图7.2登陆界面
关键代码：
连接数据库代码：
ResultSet jieguo = findForResultSet("select * from tb_userlist where username='"+ name + "'");
if (jieguo.next()) {
user.setUsername(name);
user.setPass(jieguo.getString("pass"));
if (user.getPass().equals(password)) {
user.setName(jieguo.getString("name"));
user.setQuan(jieguo.getString("quan"));
}
7.3基础信息管理模块的实现
图7.3客户信息管理-1
图7.4 客户信息管理-2
关键代码：
界面设计代码：
只有部分主要功能和代码
ResultSet haveUser = Dao.query("select * from tb_khinfo where khname='"
+ keHuQuanCheng.getText().trim() + "'")
if (haveUser.next()){
System.out.println("error");
JOptionPane.showMessageDialog(KeHuTianJiaPanel.this,
"客户信息添加失败，存在同名客户", "客户添加信息",
JOptionPane.INFORMATION_MESSAGE);}
连接数据库代码：
return insert("insert tb_khinfo values('" + khinfo.getId() + "','"
+ khinfo.getkehuname() + "','" + khinfo.getJian() + "','"
+ khinfo.getAddress() + "','" + khinfo.getyouzhengbm() + "','"
+ khinfo.getdianhua() + "','" + khinfo.getFax() + "','"
+ khinfo.getLian() + "','" + khinfo.getLtel() + "','"
+ khinfo.getMail() + "','" + khinfo.getXinhang() + "','"
+ khinfo.getHao() + "')");}
本模块中商品信息管理功能，供应商的信息管理功能，产品信息管理功能与客户信息管理功能相仿，所以在此不在赘述了。
7.4进货管理模块
图7.5 进货管理模块-进货单
进货单前台界面：
public class JinHuoDan extends JInternalFrame {
private void initTable() {
String[] columnNames = {……这里是进货单字段};
((DefaultTableModel) table.getModel())
.setColumnIdentifiers(columnNames);
TableColumn column = table.getColumnModel().getColumn(0);
DefaultCellEditor bianjiqi= new DefaultCellEditor(sp);
bianjiqi.setClickCountToStart(2);
column.setCellEditor(bianjiqi);
}
连接数据库代码：
boolean zidongtijiao= conn.getAutoCommit();
conn.setAutoCommit(false);
insert("insert into tb_kucun values('" + ruMain.getRkId()
+ "','" + ruMain.getPzs() + "'," + ruMain.getJe() + ",'"
+ ruMain.getyanshoujielun() + "','" + ruMain.getgongyingshan() + "','"
+ ruMain.getRkshijian() + "','" + ruMain.getcaozuoy() + "','"
+ ruMain.getJsr() + "','" + ruMain.getJsfs() + "')");
Set<TbRukuDetail> rkDetails = ruMain.getTabRukuDetails();
for (Iterator<TbRukuDetail> iter = rkDetails.iterator(); iter
.hasNext();) {
进货退货功能：
图7.6进货退货
进货退货的前台界面实现与进货单类似，这里只写连接数据库代码：
public static String getRkthMainMaxId(Date date) {
return getMainTypeTableMaxId(date, "tb_rkth_main", "RT", "rkthId");
}
public static boolean insertRkthInfo(TbRkthMain rkthMain) {
boolean zidongtijiao = conn.getAutoCommit();
conn.setAutoCommit(false);
Set<TbRkthDetail> rkDetails = rkthMain.getTbRkthDetails();
for (Iterator<TbRkthDetail> iter = rkDetails.iterator(); iter
.hasNext();) {
TbRkthDetail details = iter.next();
Item item = new Item();
item.setId(details.getSpid());
TbSpinfo spInfo = getSpInfo(item);
if (spInfo.getId() != null && !spInfo.getId().isEmpty()) {
TbKucun kucun = getKucun(item);
if (kucun.getId() != null && !kucun.getId().isEmpty()) {
int sl = kucun.getKcsl() - details.getSl();
update("update tb_kucun set kcsl=" + sl + " where id='"
+ kucun.getId() + "'");}
在本模块中我还加入了表单的验证功能，用户不能输入非法的，不符合本系统的数据，这样一来本系统就从前台和后台两个方面避免了非法数据的输入，这样就能使得系统更加的安全，无形之中也规范了用户的操作。
7.5销售管理模块
图7.7销售单
图7.8销售退货
销售管理模块的前台代码与进货管理的前台代码实现方式一致，这里只写连接数据库代码：
insert("insert into tb_sell_main values('" + sellMain.getSellId()
+ "','" + sellMain.getPzs() + "'," + sellMain.getJe()
+ ",'" + sellMain.getYsjl() + "','" + sellMain.getKhname()
+ "','" + sellMain.getXsdate() + "','" + sellMain.getCzy()
+ "','" + sellMain.getJsr() + "','" + sellMain.getJsfs()
+ "')");
Set<TbSellDetail> rkDetails = sellMain.getTbSellDetails();
for (Iterator<TbSellDetail> iter = rkDetails.iterator(); iter
.hasNext();) {
TbSellDetail details = iter.next();
insert("insert into tb_sell_detail values('"+ 1 +"','"
+ sellMain.getSellId() + "','" + details.getSpid()
+ "'," + details.getDj() + "," + details.getSl() + ")");
在这里通过这个方法将销售信息维护到数据库中：
boolean autoCommit = conn.getAutoCommit();
conn.setAutoCommit(false);
insert("insert into tb_xsth_main values('" + xsthMain.getXsthId()
+ "','" + xsthMain.getPzs() + "'," + xsthMain.getJe()
+ ",'" + xsthMain.getYsjl() + "','" + xsthMain.getKhname()
+ "','" + xsthMain.getThdate() + "','" + xsthMain.getCzy()
+ "','" + xsthMain.getJsr() + "','" + xsthMain.getJsfs()
+ "')");
7.6查询统计模块
图7.9查询统计模块1
图7.10查询统计模块2
图7.11查询统计模块3
本模块的特点是能够进行多字段的模糊匹配查询，该功能的目的是在实际的生产中，进过时间的积累，可能会在数据库中维护大量的数据，如果这时还使用显示全部数据的话效率太低了，所以本系统特别定制了这个功能，一来提高了工作效率，二来还能避免操作员因为公司名称记不全而导致的错误。
界面设计代码：
public void actionPerformed(final ActionEvent e) {
String conName, conOperation, content;
List list = null;
conName = conditionName.getSelectedItem().toString().trim();
conOperation = conditionOperation.getSelectedItem().toString()
.trim();
content = conditionContent.getText().trim();
String sql = "select * from tb_gysInfo where ";
if (conName.equals("供应商全称")) {
if (conOperation.equals("等于"))
list = Dao.findForList(sql + "name='" + content + "'");
else
list = Dao.findForList(sql + "name like '%" + content
+ "%'");
} else {
if (conOperation.equals("等于")){
list = Dao.findForList(sql + "jc='" + content + "'");}
else{list = Dao.findForList(sql + "jc like '%" + content + "%'");}
}updateTable(list, dftm);}
7.7库存管理模块
图7.12库存盘点
图7.13价格调整
图7.14产品入库
图7.15商品出库
界面设计代码（价格调整界面）：
kcInfo.setDj(Double.valueOf(danJia.getText()));
kcInfo.setKcsl(Integer.valueOf(kuCunShuLiang.getText()));
int rs = Dao.updateKucunDj(kcInfo);
if (rs > 0)
JOptionPane.showMessageDialog(getContentPane(), "价格调整完毕。",
kcInfo.getSpname() + "价格调整”+JOptionPane.QUESTION_MESSAGE);
数据库代码：
价格调整：
public static int updateKucunDj(TbKucun kcInfo) {
return update("update tb_kucun set dj=" + kcInfo.getDj()
+ " where id='" + kcInfo.getId() + "'");
库存盘点：
public static TbSpinfo getSpInfo(Item item) {
String where = "spname='" + item.getName() + "'";
if (item.getId() != null)
where = "id='" + item.getId() + "'";
ResultSet rs = findForResultSet("select * from tb_spinfo where "
+ where);
TbSpinfo spInfo = new TbSpinfo();
7.8系统管理
图7.16管理员权限--操作员管理
图7.17操作员权限—操作员管理
图7.18更改密码
界面设计代码：（操作员管理）
if(!user.getQuan().equals("a")){
JOptionPane.showMessageDialog(getContentPane(), "您没有进行此项操作的权限");
8 系统测试
系统测试在整个系统开发的过程中是非常必要，不可忽视，且极为致命的一个环节。软件测试不仅仅是在系统做完了以后大致的测测系统功能是否都实现了，而是要多方面多角度的进行挖掘式测试，各种条件下，各种不同的权限都要一一覆盖到，不可马虎，因为在测试阶段发现的问题，它的修改成本是最小的，如果在后期的使用中发现了问题，就意味着已经有人遭受了损失，这很可能是致命的。其实在一个软件的生命周期中，除了运行和维护的时间，就是测试占的比例是最大的，远不是开发的比例可以相比的。
在本系统的测试中，最主要的目的就是在各种不同的条件下运行程序，尽最大可能，暴露出系统的所有的问题，在保证系统基本功能没有问题可以使用的情况下，界面，安全性等所有的方面都要考虑全备。在软件测试的这个环节我们可以分为三步走：模块测试。模块测试是测试本系统中六大模块的基本功能是否都已经实现了预期需求中的所有需求。看看在程序运行期间每个模块的状况是否良好，是否会产生意料之外的异常和ERROR，保证模块的健壮性。组装测试，在完成了模块测试后紧接着就是组装测试，我们这个系统是六大模块集合体，只有他们组合成一个整体，这个系统的功能才能真正实现。模块见是会互相调用的在组装测试阶段我们主要是测试各个模块间的调用是否是正确的，数据是否有冗余或者是产生脏数据等。最后一步，确认测试，在整个系统完成了以后，我们要从宏观上出发，从最基本的需求上出发，详细对照每一条需求，看看本系统是否完美切合了设计的初衷，是否完美的实现了所有的预期功能。
在测试的过程中，我发现了很多的错误，包括逻辑上的漏洞和界面上的BUG，我从多个角度分析了错误发生的根因，并成功的解决了错误。测试有三大方法，黑盒测试，白盒测试还有灰盒测试。黑盒测试在整个软件测试的过程中是最为常见，也最为实用的到一种测试的方法。本系统的测试大部分用的也是黑盒测试方法，这种测试方法主要就是完全抛开了系统的内部逻辑结构不管，完全从系统的功能方面入手，对整体的功能和性能进行测试，检验系统功能是否完备，安全性是否达到了用户的要求。
系统的安全性测试也是非常必要的，测试的主要方面有数据的安全性，权限的鉴定是否正确，程序是否能防御SQL注入攻击等等。数据的安全性主要是看看我们输入非法的数据，程序是否会将这些错误的数据入库，或者是否做了相应的校验等。也就是健壮性测试。SQL注入攻击是一种常见的数据库工具方式，它通过字符串的拼接直接获取用户的数据，危害性极大，为了应对这种攻击方式，我在登录的页面做了相应的校验，让攻击者无从下手，让我们的系统安全性得到了进一步的提高。
8.1登陆功能测试：
这个模块的测试主要是测试不同的用户是否能正确的登陆，并且是否能够正确的完成鉴权工作，初次之外，还要测试功能是否能预防SQL注入攻击。
图8.1登陆功能测试
测试成功：
图8.2登陆成功
8.2进货功能测试
这个模块的测试主要是测试进货单中的信息是否能够正确的维护到与之相对应数据库表中。并且在之后的调用中是否能正确的使用。
图8.3进货单未填写经手人
图8.4进货单未填写验收结论
图8.5进货单未填写入库商品
图8.6进货单入库完成
销售功能与此功能类似，由于篇幅限制，不在赘述
8.3查询统计功能测试
图8.7全称匹配查询
图8.8全称模糊查询
图8.9简称匹配查询
图8.10简称模糊查询
图8.11显示全部数据
商品查询与供应商查询与此功能类似，再次不在赘述。
8.4库存管理功能测试
图8.12库存盘点功能测试
图8.13价格调整功能测试
图8.14产品入库功能测试
图8.15商品出库功能测试
8.5系统管理功能测试
图8.16添加操作员
图8.17新添加的操作员登陆成功且没有添加操作员的权限
图8.18密码更改功能
至此，本系统的全部功能已经全部测试完毕，总体来看没有明显的BUG，所有预期的功能也全部都较好的实现了，界面简洁大方，适合陶瓷工厂作为日常的管理软件长期使用。但是还是有一些小瑕疵，可以通过以后的加工使之变得更加美观科学，更易于操作，测试工作到这里就结束了。
总 结
这一次的毕业设计我认为是可以充分的检验和锻炼自己的实际代码开发能力还有系统分析能力的大好机会，通过这次的毕业设计过程，也是对我这大学四年来所学习和积累的知识的一个考察。在大四学年，我在昆山杰普实习实训基地学到了很多的实用性很强的丰富的知识和各位指导老师多年来的开发项目的经验和技巧。学习的知识越来越多，同时积累的经验也越来越丰富，随着数据库和系统知识的了解，经过和各位老师和教授的指导后，我选择了XXX陶瓷工厂的进销存管理系统软件设计与实现这个课题。这是一个属于实际应用的课题,我所设计的进销存管理系统将实际应用到中国广大的陶瓷工厂的实际生产中去，对于初涉社会的我来说，无疑是一个非常好地锻炼的机会。在这次的毕业设计中我谨记老师给我的教诲，做一个诚实，认真负责的人，所以整个项目的编写和实现都由我一人独立实现，再次基础上，我还和两位指导老师进行了多次密切的交流，使得项目更加的科学和完善。我还非常的重视项目的基础调研工作，因为这个项目就是为了实际应用而开发，它是一个面向实际的项目。至此，本次XXX陶瓷工厂的进销存管理系统基本实现预想的功能，在基本的增删改查等功能完美实现之后，又加入了更改密码以及模糊查询等功能。在本次毕业设计的过程中，学校给予的支持力度使是非常大的，在进行毕业设计的这段时间里，学院配合我们进行了一个实习周报的完成，在这个报告中，会将自己每周在毕设时遇到的问题报告给指导老师，老师会及时回馈。这点在毕设时给予我们非常大的帮助。但是由于完成毕业设计的时候我正在实习单位参加实习工作，时间上有所短缺，所以系统还不是非常的完善，和市场上那些非常成熟的进销存管理系统相比起来仍是有一些不足之处的，今后我将利用学习和工作之余的时间，学习新的更适合本系统的技术还有设计理念，对XXX陶瓷工厂的进销存管理系统做多次的迭代深层次的开发学习，目标是在今后的三到四个月让整体的代码更加的完善，界面更加的易于操作，程序的可扩展性进一步的增强，成为一个能够和市场接轨，真正能够投入实际生产生活的完善的系统。
通过此次毕业设计，我确确实实学到了很多的东西，包括在学习书本知识上和动手时间上，之前在做课程设计的时候，虽然自己也成功地实现过一个个功能，但是毕竟是小组完成，或多或少会听取到别人的想法， 此次毕设则有很大的不同，基本上是有自己独立完成的，从前期的业务调查，知识准备，再到中间开发环境与工具的安装，到最后程序的编码实现，自己实实在在地完成了一个项目，激动之情无法言说。也由此，我在学习上，项目实践中能力得到了很大的提高。我相信此次经历在我以后的道路上将会是一笔伟大的财富。
参考文献
- 郑四华,彭文治,陈磊. 陶瓷企业进销存管理系统的分析与设计[J]. 景德镇高专学报,2006,(04):18-21.
- 黄华. 基于陶瓷行业ASP平台的协同办公系统的研究与实现[D]. 景德镇陶瓷学院,2007.
- 翁谦益.基于JavaSE的企业进销存管理系统设计与实现[D].厦门大学,2014.
- 马萌.基于Java语言的进销存管理系统[J].计算机与网络,2015,(19):61-64.
- 吴丽芝.小企业进销存管理系统的设计与实现[D].吉林大学,2015.
- 陶亮.进销存管理系统的设计与实现[D].电子科技大学,2010.
- 罗爱萍.仓库进销存管理系统的开发[D].电子科技大学,2006.
- 杨宏伟,李晶.JAVA程序员开发手册[M].北京：科学出版社，2006,243-377.
[10]孟小峰.数据库系统导论。机械工业出版社.2000
[11]张海藩．软件工程．清华大学出版社．2009
[12]Steven Holzner．Java技术内幕．机械工业出版社．2002
[13]RyanMA,VrugtA,LienhardJ,GilmoreD,DyerJ,SteeleD.Trendsinpurchasing,inventorycontrolprobed.[J].Medicalproductssales:MPS:theofficialjournaloftheAmericanSurgicalTradeAssociation,1985,16(4):.
[14]McAllisterJC.Purchasingandinventorycontrolsystemsmanagement.[J].Americanjournalofhospitalpharmacy,1984,41(2):.
[15]BaerDM,HawkinsB,TymoshukP,WashingtonR.Inventorycontrolandpurchasingatreducedcost.[J].MLO:medicallaboratoryobserver,1994,26(11):.
What is Java?
Java is designed to meet the challenges of application development in the context of heterogeneous, network-wide distributed environments. Paramount among these challenges is secure delivery of applications that consume the minimum of system resources, can run on any hardware and software platform, and can be extended dynamically.
Java originated as part of a research project to develop advanced software for a wide variety of network devices and embedded systems. The goal was to develop a small, reliable, portable, distributed, real-time operating platform. When the project started, C++ was the language of choice. But over time the difficulties encountered with C++ grew to the point where the problems could best be addressed by creating an entirely new language platform. Design and architecture decisions drew from a variety of languages such as Eiffel, SmallTalk, Objective C, and Cedar/Mesa. The result is a language platform that has proven ideal for developing secure, distributed, network based end-user applications in environments ranging from network-embedded devices to the World-Wide Web and the desktop.
The design requirements of Java are driven by the nature of the computing environments in which software must be deployed.
The massive growth of the Internet and the World-Wide Web leads us to a completely new way of looking at development and distribution of software. To live in the world of electronic commerce and distribution, Java must enable the development of secure, high performance, and highly robust applications on multiple platforms in heterogeneous, distributed networks.
Operating on multiple platforms in heterogeneous networks invalidates the traditional schemes of binary distribution, release, upgrade, patch, and so on. To survive in this jungle, Java must be architecture neutral, portable, and dynamically adaptable.
The Java system that emerged to meet these needs is simple, so it can be easily programmed by most developers; familiar, so that current developers can easily learn Java; object oriented, to take advantage of modern software development methodologies and to fit into distributed client-server applications; multithreaded, for high performance in applications that need to perform multiple concurrent activities, such as multimedia; and interpreted, for maximum portability and dynamic capabilities.
Together, the above requirements comprise quite a collection of buzzwords, so let’s examine some of them and their respective benefits before going on.
What’s completely new is the manner in which Java and its run-time system have combined them to produce a flexible and powerful programming system..
Developing your applications using Java results in software that is portable across multiple machine architectures, operating systems, and graphical user interfaces, secure, and high performance, With Java, your job as a software developer is much easier—you focus your full attention on the end goal of shipping innovative products on time, based on the solid foundation of Java. The better way to develop software is here, now, brought to you by the Java language platform.
Very dynamic languages like Lisp, TCL, and SmallTalk are often used for prototyping. One of the reasons for their success at this is that they are very robust—you don’t have to worry about freeing or corrupting memory.
Similarly, programmers can be relatively fearless about dealing with memory when programming in Java, The garbage collection system makes the programmer’s job vastly easier; with the burden of memory management taken off the programmer’s shoulders, storage allocation errors go away. Another reason commonly given that languages like Lisp, TCL, and SmallTalk are good for prototyping is that they don’t require you to pin down decisions early on—these languages are semantically rich.
Java has exactly the opposite property: it forces you to make explicit choices. Along with these choices come a lot of assistance—you can write method invocations and, if you get something wrong, you get told about it at compile time. You don’t have to worry about method invocation error.
The Java beginner must grasp 30 basic concepts
Basic concept
1.In OOP the only relations is what the object’s interface, such as the computer seller he leaves alone internal structure of electrical source, but he is only concerned about that whether the power will be supplied to you, also so long as know can or not but is not how and why.All procedures are make up of certain attribute and the behavior object, the different object visit invokes through the function invocation, between the object all intercommunion are invoke through the method invocation, By object data encapsulation, enhances reuse rate very much..
2.In OOP the most important thought is class, the class is the template ,is a blueprint, construct an object from a class, namely construct an instance of the class.
3. Encapsulation: is that combines the data and the behavior in a package) and hides the data the realization process to the object user, in an object data is called its instance field.
4.Through expands a class to obtain a new class is called inheritance, but all classes are constructed by the object super root class of expansion, super root class of as follows can make the introduction.
5.Object 3 principal characteristics
Behavior--- explained this object can make what.
Tate--- when the object exerts the method object reflection.
Dentity--- and other similar behavior objects discrimination symbols.
Each object has only indentity and among three characteristics they affect mutually.
6. Relations among classes:
Use-a:Dependent relation
Has-a:Polymerization relation
Is-a: inheritor relation -- example:A class has inherited B class, this time A class not only has B class of method, but also has its own method(Individuality exists in general character)
7.Structure object use structure:Structure proposing, the structure is one special method, the structure object and to its initialization.
Example:A Data class of structure calls Data
New Data () --- structure a new object, also initialize current time.
Data happyday=new Data () --- an object evaluates an variable happyday, thus enables this object to be used many times, here be stated the cause variable and the object variable are different.
New returns the value is a quotation.
Constructor characteristic:The constructor may have 0, one or many parameters
The constructor and the class have the same name
A class may have many constructor. The constructor has not returned value
The constructor always be together used with the new operator
8. Over loading: When many methods have the same name when includes the different parameter, then has the over loading Which method does the compiler have to choose invokes.
9.Package : Java allow one or many classes to become together as group, is called package, to organizing duty easily, the standard Java storehouse divides into many packages Java.Lang java.Util java, net and so on, the package is layered and all java packages are in java and in a javax package.
10. Extendable thought: permit to construct new class on existing classes , when you extend the class which already existed, then you reuse this class of method and the field, at the same time you might add the new method and the field in the new class.
11.Expandable class:The expandable class fully manifested is-a to extend the relations The form is:Class (subclass) extends (base class).
12. Multi-modality: In java, the object variable is multi-modality But in java does not support multiple extend.
13.Dynamic combine: the mechanism of invoking object method mechanism.
1) compiler examines object statement type and method name.
2) the compiler examines that method invokes parameter type.
3) static combine: If the method type is priavte static the final ,compiler can accurately know which method should invoke.
4) when the procedure runs and uses dynamic combine to invoke a method, the method edition which then hypothesized machine must invoke x the object actual type which aims at to match.
5) dynamic combine: is a very important characteristic, it can cause the procedure to change again may expand but does not need to translate has saved the code.
14.Final class:In order to prevent other people derive the new class from yours class, this class is cannot expanded.
15.The dynamic invocation spend longer time than the static invocation expenditure.
16.Abstract class:Stipulated or many abstract methods class of itself must define is abstract.
Example: Public abstract string getDescripition
17.In Java each class is be extended by object class.
18. equal and toString method in object class .
Equal uses in testing an object is whether equal with another object.
ToString returns to represent this object the string of character, each class can nearly over loading this method, in order to returns to the current condition the correct expression.
(The toString method is a very important method)
19.General programming:Any class of type all values all may replace with a object class of variable.
20.The array tabulates: The ArrayList dynamic array tabulates, is a class of storehouse, defines in java.In uitl package, but automatic control array size.
21.in class and class of object ,getclass method returns to the class type an example, when the procedure start contains can increase in the main method class, hypothesized confidential increase all classes which he needs, each increase class all must increase the class which it needs.
22.The class: class might dynamic operate the java code for the compilation the procedure to provide the formidable function reflection, this function was JavaBeans is specially useful, the use reflected Java to be able to support the VB programmer to be familiar with the use the tool.
procedure of analysis class ability is called the reflector, in Java to provide this function the package to call Java.Lang.The reflect reflection mechanism is extremely formidable.
1) when run analysis class ability.
2) when run searches observes a class of object.
3) realizes the general array operation code.
4) provides the method object.
But this mechanism mainly aims at the tool but not the application and the procedure.
In the reflection mechanism most important part is that permits class that you inspect structure. With to API includes:
Java.Lang.Reflect.Field returns to the field.
Java.Reflect.Method returns to the method.
Java.Lang.Reflect.Constructor returns to the parameter.
Method pointer: Java does not have the method pointer, makes a method address another method, may invoke it in behind, but the interface is the better solution.
23. interface: should showing class could do what but not to assign how to do, a class may realize one or many interfaces.
24.The interface is not a class, but is to conforms to a interface request class of set of standard.
If realizes a interface to need 2 steps:
1) the statement class needs to realize assigns the interface.
2) provides in the interface all methods definition.
Stated a class realizes a interface to need to use the implements key words
Class actionB implements Comparable its actionb needs to provide the CompareTo method, the interface is not the class, cannot use a new example interface.
25.A class only then a super class, but a class can realize many interfaces. In a Java important interface: Cloneable
26.The interface and call-back :to programs a commonly used pattern is call-back,in the pattern, you may refer when this class of pattern settled specific time occurs returns to adjusts on the object the method.
Example:ActionListener interface monitor.
Similar API includes:
Java.Swing.JOptionPane
Java.Swing.Timer
Java.Awt.Tookit
27.Object clone:The clone method is a object protection method, this meant your code cannot simple invoke it.
28.Inner class an inner class definition is the definition in another class.
The reason is:
1) an inner class object can visit founds its object realization, including private data.
2) about other classes in the same package in that, inner class can be hided.
3) the anonymous inner class may the very convenient definition accent.
4) uses the category to be possible the extremely convenient compilation event driver.
29.Agent class (proxy):
1) appointing all codes that interfaces request
2) all methods (toString equals) that object class define
30.Data type:Java is kind of emphasizing type language, each variable all must be declared its types at first, in java altogether has 8 basic types . four kinds are the long, two kinds are the float, one is the char, being used in the Unicode code char, Boolean.
附录二：中文翻译
什么是JAVA？
Java是被设计用来解决在上下文分布式的异构网络中应用程序开发的问题。在这些复杂问题中，首要的是安全发布应用程序、消耗最小的系统资源、可以在任何硬件和软件平台上运行以及被动态地扩展。
Java最初是作为研发方案的一部分而开发的，这个研究方案是为了给广阔多样的网络设备和嵌入式系统开发高级的软件。目标是开发一个小巧的、可靠性高的、可移植的、分布式的、实时的操作系统平台。当这个方案开始的时候，C++是精选的语言，但是过了一段时间，用C++语言遇到的困难也随之增长，解决这些问题最好的办法是创造一个全新的语言平台。设计和体系结构的决定汲取了多种语言，例如Eiffel、 SmallTalk,、Objective C以及 Cedar/Mesa。结果证明这个语言平台是理想的，对于开发一个可靠性高的、可移植的、分布式的、基于终端用户网络的应用程序在多种环境中广泛搜索从嵌入网络的设备到万维网和桌上型电脑。
Java的需求设计通过自然状态的，在软件必须被配置的处理环境中被推动的。
因特网和万维网的巨大发展导致我们完全地以新的情形着眼于开发和发行软件。对于全球电子化的商业和销售发行的存在，Java必须使安全的，高性能的和非常健壮的应用程序在多平台异构的，分布式的网络中开发。
在异构的网络中，多平台上运行会使传统配置的二进制发送、释放、更新、补丁等等无效。为了在这些问题中幸存下来，Java必须是体系结构中立的、可移植的以及可以被动态的修改。
为满足以上的需求而开发的Java系统是简单的，所以它能够被绝大多数的程序员进行编程；熟悉的，所以当前的程序员学习Java语言是简单的；面向对象的，为了利用现代的软件开发方法学和适合分布式的客户机/服务器应用程序；多线程的，为了高性能在应用程序中需要执行多个并发的活动,例如多媒体；解释的，为了最大极限的可移植和动态的容量。
同时，以上的需求完全是由收集的时髦词语组成的，所以在开始以前让我们来查看它们中的一些和它们的各自的优点。
什么是完全新的，样式风格在Java语言和它的运行系统结合它们来产生一个灵通的且强大的编程系统。
在软件中，用Java语言开发的你的应用程序可以在多种机器总体结构、操作系统和图形用户接口之间移植。运用Java语言，诸如软件开发者的工作就会变得简单的多——你会把你的全部精力都集中在最终的目标：准时运送革新的产品、基于可靠的构造的Java语言。较好的开发软件的方法在这里，现在，Java语言平台会带给你这些。
许多动态的语言像Lisp、TCL和 SmallTalk通常被应用于原型构造技术它们成功原因中的一个在于它们非常健壮——你没有必要去担心关于解除或破坏存储器。
同样的，程序员可以相对大胆的处理存储器，当在Java语言里面编程的时候。垃圾回收系统使程序员的工作大为容易，卸下了程序员肩上存储管理之负担，存储分配错误不再发生。
一般认为像Lisp, TCL, 和 SmallTalk这样一些语言十分适合于原型法的另一个理由，是因为它们不要求你受早期决定的约束——这些语言的语义是很丰富的。
Java语言有着严密的对应的属性：它促使你做出清楚的选择。伴随着这些选择带来了许多的协助——你可以写一个方法调用，而且如果你在编写时有一些错误的时候，在编译的时候将会被告知。你没有必要去担心关于方法调用的错误。
Java初学者需掌握的30个基本概念
基本概念：
1.OOP中唯一关系是什么是对象的接口，就像计算机的销售商不管电源内部结构是怎样的，它只关心能否给你提供电，也就是只要知道能或不能而不是知道怎样和为什么会有电。所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过封装对象数据，很大限度上提高复用率。
2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。
3.封装：就是把数据和行为结合起在一个包中，并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。
4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。
5.对象的3个主要特性：
Behavior——说明这个对象能做什么。
Tate——当对象施加方法时对象的反映。
Dentity——与其他相似行为对象的区分标志。
每个对象有唯一的indentity 而这3者之间相互影响。
6.类之间的关系：
use-a ：依赖关系
has-a ：聚合关系
is-a ：继承关系——例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法(个性存在于共性中)。
7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。
例:Data类的构造器叫Data。
New Data()——构造一个新对象，且初始化当前时间。
Data happyday=new Data()——把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者是不同的。
new返回的值是一个引用。
构造器特点:构造器可以有0个，一个或多个参数。
构造器和类有相同的名字。
一个类可以有多个构造器,构造器没有返回值,构造器总是和new运算符一起使用。
8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。
9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包Java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。
10.继承思想：允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。
11.扩展类：扩展类充分体现了is-a的继承关系，形式为：class (子类) extends (基类)。
12.多态：在java中，对象变量是多态的，而java中不支持多重继承。
13.动态绑定：调用对象方法的机制。
1）编译器检查对象声明的类型和方法名。
2）编译器检查方法调用的参数类型。
3）静态绑定：若方法类型为priavte static final 编译器会准确知道该调用哪个方法。
4）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。
5）动态绑定：是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。
14.final类：为防止他人从你的类上派生新类，此类是不可扩展的。
15.动态调用比静态调用花费的时间要长。
16.抽象类：规定一个或多个抽象方法的类本身必须定义为abstract。
例:：public abstract string getDescripition
17.Java中的每一个类都是从Object类扩展而来的。
18.object类中的equal和toString方法。
equal用于测试一个对象是否同另一个对象相等。
toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示(toString 方法是一个很重要的方法)。
19.通用编程：任何类类型的所有值都可以同object类性的变量来代替。
20.数组列表：ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小。
21.class类 object类中的getclass方法返回class类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。
22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。
能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大。
1）在运行时分析类的能力。
2）在运行时探察类的对象。
3）实现通用数组操纵代码。
4）提供方法对象。
而此机制主要针对是工具者而不是应用及程序。
反射机制中的最重要的部分是允许你检查类的结构.用到的API有：
java.lang.reflect.Field 返回字段。
java.reflect.Method 返回方法。
java.lang.reflect.Constructor 返回参数。
方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。
23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。
24.接口不是一个类，而是对符合接口要求的类的一套规范。
若实现一个接口需要2个步骤：
1）声明类需要实现的指定接口。
2）提供接口中的所有方法的定义。
声明一个类实现一个接口需要使用implements 关键字。
class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口。
25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable。
26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。
例:ActionListener 接口监听。
类似的API有：
java.swing.JOptionPane
java.swing.Timer
java.awt.Tookit
27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。
28.内部类：一个内部类的定义是定义在另一个内部的类。
原因是：
1）一个内部类的对象能够访问创建它的对象的实现，包括私有数据。
2）对于同一个包中的其他类来说，内部类能够隐藏起来。
3）匿名内部类可以很方便的定义回调。
4）使用内部类可以非常方便的编写事件驱动程序。
29.代理类(proxy)：
1）指定接口要求所有代码。
2）object类定义的所有的方法(toString equals)。
30.数据类型：Java是强调类型的语言，每个变量都必须先申明它的类型，java中总共有8个基本类型：4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型。
https://download.csdn.net/download/dwf1354046363/87813592
1140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
