精华内容
下载资源
问答
  • 编程基本概念
    千次阅读
    2006-10-16 08:55:00

    极限编程

    极限编程是价值而非实践驱动的高度迭代的开发过程。
    极限编程的价值:
    1、沟通(Communication):追求有效的沟通。
    2、简单(Simplicity):实现最简单的可行方案。
    3、反馈(Feedback):快速有效的反馈
    4、勇气(Courage):勇于放弃和重构
    基本原则:
    1、快速反馈(Rapid Feedback)
    2、假定简单(Assume Simplicity)
    3、递增改变(Incremental Change)
    4、拥抱改变(Embrace Change)
    5、质量产品(Quality Work)
    核心活动:

    需求->测试->编码->设计

    极限编程基本实践:


    1、小版本(Small Release)迭代
    2、规则游戏(Planning Game)(用例驱动)
    3、现场客户(On-Site Customer)
    4、隐喻(Metaphor)(统一术语)
    5、简单设计(Simple Design)
    6、重构(Refactoring)
    7、测试驱动开发(Test-Driven Development,TDD)
    8、持续集成(Continuous Integration)
    9、结对编程(Pair Programming)
    10、代码共有(Collective Code Ownership)
    11、编码标准(Coding Standards)
    12、每周40小时工作制

    极限编程的优点

    1、重视客户的参与
    2、重视团队合作和沟通
    3、制定计划前要做出合理预测
    4、让编程人员参与软件功能的管理
    5、重视质量
    6、简单设计
    7、高频率的重新设计和重构
    8、高频率及全面的测试
    9、递增开发
    10、连续的过程评估
    11、对过去的工作持续不断的检查

    极限编程的缺点

    1、以代码为中心,忽略了设计
    2、缺乏设计文档,局限于小规模项目
    3、对已完成工作的检查步骤缺乏清晰的结构
    4、质量保证依赖于测试
    5、缺乏质量规划
    6、没有提供数据的收集和使用的指导
    7、开发过程不详细
    8、全新的管理手法带来的认同度问题
    9、缺乏过渡时的必要支持
     

    更多相关内容
  • EXCEL编程基本概念.doc

    2021-09-29 13:09:22
    EXCEL编程基本概念.doc
  • C#网络编程 ( 基本概念和操作 ) - 引言 C#网络编程系列文章计划简单地讲述网络编程方面的基 础知识由于本人在这方面功力有限所以只能提供一些初步的入门知识希望能对刚开始学习的朋友提供一些帮助如果想要更加深入的...
  • 面向对象编程基本概念

    千次阅读 2018-04-18 15:41:53
    面向对象编程(OOP)为软件社区引入了一场革命,以帮助解决这些问题。 OOP专注于模块化,改变容忍度,代码重用,易于理解和分布式开发。今天大多数项目都使用面向对象的概念。由于C ++引入了OOP,因此用户体验已经...

    引言

     在软件工程的早期,史诗般的挣扎着项目的复杂性,增长以及管理大型开发团队的挑战。面向对象编程(OOP)为软件社区引入了一场革命,以帮助解决这些问题。 OOP专注于模块化,改变容忍度,代码重用,易于理解和分布式开发。今天大多数项目都使用面向对象的概念。

    由于C ++引入了OOP,因此用户体验已经产生了关于如何最好地利用OOP的更多知识。有很多关于面向对象的协议和更多的争论。应该鼓励哪些功能? C ++是否定义了哪些功能是面向对象的。

    随着重用和验证IP在硬件验证中变得流行,OOP是适用的。事实上,功能验证为重用提供了理想的条件,因为标准协议,系统甚至测试和有趣的事务序列都利用了OOP。

    设计大型软件应用程序

     传统上,程序被视为一系列功能的集合。这适用于小型应用程序,但阻碍重用程序的一个子集或利用分布式并行开发过程,其中不同的工程师拥有程序的不同方面。那么我们如何设计一个大型应用程序呢? OOP建议使用“分而治之”的方法,其中应用程序是一组相关的交互对象。例如,模拟交通的应用程序将涉及汽车,司机和交通信号灯,而不是为整个交通系统设计应用程序,我们应该专注于单独的模块以捕捉汽车,司机和交通灯操作。测试平台或验证项目也是如此。我们专注于最终构成测试平台的数据项或协议特定组件,而不是专注于完整的应用程序。

    OOP中的对象是什么?

     一个对象是一个实体,它拥有的数据和对这些数据进行操作的方法。每个对象都可以被看作是一个独立的小机器或者具有不同责任的角色。在我们的交通仿真例子中,汽车,司机和交通灯都是对象。

     分布式开发环境

     OOP面临的挑战之一是定义对象和它们之间的交互。最初的协议是让个人和团队合作的关键。这些对象通过商定的公共接口(合同)提供服务。其他对象可以使用这个公共API。对象内部实现可以独立开发和完善。语言提供信息隐藏设施,以限制对象使用公共方法。下图演示了两个在OOP环境中工作的开发人员,使用单独对象之间的协议接口。


                           OOP接口对象启用并行开发

    分离问题

     我们可以使用相同的对象来创建其他系统吗?或复制一个对象并将其用于不同的系统?这需要建立独立的对象。对象之间不应存在功能重叠。例如,我们的交通仿真例子也可能包括一条赛道。在一个典型的赛道上,没有交通信号灯,没有转向灯,而且赛车速度更快。如果一辆汽车的实施假定存在交通灯,则不能参与没有交通信号灯的赛道系统。同样,一个功能验证示例可以拥有一个不应该自行发送或提交给特定协议/驱动程序的数据包。如果是这样,它不能用于需要不同驱动协议或协议分层的环境中。

     类,对象和程序

     类定义了对象的抽象特征(属性)和行为(方法)。这是一个蓝图,允许创建一个或多个相同类型的对象。例如,可能有一个汽车类定义了汽车对象可以包含的所有东西。然后,一辆特殊的汽车,比如...... Plorsche,是汽车类的一个子类(专业化),具有超越普通汽车类的特殊属性。最后,汽车物体是具有特定颜色和引擎属性的汽车的特定实例,例如银色Plorsche轿跑车。可能有许多Plorsche汽车共享这些属性;所有这些都将成为Plorsche子类或汽车专业化的对象。

    对象保存运行时数据并用作程序的构建块。程序或应用程序实例化对象并触发它们的交互。


     注: SystemVerilog类与动态特性的Verilog模块实例不同。模块实例,它们的编号和层次结构是在Verilog中进行阐述时创建的,并且在整个模拟过程中都是静态的。对象可以在运行时根据请求创建。这允许创建模块化和优化的数据结构。在功能验证中,测试平台的构建过程是动态的,这使得它更加灵活。它使用程序流控制来实例化所需的测试台结构。根据需要,动态对象用于表示数据项(如数据包,帧或事务),并且通常会考虑其他环境变量值

     使用泛化和继承

     人类使用泛化来感知世界。汽车的抽象概念意味着:四个车轮,一个发动机,至少两个车门,一个方向盘等等。这种抽象能力使我们能够组织数据并实现有效的沟通。例如,你可以说“我开车让我的车昨天工作”,听众不需要你定义一辆车,谈论你驾驶的特定汽车,或者你驾驶的方式。这些细节是不必理解你简单陈述的意图

     面向对象编程使我们能够在软件设计中做同样的事情。您可以定义泛型类的概念,并使用继承来创建该抽象类的特化。跑车可能是通用汽车概念的专业化。除了拥有所有的汽车属性外,它还具有更大的马力,更好的操控性,并且经常吸引人们的注意力。用户可以表达所需的功能 - 例如,驾驶()汽车 - 而无需知道特定汽车中驾驶方式的具体细节。

    使用继承允许具有足够类似接口的对象共享实现代码。一个永远不应该实例化的父类 - 意味着它仅用于建模目的以便重用和抽象 - 被声明为一个虚类.


    创建紧凑可重用代码

     如果您在对象之间有重叠,请考虑创建一个抽象类来保存通用功能并派生一个类来捕获变体。这将减少开发和维护所需的代码量。例如,请求和响应数据包可能具有相似的属性,但请求中生成的数据是在响应中收集的,反之亦然。



    OOP中的多态

     程序可能需要以程序的方式操纵一组对象。例如,您可能想要一个汽车的抽象句柄,并在一个循环中调用数组中所有汽车的run()方法。每个汽车类都有不同的run()方法实现。对抽象类执行run()并执行特定run()的能力称为“多态性”。程序员不必提前知道对象的确切类型。下面的例子3-2演示了Plorsche和Flerrari汽车是如何从一个抽象运动车类派生的。多态性允许程序的print()任务持有一个指向可能包含Plorsche和Flerrari汽车的虚拟类数组的指针,但为每个项目执行正确的print()函数

     例3-2继承和多态


    Downcast

     想象一下,一辆具有飞行能力的新车被发明出来,而其他车辆则无法飞行。一个汽车使用者不希望发现他们的汽车在驶入鸿沟后不能飞行。在开始驾驶之前需要提前警告,以确保您的汽车能够飞行。在这种情况下,您需要在模拟开始之前获得编译时错误消息。例如,您不希望非法分配在执行两天后中断仿真。编译器强制用户在使用其一个子类型特征或属性之前明确地向下转换泛型引用。 (术语向下意味着在继承树中下降。)

    注:在我们的汽车示例中,用户需要明确声明指针用fly()方法持有汽车。将通用句柄分配给特定的句柄称为downcast。


    类库

     类库是用于加快系统实现的类的集合。用户可以通过定制它们来从库类派生新的类,或者只是实例化和使用它们,而不是从头开始实现。例子包括数学图书馆,图形图书馆,甚至是面向验证的图书馆。 UVM有一个类库。类库的一个重要优点是它编写了最佳实践并实现了标准化和重用。使用类库的缺点是需要学习类库规范。虽然类库带有API规范,但通过类库实现并了解功能和建议的实现是一种很好的做法。

    静态方法和属性

     对象具有保存其特定数据和状态的属性。例如,一个Plorsche状态可以被“驱动”,而一个不同的Plorsche可以被“停放”。但是,SystemVerilog支持属于一个类而不是特定实例的静态属性。即使没有实例存在,也可以访问这些属性,并允许多实例预订和设置。例如,您可以使用静态属性来计算特定类的实例数量。您也可以拥有可以操纵静态属性的静态方法。静态方法不能访问非静态属性,因为这些属性可能不存在。

    调用静态方法不涉及特定的实例,可以通过使用class_name :: method_name()来实现。 例如,我们可以使用这样的汽车静态方法:car::increment_counter()

    参数化类

     当需要用于不同数据类型或大小的类似逻辑时,使用参数化类。参数化类的经典用法适用于容器。以下示例显示了不同类型对象的容器。


    包和命名空间

     典型的应用程序利用来自多个来源的许多类。有可能某些类型,类或函数名称可能会发生冲突并导致编译错误。修改类和类型名称以获得唯一性的成本可能很大。此外,当使用加密的代码时,如验证IP(VIP),这个问题更具挑战性。

    为了避免全局名称空间发生冲突,面向对象的语言将添加包或名称空间功能。这为每个包定义创建了一个不同的范围。在不存在冲突的情况下,用户可以使用import命令将所有定义导入联合名称空间。如果存在冲突并且不可能包含导入,则用户可以导入特定类型或使用类的完全限定类型名称(包名称和类名称的组合)。

    例如,假设在我们的系统中,开发了两种类型的汽车类别(sports_car),一种是品牌A,另一种是品牌Z.没有包装,两个类别称为“sports_car”(来自品牌A和品牌Z各一个)无法编译

    在以下示例中,我们将包导入单个模块范围。 这是可能的,因为在包内与名称没有冲突。 您可以导入包中的所有符号,或者只使用不碰撞的选定符号。


     为所有可重用代码使用包至关重要,以便与其他包中的其他类似类共存并防止代码修改。

    软件设计模式

     软件问题的创造性解决方案可以产生随机的好处和后果。另外,已经证实的解决方案可以产生更一致的结果我们不反对创造力,但大多数验证挑战需要创造性和常识性,而不需要重新发明轮子。设计模式是软件设计中常见问题的一般可重复解决方案。 1995年出版的“设计模式:可重用面向对象软件的元素”(通常被称为“四人帮”或“GoF”一书)一书创造了术语设计模式,并成为面向对象的软件的重要来源,面向设计理论与实践。这些最为人所知的做法是在包含姓名,挑战,代码样本等的模板中捕获的。有关更多信息,请阅读Gamma,Helm,Johnson和Vlissides的“设计模式:可重用面向对象软件的元素”一书。

    软件设计模式:单例模式

    许多系统都要求系统资源只应该实例化一次。这可能是内存管理员,全球协调员或其他系统级协调员。问题是如何创建一个具有内置限制的类只能实例化一次?单例解决方案通过使构造函数专用于类来工作,从而防止类被实例化。实例化类的唯一方法是调用静态方法,该方法在首次调用时分配类的本地实例并返回调用者的对象句柄。对此静态方法的连续调用将返回实例化的实例句柄,而不分配新的类。 UVM库中的单例的一个示例是报告服务器具有受保护的构造函数,以将服务器的创建限制为单个实例

    软件设计反模式

     反模式,也称为陷阱,通常是对问题的不良软件解决方案进行彻底改造。这个词是由安德鲁柯尼希1995年创造的,受到了四人帮的启发。使用不良做法有多种原因。在某些情况下,它涉及缺乏计划;在其他情况下,在错误的情况下使用完美的解决方案,使其适得其反。与设计模式一样,反模式具有正式的模板,其名称,原因,含义等等。反模式还包括恢复过程(重构)以修补误用的实践。反模式的一个例子是“意大利面条”代码 - 源代码,它具有复杂和纠结的控制结构。有关更多信息,请阅读Brown,Marley,McCormick和Mowbray撰写的书籍“AntiPatterns:危机中的软件重构,体系结构和项目”

    为什么现有的面向对象方法不够?

     上面提到的是一些书籍,它们记录了多年来在面向对象编程方面积累和证实的经验。那么,为什么我们需要更多的方法?大多数通用概念适用于功能验证任务并且有效。但功能验证引入了独特的挑战,并且与软件开发不同。与每六个月发布的程序相反,功能验证的结果是最终测试,其中几项可能会在一天内创建。考虑下图中的测试平台以及使用它的三个测试。每个测试涉及测试平台的不同方面。它可能会改变配置,引入不同的序列,在生成的数据项上使用约束等来实现其目标。面向对象的编程不是为了这样的极端重用,也没有考虑到通过测试进一步修改类的开放性。


    面向方面的编程

     最近,软件设计模式已被批评为建议复杂的配方,而不是改进工具或语言。 OOPSLA(面向对象的程序设计,系统,语言和应用)是一个主要在美国举行的年度ACM会议,它主持了一个名为“四人帮”试验的小组。 Verisity引入了e语言来解决验证挑战,并使用这种内置解决方案而非设计模式。在面向方面的特性e面(这是面向对象的超集)的基础上,面向方面的编程提供了许多SystemVerilog语言限制的简单解决方案。在SystemVerilog UVM中,我们使用工厂解决方案,回调,字段宏,配置机制等等。在这些不是必需的。此外,e允许其他功能,例如覆盖范围和枚举类型扩展,用于数据项随机化的更强大的建模功能以及显着简化验证任务的其他语言功能。该行业在向其他HVL提供有限的AOP扩展方面做出了一些努力,但这些扩展受到限制,并且无法理解挑战和解决方案。我们只能希望SystemVerilog能够在某些时候采用这些功能并简化验证工作,从而为SystemVerilog用户群带来益处

    概要

     面向对象编程引入了一种处理大型软件应用程序复杂性的方法。它侧重于模块化,适应变化和重用,这是功能验证的关键。了解理论和动机是有益的,但是没有必要为了使用UVM库而掌握理论。使用UVM库的优点之一是它将最好的验证实践编入库基类,使您能够按照推荐的指示完成正确的事情

    展开全文
  • 主要介绍了jQuery的基本概念与高级编程的简单介绍,有需要的小伙伴可以参考下。
  • ros机器人编程(从基本概念到机器人应用程序编程实战)中英文两版ROS_Robot_Programming_CN ...... 10.1.ROS支持的机器人 283 10.2.TurtleBot3系列机器人 283 10.3.TurleBot3的硬件 284 10.4.TurtleBot3软件 287 ...
  • 【翻译】Java 面向对象编程基本概念

    千次阅读 2016-08-02 14:25:41
    【翻译】Java 面向对象编程基本概念 原文地址:Java OOPs Concepts  面向对象的理念包含了四个主要原则:抽象(abstraction)、封装(encapsulation)、继承(inheritance)和多态(polymorphism),这也是众所周知的面向...

    【翻译】Java 面向对象编程基本概念

            原文地址:Java OOPs Concepts
            面向对象的理念包含了四个主要原则:抽象(abstraction)、封装(encapsulation)、继承(inheritance)和多态(polymorphism),这也是众所周知的面向对象理念的四个支柱。抽象是暴露实体本质,而忽略一些无关细节的过程,以此来降低使用的复杂程度。封装是在一个实体中绑定数据和操作的过程。继承是从已有的类型衍生出一个新的类型,进而建立父类-子类关系。多态让一个实体在不同的上下文环境上呈现不同的状态。
    下面详细介绍上述四个面向对象的四个主要原则。

    一、 抽象(Abstraction)

            我们用现实世界中的场景来举例说明,抽象就变得很容易理解。例如:当我们去驾驶我们的汽车,我们不用关心汽车内部是如何工作的。我们需要关系的仅仅是汽车与我们交互的部分,如:方向盘、刹车踏板、油门踏板等。这些就是我们对汽车的抽象。
            在计算机科学中,抽象就是用语义的形式描述数据和程序,隐藏其实现细节。简单地说,抽象就是通过在真实世界中类似的东西间进行比较,来隐藏不相关的信息。

     抽象仅包含当前视角下类型的相关信息
    

    常见的抽象有如下两种形式
    1.数据抽象
            数据抽象是将多个细分的数据类型整合成一个复杂的数据类型。通常情况下,这个复合数据类型与现实世界的实体更为接近。如:一个Employee类型可以是一个拥有多个细分信息的复合数据类型。

    public class Employee {
        private Department department;
        private Address address;
        private Education education;
        //so on...
    }

            因此,如果我们想获取一个Employee的信息,我们只需要从Employee获取,正如我们在现实生活中一样。
    2.操作抽象
            操作抽象是通过内部的方法访问为一个复杂任务隐藏其内部的一系列动作。因此,任务的具体逻辑对使用者来说是隐藏的,并且可以在不影响使用者代码的情况对内部逻辑进行调整。

    public class EmployeeManager{
        public Address getPrefferedAddress(Employee e){
            //Get all address from database
            //Apply logic to determine which address is preferred
            //Return address.
        }
    }

            在上述的例子,如果后续我们需要调整方法逻辑让方法一直返回国内的地址,我们可以调整getPrefferedAddress()方法的实现逻辑,且使用者的代码不受影响。
            更多信息,参见:Understanding abstraction in Java

    二、封装(Encapsulation)

    将数据和方法包装至一个类型中,并通过访问控制隐藏相关的实现逻辑通常叫做封装。封装的结果是一个类型既包含了属性与包含了行为。封装的本质是实现了信息和实现的隐藏。

    "Whatever changes,encapsulate it" -- A famous design principle
    

    信息隐藏常通过使用访问控制关键字来实现(如:public,private,protected),实现隐藏常通过创建类型的接口实现。通过信息隐藏可以让设计人员在需求发生变更时自由地修改提供信息的实现逻辑。
    信息隐藏,示例:

    class InformationHiding{
        //Restrict direct access to inward data
        private List items = new ArrayList();
    
        //provide a way to access data - internal logic can safely be changed in future
        public List getItems(){
            //do something needed here...
            return items;
        }
    }

    实现隐藏,示例:

    interface ImplemenatationHiding{
        Integer sumAllItems(List items);
    }
    class InformationHiding implements ImplemenatationHiding{
        //Restrict direct access to inward data
        private List items = new ArrayList();
    
        //provide a way to access data - internal logic can safely be changed in future
        public List getItems(){
            //do something needed here...
            return items;
        }
    
        public Integer sumAllItems(List items){
            //Here you may do N number of things in any sequence
            //Which you do not want your clients to know
            //You can change the sequence or even whole logic
            //without affecting the client
        }
    }

            更多信息,参见:Encapsulation in Java

    三、继承(Inheritance)

            在Java中,继承是一个对象获取其父类对象属性和行为的一种机制,其本质是在类型之间建立父-子关系。在Java中,我们经常使用继承来实现代码的复用以及提升其可维护性。
            Java使用关键字extends来实现对类的继承。extends关键字表明我们从一个已有的类衍生出一个新的类型。Java使用超类(super class)术语来表示被继承的类,新的类称为子类(subclass)
            子类继承父类所有的非私有成员(属性、方法以及嵌套类)。构造函数不是类的成员,因此,构造函数不会被子类继承,但子类的构造函数可以触发父类的构造函数。
    示例

    public class Employee {
        private Department department;
        private Address address;
        private Education education;
        //so on...
    }
    
    class Manager extends Employee{
        private List<Employee> reportees;
    }

    四、多态(Polymorphism)

            多态指的是我们创建的函数或引用的对象在不同的运行上下文中表现出不同的行为状态。
    在Java中,从本质上来看,多态存在两个不同的类型:
    + 编译时多态(静态的绑定或方法重载)
    + 运行时多态(动态的绑定或方法重写)
            更多信息,参见:Java面向对象编程基本概念——多态

    展开全文
  • [061]深入浅出VC++串口编程基本概念.zip上位机开发VC串口学习资料源码下载[061]深入浅出VC++串口编程基本概念.zip上位机开发VC串口学习资料源码下载[061]深入浅出VC++串口编程基本概念.zip上位机开发VC串口...
  • C#程序设计 Programming in C# 1011028 主讲刘君瑞计算机学院 C#程序设计 Windows编程基本概念 1Windows编程基本概念 2消息与消息循环 1.Windows编程基本概念 人机界面HCI human-computer interface又称用户...
  • C#,网络编程基本概念,操作 C#,网络编程基本概念,操作 C#,网络编程基本概念,操作C#,网络编程基本概念,操作 C#,网络编程基本概念,操作C#,网络编程基本概念,操作 C#,网络编程基本概念,操作...
  • Python全栈(四)高级编程技巧之5.Socket编程-基本概念、UDP发送与接收数据.pdf
  • C#网络编程基本概念和操作
  • VC++串口编程(基本概念).pdf VC++串口编程(基本概念).pdf VC++串口编程(基本概念).pdf
  • 了解如何在NI LabVIEW 软件环境下进行工作。下载七大基本概念讲义,包括LabVIEW编程环境、图形化编程编程工具、错误调试与处理、数据类型和结构、执行结构等,学习LabVIEW编程的基本构件。
  • 深入浅出讲解了VC++串口编程基本概念,书中介绍了多种串口通信的方法,对初学者是个启发
  • Java Socket编程(一) Socket编程原理及基本概念

    万次阅读 多人点赞 2016-12-09 16:00:27
    介绍了Socket编程基本概念,并以UDP编程为例,给出示例。

    辛苦堆砌,转载请注明出处,谢谢!

              本篇文章完全是一个铺垫,是为了后面文章提供理论基础,没有这些基础,谈论Socket编程和后续的具体功能实现,都是纸上谈兵,所以还请很少接触Socket编程的看官耐心看完这篇文章,相信对各位有好处。

          看一下网络的分层结构,如下图:


    基于TCP/IP协议族的网络,被分为四层,分别为应用层,传输层,网际层以及网络接口层,每一层都设计了相应的协议,我们常用的一些协议(如HTTP,FTP等),都是属于应用层协议,他们大多是基于传输层的TCP,UDP设计出来的。

            我们的主角Socket,它是应用层之下,传输层之上的一个接口层,也就是操作系统提供给用户访问网络的系统接口,我们可以借助于Socket接口层,对传输层,网际层以及网络接口层进行操作,来实现我们不同的应用层协议,举几个例子,如HTTP是基于TCP实现的,ping和tracerouter是基于ICMP实现的,libpcap(用wireshare做过网络抓包的可能更熟悉)则是直接读取了网络接口层的数据,但是他们的实现,都是借助于Socket完成的。可见,对于应用层,我们想实现网络功能,归根究底都是要通过Socket来实现的,否则,我们无法访问处于操作系统的传输层,网际层以及网络接口层。考虑的本文以及本文之后的其他文章,我们暂时只关注Socket访问传输层的流程,其他的方面可以参看相关书籍,这里推荐《TCP/IP详解 卷一》以及《UNIX网络编程》(UNP),虽然是Linux C语言开发的书,但是对网络编程讲解的很透彻。这里也向这位大家致敬,虽英年早逝,留给大家的财富不可估量。

            再来了解一下TCP和UDP,两者最大的区别在于,TCP是可靠的,也就是说,我们通过TCP发送的数据,网络协议栈会保证数据可靠的传输到对端,而UDP是不可靠的,如果出现丢包,协议栈不会做任何处理,可靠性的保证交由应用层处理。因此,TCP的性能会比UDP低,但是可靠性会比UDP好很多。除此之外,两者在传输数据时,也有形式上的不同,TCP的数据是流,大家可以类比文件流,而UDP则是基于数据包,也就是说数据会被打成包发送,可能大家会有疑问,这个有什么差别吗?当然有,一个最大的问题就是,TCP没有数据边界,每次接收数据以字节为单位,如果想区分两次发送的数据,除非在数据中加入分割字符(如http的\r\n\r\n),否则,TCP无法区分数据边界,而UDP每次发送的数据都被打为一个独立的数据包,因此几次发送的数据边界很清晰,我们每次接收也是按照数据包为单位进行接收。对于不同的编程语言或平台,虽然Socket的接口可能不同,但是都提供了基于TCP发送数据的接口以及基于UDP发送数据的接口。

             另外,还有一个概念,对于一个Socket以 客户端的IP及端口号<=>服务器端的IP以及端口号 唯一标识。

            由于后面几篇文章基本上都是基于TCP的,所以这里为了让大家知道Socket是个什么东西,先以UDP为例,后面再详细了解基于TCP的Socket编程。我们使用Java Socket,基于UDP协议,实现字母的大写转换,整个流程是客户端发送字符串给服务器,服务器将字符串转换为全部大写后,发送回客户端,客户端进行显示。

            首先看一下服务器端的代码:

    package com.yjp.server;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.SocketException;
    import java.net.UnknownHostException;
    
    public class ToUpperUDPServer {
    	
    	//服务器IP
    	public static final String SERVER_IP = "127.0.0.1";
    	
    	//服务器端口号
    	public static final int SERVER_PORT = 10005;
    	
    	//最多处理1024个字符
    	public static final int MAX_BYTES = 1024;
    	
    	//UDP使用DatagramSocket发送数据包
    	private DatagramSocket serverSocket;
    	
    	/***
    	 * 启动服务器
    	 * @param 服务器监听的端口号,服务器ip无需指定,系统自动分配
    	 */
    	public void startServer(String serverIp, int serverPort) {
    		try {
    			//创建DatagramSocket
    			InetAddress serverAddr = InetAddress.getByName(serverIp);
    			serverSocket = new DatagramSocket(serverPort, serverAddr);
    			
    			//创建接收数据的对象
    			byte[] recvBuf = new byte[MAX_BYTES];
    			DatagramPacket recvPacket = new DatagramPacket(recvBuf , recvBuf.length);
    			
    			//死循环,一直运行服务器
    			while (true) {
    				//接收数据,会在这里阻塞,直到有数据到来
    				try {
    					serverSocket.receive(recvPacket);
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    				
    				
    				String recvStr = new String(recvPacket.getData(), 0, recvPacket.getLength());
    				
    				//拿到対端的ip和端口
    				InetAddress clientAddr = recvPacket.getAddress();
    				int clientPort = recvPacket.getPort();
    				
    				//回传数据
    				String upperString = recvStr.toUpperCase();
    				byte[] sendBuf = upperString.getBytes();
    				DatagramPacket sendPacket = new DatagramPacket(sendBuf, sendBuf.length, clientAddr, clientPort);
    				try {
    					serverSocket.send(sendPacket);
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    			
    		} catch (SocketException e) {
    			e.printStackTrace();
    		} catch (UnknownHostException e2) {
    			e2.printStackTrace();
    		} finally {
    			//记得关闭Socket
    			if (null != serverSocket) {
    				serverSocket.close();
    				serverSocket = null;
    			}
    		}
    	}
    	
    	public static void main(String[] args) {
    		ToUpperUDPServer server = new ToUpperUDPServer();
    		server.startServer(SERVER_IP, SERVER_PORT);
    	}
    }
    
    服务器通过static final常量公开了自己的ip地址以及端口号,还有可以处理的最大字符数,之后,基于给定的ip和port,创建Socket,开始接收数据,收到数据后,转化为大写,返回给客户端。

    再来看看客户端:

    package com.yjp.client;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.SocketException;
    import java.net.UnknownHostException;
    
    import com.yjp.server.ToUpperUDPServer;
    
    public class ToUpperUDPClient {
    	
    	private DatagramSocket clientSocket;
    	
    	public String toUpperRemote(String serverIp, int serverPort, String str) {
    		String recvStr = "";
    		
    		try {
    			//创建UDP Socket
    			clientSocket = new DatagramSocket();
    			
    			//向服务器发送数据
    			byte[] sendBuf;
    	        sendBuf = str.getBytes();
    	        InetAddress serverAddr = InetAddress.getByName(serverIp);
    	        DatagramPacket sendPacket 
    	            = new DatagramPacket(sendBuf ,sendBuf.length , serverAddr , serverPort);
    	        try {
    				clientSocket.send(sendPacket);
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    	        
    	        //接收服务器的响应
    	        byte[] recvBuf = new byte[ToUpperUDPServer.MAX_BYTES];
    	        DatagramPacket recvPacket
    	            = new DatagramPacket(recvBuf , recvBuf.length);
    	        try {
    				clientSocket.receive(recvPacket);
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    	        
    	        //显示响应
    	        recvStr = new String(recvPacket.getData() , 0 ,recvPacket.getLength());
    		} catch (SocketException e1) {
    			e1.printStackTrace();
    		} catch (UnknownHostException e2) {
    			e2.printStackTrace();
    		} finally {
    			if (null != clientSocket) {
    				clientSocket.close();
    				clientSocket = null;
    			}
    		}
    		
    		return recvStr;
    	}
    	
    	public static void main(String[] args) {
    		ToUpperUDPClient client = new ToUpperUDPClient();
    		String recvStr = client.toUpperRemote(ToUpperUDPServer.SERVER_IP, ToUpperUDPServer.SERVER_PORT, "aaaAAAbbbBBBcccCCC");
    		System.out.println("收到:" + recvStr);
    	}
    }
    

    客户端通过借助于服务器端的常量,获知服务器的IP以及端口号,然后向该服务器发送字符串,然后接收服务器的响应,输出响应,响应结果如下所示:

    收到:AAAAAABBBBBBCCCCCC



    展开全文
  • 初学语音编程的扫盲级资料 初学语音编程的扫盲级资料
  • GPU编程--OpenCL基本概念

    万次阅读 多人点赞 2018-05-23 21:24:22
    基本概念 编写OpenCL程序的基本步骤 参考博文 一、背景 在过去利用GPU对图像渲染进行加速的技术非常成熟,因为GPU是典型的单指令多数据(SIMD)的体系结构,擅长大规模的并行计算;而CPU是多指令单...
  • 小组内对代码大全学习的资料,包含的是程序撰写的基本概念
  • 新学编程之掌握基本概念

    万次阅读 多人点赞 2021-02-25 10:59:25
    1. 为什么要学习基本概念 2. 如何学习基本概念 2.1 理解基本概念的字面意思 2.1.1 学习神器一 2.1.2 学习神器二 ...3. 编程基本概念 3.1 Python vs Anaconda 3.2 变量 3.3 Unicode 和 UTF-8 的不同之处.........
  • 面向对象程序设计的基本概念

    千次阅读 2020-06-30 16:56:24
    1. 面向对象程序设计的基本概念 Java是一种面向对象的编程语言。面向对象编程,英文是Object-Oriented Programming,简称OOP。 那什么是面向对象编程? 面向对象其实是现实世界模型的自然延伸。可以将现实世界中的...
  • “Client - Server”模型的操作概念可以类比我们用淘宝进行购物的操作,每一次的在手机淘宝上的操作都是作为客户端向淘宝服务器发送请求并且拿到响应消息的例子 过程: 打开淘宝时,会向淘宝服务器发送一个购买辣条...
  • 一、响应式编程基本介绍

    千次阅读 2021-07-31 14:30:20
    什么是响应式编程
  • MFC界面编程基础(00):基本概念

    万次阅读 多人点赞 2018-12-24 21:20:17
    基本概念解释 我们在编写标准C程序的时候,经常会调用各种库函数来辅助完成某些功能:初学者使用得最多的C库函数就是printf了,这些库函数是由你所使用的编译器厂商提供的。在Windows平台下,也有类似的函数可供...
  • Linux的基本概念和特点

    万次阅读 2021-06-21 23:40:13
    Linux基本成分 Linux的特点 Linux优点 Linux基本成分 1) 文件系统 提供计算机存储信息的结构,信息存储在文件中,文件主要存储在计算机的内部硬盘里,在目录的分层结构中组织文件。文件系统为操作系.
  • 【网络编程知识】什么是Socket?概念及原理分析

    千次阅读 多人点赞 2022-03-15 15:46:15
    套接字 是通信的基石,是支持TCP/IP协议的路通信的基本操作单元。可以将套接字看作不同主机间的进程进行双间通信的端点,它构成了单个主机内及整个网络间的编程界面。套接字存在于通信域中,通信域是为了处理一般的...
  • JAVA课件网络编程概念

    2014-01-06 23:05:45
    网络编程基础教程,主要介绍网络编程基本概念,JAVA类
  • 面向对象的基本概念

    千次阅读 2016-04-14 20:35:47
    面向对象包括3部分:面向对象分析(Object Oriented ...面向对象编程的两个重要概念是类和对象。 类 类是变量与作用这些变量的方法集合,事物都具有其自身的属性和方法,通过这些属性和方法可以将不同的物质区分开来。
  • 编程范式是计算机语言编程的一种需要编程者遵循的基本风格与规范模式。如果说每一个编程者进行的编程是在创造一个依托于计算机而存在的虚拟世界,那么编程范式就是这个虚拟世界所采用的世界观与创造世界的方法论。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 631,518
精华内容 252,607
关键字:

编程基本概念

友情链接: engine.zip