信息安全的基本要素：保密性、完整性、可用性、可控性、不可否认性。
 
（1） 保密性
 
      信息不被透露给非授权用户、实体或过程。保密性是建立在可靠性和可用性基础之上，常用保密技术有以下几点：
 ① 防侦收（使对手收不到有用的信息）
 ② 防辐射（防止有用信息以各种途径辐射出去）
 ③ 信息加密（在密钥的控制下，用加密算法对信息进行加密处理，即使对手得到了加密后的信息也会因没有密钥而无法读懂有用信息）
 ④ 物理保密（使用各种物理方法保证信息不被泄露）
 
（2） 完整性
 
      在传输、存储信息或数据的过程中，确保信息或数据不被非法篡改或在篡改后被迅速发现，能够验证所发送或传送的东西的准确性，并且进程或硬件组件不会被以任何方式改变，保证只有得到授权的人才能修改数据。
 完整性服务的目标是保护数据免受未授权的修改，包括数据的未授权创建和删除。通过如下行为，完成完整性服务：
 ① 屏蔽，从数据生成受完整性保护的数据。
 ② 证实，对受完整性保护的数据进行检查，以检测完整性故障。
 ③ 去屏蔽，从受完整性保护的数据中重新生成数据。
 
（3） 可用性
 
      让得到授权的实体在有效时间内能够访问和使用到所要求的数据和数据服务，提供数据可用性保证的方式有如下几种：
 ① 性能、质量可靠的软件和硬件。
 ② 正确、可靠的参数配置。
 ③ 配备专业的系统安装和维护人员。
 ④ 网络安全能得到保证，发现系统异常情况时能阻止入侵者对系统的攻击。
 
（4） 可控性
 
      指网络系统和信息在传输范围和存放空间内的可控程度。是对网络系统和信息传输的控制能力特性。使用授权机制，控制信息传播范围、内容，必要时能恢复密钥，实现对网络资源及信息的可控性。
 
（5） 不可否认性
 
      对出现的安全问题提供调查，是参与者（攻击者、破坏者等）不可否认或抵赖自己所做的行为，实现信息安全的审查性。

区块链具有去中心化、不可篡改、不可逆、匿名等特性。
去中心化：因为整个网络没有中心统治者。系统依靠的是网络上多个参与者的公平约束，所以任意每几个节点的权利和义务都是均等的，而且每一个节点都会储存这个区块链上所有数据。即使该节点被损坏或遭受攻击，仍然不会对账簿造成任何威胁。
不可篡改：确保信息或合约无法伪造。账簿在某个人或某几人手上，造假的可能性就非常高，但每个人手里都有一本账簿，除非整个游戏里超过 51% 的人都更改某一笔账目，否则任何的篡改都是无效的，这也是集体维护和监督的优越性。
不可逆：区块链上的信息必须不可撤销，不能随意销毁。系统是开源的，整个系统都必须是公开透明的，因此某笔交易被全网广播以后，达到 6 个确认以上就成功记录在案了，且不可逆转不可撤销。注: imToken 是 12 个区块确认。

匿名性：各区块节点的身份信息不需要公告或验证, 信息传递可以匿名进行。举个简单的例子, 就是你在区块链上向一个钱包地址发起交易, 但是却无法知道这个地址背后确切对应的是那一个人, 或者你的私钥被某一个黑客盗窃了, 无法从一个钱包地址中得知黑客是谁。

透切理解面向对象三大基本特性是理解面向对象五大基本原则的基础.
 

三大特性是：封装,继承,多态  
 
所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。
 

所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
 
 
 
所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
 

五大基本原则 
单一职责原则SRP(Single Responsibility Principle)
是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。

开放封闭原则OCP(Open－Close Principle) 
一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，
那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。

替换原则(the Liskov Substitution Principle LSP) 
子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，
也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。

依赖原则(the Dependency Inversion Principle DIP) 具体依赖抽象，上层依赖下层。假设B是较A低的模块，但B需要使用到A的功能，
这个时候，B不应当直接使用A中的具体类： 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口：这样就达到
了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件，而编译B时同样要直接包含到A的cpp文件。
 

接口分离原则(the Interface Segregation Principle ISP) 
模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来

 
 
  
 
  

   作者：
   Leo Chin
  
 
  
 
  

   出处：
   
   http://www.cnblogs.com/hnrainll/
  
 

阅读数：634
 
 
面向对象的三个基本特征是：封装、继承、多态
 
 
 
封装
封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
 
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
 
在Java中类中成员的属性有：public， protected， <default>， private，这四个属性的访问权限依次降低。
 
 
 
2.继承
 
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
 
通过继承创建的新类称为“子类”或“派生类”。
 
被继承的类称为“基类”、“父类”或“超类”。
 
继承的过程，就是从一般到特殊的过程。
 
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
 
在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
 
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
 
Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；
 
Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
 
Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
 
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
 
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
 
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
 
 
 
3.多态
 多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
 
实现多态，有二种方式，覆盖，重载。
 
覆盖，是指子类重新定义父类的虚函数的做法。
 
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
 
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
 
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
 
 
 
 
 
概念讲解
 
泛化（Generalization）
 
 
 
 
图表 1 泛化
 
在上图中，空心的三角表示继承关系（类继承），在UML的术语中，这种关系被称为泛化（Generalization）。Person(人)是基类，Teacher(教师)、Student(学生)、Guest(来宾)是子类。
 
若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。
 
例如，教师是人，Teacher 是Person的“一种”（a kind of ）。那么类Teacher可以从类Person派生（继承）。
 
如果A是基类，B是A的派生类，那么B将继承A的数据和函数。
 
如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。
 
若在逻辑上B是A的“一种”（a kind of ），则允许B继承A的功能和属性。
 
 
 
聚合（组合）
 
 
图表 2 组合
 
若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。
 
例如，眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。
 
 
 
聚合的类型分为无、共享(聚合)、复合(组合)三类。
 
 
 
聚合（aggregation）
 
 
 
 
图表 3 共享
 
上面图中，有一个菱形（空心）表示聚合（aggregation）（聚合类型为共享），聚合的意义表示has-a关系。聚合是一种相对松散的关系，聚合类B不需要对被聚合的类A负责。
 
 
 
组合（composition）
 
 
图表 4 复合
 
这幅图与上面的唯一区别是菱形为实心的，它代表了一种更为坚固的关系——组合（composition）（聚合类型为复合）。组合表示的关系也是has-a，不过在这里，A的生命期受B控制。即A会随着B的创建而创建，随B的消亡而消亡。
 
 
 
依赖(Dependency)
 
 
图表 5 依赖
 
这里B与A的关系只是一种依赖(Dependency)关系，这种关系表明，如果类A被修改，那么类B会受到影响。
 
 
 
 
 
 
 
 
 
 
 
面向对象五大原则：
 
(1)单一职责原则（Single-Resposibility Principle）
 
 
 
•一个类应该仅有一个引起它变化的原因
 
职员类例子： 比如在职员类里，将工程师、销售人员、销售经理这些情况都放在职员类里考虑，其结果将会非常混乱，在这个假设下，职员类里的每个方法都要ifelse判断是哪种情况，从类结构上来说将会十分臃肿，并且上述三种的职员类型，不论哪一种发生需求变化，都会改变职员类！这个是大家所不愿意看到的！
 
 
 
(2)开放封闭原则（Open-Closed principle）
 
 
 
•对扩展是开放的，对更改是封闭的！
 
变化来临时，如果不必改动软件实体裁的源代码，就能扩充它的行为，那么这个软件实体设计就是满足开放封闭原则的。如果说我们预测到某种变化，或者某种变化发生了，我们应当创建抽象类来隔离以后发生的同类变化。
 
 
 
(3)里氏替换原则（Liskov-Substituion Principle）
 
 
 
•子类可以替换父类并且出现在父类能够出现的任何地方,贯彻GOF倡导的面向接口编程
 
在这个原则中父类应尽可能使用接口或者抽象类来实现！
 
子类通过实现了父类接口，能够替父类的使用地方！
 
通过这个原则，我们客户端在使用父类接口的时候，通过子类实现！
 
意思就是说我们依赖父类接口，在客户端声明一个父类接口，通过其子类来实现
 
这个时候就要求子类必须能够替换父类所出现的任何地方，这样做的好处就是，在根据新要求扩展父类接口的新子类的时候而不影响当前客户端的使用！
 
 
 
(4)依赖倒置原则（Dependecy-Inversion Principle）
 
 
 
•传统的结构化编程中，最上层的模块通常都要依赖下面的子模块来实现，也称为高层依赖低层！
 
所以DIP原则就是要逆转这种依赖关系，让高层模块不要依赖低层模块，所以称之为依赖倒置原则！
 
 
 
(5)ISP 接口隔离原则(Interface-Segregation Principle)
 
 
 
•使用多个专门的接口比使用单个接口要好的多！
 
这个我有体会，在我实际编程中，为了减少接口的定义，将许多类似的方法都放在一个接口中，最后发现，维护和实现接口的时候花了太多精力，而接口所定义的操作相当于对客户端的一种承诺，这种承诺当然是越少越好，越精练越好，过多的承诺带来的就是你的大量精力和时间去维护！