面向抽象类编程思想强化

最新推荐文章于 2024-04-08 19:00:00 发布
最新推荐文章于 2024-04-08 19:00:00 发布
阅读量644 收藏 1
点赞数
分类专栏： C++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbs375/article/details/52662889
版权

企业信息系统框架集成第三方产品

案例背景：一般的企业信息系统都有成熟的框架。软件框架一般不发生变化，能自由的集成第三方厂商的产品。

案例需求：请你在企业信息系统框架中集成第三方厂商的Socket通信产品和第三方厂商加密产品。

                     1.第三方厂商的Socket通信产品：完成两点之间的通信；

                     2.第三方厂商加密产品：发送数据时采用des加密；数据接收到时解密。

案例要求： 1）能支持多个厂商的Socket通信产品入围

2）能支持多个第三方厂商加密产品的入围

3）企业信息系统框架不轻易发生变化

 需求实现

思考1：企业信息系统框架、第三方产品如何分层

思考2：企业信息系统框架，如何自由集成第三方产品

（软件设计：模块要求松、接口要求紧）

思考3：软件分成以后，开发企业信息系统框架的程序员，应该做什么？

第三方产品入围应该做什么？

系统架构


 编码实现

分析有多少个类 CSocketProtocol  CSckFactoryImp1 CSckFactoryImp2

CEncDesProtocol  HwEncdes  ciscoEncdes

1、 定义 CSocketProtocol  抽象类

2、 编写框架函数

3、 编写框架测试函数

4、 厂商1（CSckFactoryImp1）实现CSocketProtocol、厂商2（CSckFactoryImp1）实现CSocketProtocol

5、 抽象加密接口（CEncDesProtocol）、加密厂商1(CHwImp)、加密厂商2(CCiscoImp))，集成实现业务模型

6、 框架（c语言函数方式，框架函数；c++类方式，框架类）

 几个重要的面向对象思想

继承-组合（强弱）

注入

控制反转 IOC

MVC

面向对象思想扩展aop思想

aop思想是对继承编程思想的有力的补充

编码实现：

CSocketProtocol.h

#pragma once
#include <iostream>

using namespace std;

class CSocketProtocol  
{
public:
	CSocketProtocol()
	{
		;
	}
	virtual ~CSocketProtocol()
	{

	}
	//初始化
	virtual int cltSocketInit() = 0; 
	//发报文
	virtual int cltSocketSend(unsigned char *buf,int buflen) = 0; 
	//接收报文
	virtual int cltSocketRev(unsigned char *buf,int *buflen) = 0; 
	//客户端释放资源
	virtual int cltSocketDestory() = 0;
protected:
private:
};
CSckFactoryImp1.h 
#pragma once
#include <iostream>
#include "CSocketProtocol.h"

using namespace std;

class CSckFactoryImp1 : public CSocketProtocol 
{
public:
	CSckFactoryImp1()
	{

	}
	~CSckFactoryImp1()
	{
		if (p!=NULL)
		{
			delete[] p;
		}
	}
	//初始化
	virtual int cltSocketInit() ; 
	//发报文
	virtual int cltSocketSend(unsigned char *buf,int buflen) ; 
	//接收报文
	virtual int cltSocketRev(unsigned char *buf,int *buflen) ; 
	//客户端释放资源
	virtual int cltSocketDestory();
protected:
private:
	unsigned char *p;
	int len;
};

EncDesProtocol.h 

#pragma once

class CEncDesProtocol
{
public:
	CEncDesProtocol()
	{

	}
	virtual ~CEncDesProtocol()
	{

	}
	virtual int EncData(unsigned char *plain,int plainlen,unsigned char *cryptdata,int *cryptlen) = 0;
	virtual int DecData(unsigned char *cryptdata,int cryptlen,unsigned char *plain,int *plainlen) = 0;
};

des.h 

/*********************************************************
 *  des.h
 *  用户使用des算法头文件
 *    
 *********************************************************/
#ifndef _OPENDESS_H_
#define _OPENDESS_H_

#ifdef __cplusplus
extern "C" {
#endif

/* 厂商甲根据 "CEncDesProtocol.h" 里头定义的加密解密抽象层，实现的接口 */

//加密数据（encrypt：加密）
//pInData：明文数据
//nInDataLen：明文数据长度
//pOutData：加密后的数据
//pOutDataLen：加密数据的长度
int DesEnc(
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen);


//解密数据(decrypt：解密)
//pInData：密文数据
//nInDataLen：密文数据长度
//pOutData：解密后的数据
//pOutDataLen：解密数据的长度
int DesDec(
       unsigned char *pInData,
       int            nInDataLen,
       unsigned char *pOutData,
       int           *pOutDataLen);

#ifdef __cplusplus
}
#endif

#endif

HwEncdes.h 

#pragma once
#include "EncDesProtocol.h"


class HwEncdes : public CEncDesProtocol
{
public:
	HwEncdes(void);
	~HwEncdes(void);
	virtual int EncData(unsigned char *plain,int plainlen,unsigned char *cryptdata,int *cryptlen);
	virtual int DecData(unsigned char *cryptdata,int cryptlen,unsigned char *plain,int *plainlen);
};
CSckFactoryImp1.cpp 
#pragma once
#include <iostream>
#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"

using namespace std;

//初始化
int CSckFactoryImp1::cltSocketInit()
{
    this->p = NULL;
    this->len = 0;

    return 0;
}
//发报文
int CSckFactoryImp1::cltSocketSend(unsigned char *buf,int buflen)
{
    p = new unsigned char[buflen];
    
    if (p==NULL)
    {
        return -1;
    }
    //p =(unsigned char *)p
    memcpy(p,buf,buflen);
    this->len = buflen;

    return 0;
}
//接收报文
int CSckFactoryImp1::cltSocketRev(unsigned char *buf,int *buflen)
{
    if (buf==NULL||buflen==NULL)
    {
        return -1;
    }
    memcpy(buf,p,this->len);
    *buflen = this->len;
    return 0;
}
//客户端释放资源
int CSckFactoryImp1::cltSocketDestory()
{
    if (this->p!=NULL)
    {
        delete[] p;
        this->len = 0;
        this->p =NULL;
    }
    return 0;
}

des.cpp 

/******************************************************
 *
 *  des.c
 *  common des......
 *
 ******************************************************/
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "des.h"

/*********************************************************
  data type definition for Des;
**********************************************************/
#define EN0    0
#define DE1    1

#define DES_KEYBYTES    128
#define DES_KEYLONGS    32
#define DES_BLOCKLEN    8

typedef struct {
    unsigned char ek[DES_KEYBYTES];
    int    ekLen;
    unsigned char dk[DES_KEYBYTES];
    int    dkLen;
    unsigned char CbcCtx[DES_BLOCKLEN];
} DES_CTX;

typedef struct {
    unsigned char ek1[DES_KEYBYTES];
    int    ek1Len;
    unsigned char dk1[DES_KEYBYTES];
    int    dk1Len;
    unsigned char ek2[DES_KEYBYTES];
    int    ek2Len;
    unsigned char dk2[DES_KEYBYTES];
    int    dk2Len;
    unsigned char CbcCtx[DES_BLOCKLEN];
    //int    IsFirstBlock;
} DES3_CTX;


static unsigned char pc1[56] = {
    56, 48, 40, 32, 24, 16,  8,  0, 57, 49, 41, 33, 25, 17,
     9,  1, 58, 50, 42, 34, 26, 18, 10,  2, 59, 51, 43, 35,
    62, 54, 46, 38, 30, 22, 14,  6, 61, 53, 45, 37, 29, 21,
    13,  5, 60, 52, 44, 36, 28, 20, 12,  4, 27, 19, 11,  3 };

static unsigned char pc2[48] = {
    13, 16, 10, 23,  0,  4,         2, 27, 14,  5, 20,  9,
    22, 18, 11,  3, 25,  7,     15,  6, 26, 19, 12,  1,
    40, 51, 30, 36, 46, 54,        29, 39, 50, 44, 32, 47,
    43, 48, 38, 55, 33, 52,     45, 41, 49, 35, 28, 31 };

static unsigned short bytebit[8] = {0200,0100,040,020,010,04,02,01 };
static unsigned char totrot[16] = {1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28};
static unsigned long bigbyte[24] = {
    0x800000L,    0x400000L,    0x200000L,    0x100000L,
    0x80000L,    0x40000L,    0x20000L,    0x10000L,
    0x8000L,    0x4000L,    0x2000L,    0x1000L,
    0x800L,        0x400L,        0x200L,        0x100L,
    0x80L,        0x40L,        0x20L,        0x10L,
    0x8L,        0x4L,        0x2L,        0x1L    };

//insert digits
static unsigned long SP1[64] ={
       0x01010400l,0x00000000l,0x00010000l,0x01010404l,
       0x01010004l,0x00010404l,0x00000004l,0x00010000l,
       0x00000400l,0x01010400l,0x01010404l,0x00000400l,
       0x01000404l,0x01010004l,0x01000000l,0x00000004l,
       0x00000404l,0x01000400l,0x01000400l,0x00010400l,
       0x00010400l,0x01010000l,0x01010000l,0x01000404l,
       0x00010004l,0x01000004l,0x01000004l,0x00010004l,
       0x00000000l,0x00000404l,0x00010404l,0x01000000l,
       0x00010000l,0x01010404l,0x00000004l,0x01010000l,
       0x01010400l,0x01000000l,0x01000000l,0x00000400l,
       0x01010004l,0x00010000l,0x00010400l,0x01000004l,
       0x00000400l,0x00000004l,0x01000404l,0x00010404l,
       0x01010404l,0x00010004l,0x01010000l,0x01000404l,
       0x01000004l,0x00000404l,0x00010404l,0x01010400l,
       0x00000404l,0x01000400l,0x01000400l,0x00000000l,
       0x00010004l,0x00010400l,0x00000000l,0x01010004l };
       
       
static unsigned long SP2[64]={
       0x80108020l,0x80008000l,0x00008000l,0x00108020l,
       0x00100000l,0x00000020l,0x80100020l,0x80008020l,
       0x80000020l,0x80108020l,0x80108000l,0x80000000l,
       0x80008000l,0x00100000l,0x00000020l,0x80100020l,
       0x00108000l,0x00100020l,0x80008020l,0x00000000l,
       0x80000000l,0x00008000l,0x00108020l,0x80100000l,
       0x00100020l,0x80000020l,0x00000000l,0x00108000l,
       0x00008020l,0x80108000l,0x80100000l,0x00008020l,
       0x00000000l,0x00108020l,0x80100020l,0x00100000l,
       0x80008020l,0x80100000l,0x80108000l,0x00008000l,
       0x80100000l,0x80008000l,0x00000020l,0x80108020l,
       0x00108020l,0x00000020l,0x00008000l,0x80000000l,
       0x00008020l,0x80108000l,0x00100000l,0x80000020l,
       0x00100020l,0x80008020l,0x80000020l,0x00100020l,
       0x00108000l,0x00000000l,0x80008000l,0x00008020l,
       0x80000000l,0x80100020l,0x80108020l,0x00108000l };
       
       
static unsigned long SP3[64]={ 
       0x00000208l,0x08020200l,0x00000000l,0x08020008l,
       0x08000200l,0x00000000l,0x00020208l,0x08000200l,
       0x00020008l,0x08000008l,0x08000008l,0x00020000l,
       0x08020208l,0x00020008l,0x08020000l,0x00000208l,
       0x08000000l,0x00000008l,0x08020200l,0x00000200l,
       0x00020200l,0x08020000l,0x08020008l,0x00020208l,
       0x08000208l,0x00020200l,0x00020000l,0x08000208l,
       0x00000008l,0x08020208l,0x00000200l,0x08000000l,
       0x08020200l,0x08000000l,0x00020008l,0x00000208l,
       0x00020000l,0x08020200l,0x08000200l,0x00000000l,
       0x00000200l,0x00020008l,0x08020208l,0x08000200l,
       0x08000008l,0x00000200l,0x00000000l,0x08020008l,
       0x08000208l,0x00020000l,0x08000000l,0x08020208l,
       0x00000008l,0x00020208l,0x00020200l,0x08000008l,
       0x08020000l,0x08000208l,0x00000208l,0x08020000l,
       0x00020208l,0x00000008l,0x08020008l,0x00020200l };
       
       
static unsigned long SP4[64]={             
       0x00802001l,0x00002081l,0x00002081l,0x00000080l,
       0x00802080l,0x00800081l,0x00800001l,0x00002001l,
       0x00000000l,0x00802000l,0x00802000l,0x00802081l,
       0x00000081l,0x00000000l,0x00800080l,0x00800001l,
       0x00000001l,0x00002000l,0x00800000l,0x00802001l,
       0x00000080l,0x00800000l,0x00002001l,0x00002080l,
       0x00800081l,0x00000001l,0x00002080l,0x00800080l,
       0x00002000l,0x00802080l,0x00802081l,0x00000081l,
       0x00800080l,0x00800001l,0x00802000l,0x00802081l,
       0x00000081l,0x00000000l,0x00000000l,0x00802000l,
       0x00002080l,0x00800080l,0x00800081l,0x00000001l,
       0x00802001l,0x00002081l,0x00002081l,0x00000080l,
       0x00802081l,0x00000081l,0x00000001l,0x00002000l,
       0x00800001l,0x00002001l,0x00802080l,0x00800081l,
       0x00002001l,0x00002080l,0x00800000l,0x00802001l,
       0x00000080l,0x00800000l,0x00002000l,0x00802080l };
       
       
static unsigned long SP5[64]={   
       0x00000100l,0x02080100l,0x02080000l,0x42000100l,
       0x00080000l,0x00000100l,0x40000000l,0x02080000l,
       0x40080100l,0x00080000l,0x02000100l,0x40080100l,
       0x42000100l,0x42080000l,0x00080100l,0x40000000l,
       0x02000000l,0x40080000l,0x40080000l,0x00000000l,
       0x40000100l,0x42080100l,0x42080100l,0x02000100l,
       0x42080000l,0x40000100l,0x00000000l,0x42000000l,
       0x02080100l,0x02000000l,0x42000000l,0x00080100l,
       0x00080000l,0x42000100l,0x00000100l,0x02000000l,
       0x40000000l,0x02080000l,0x42000100l,0x40080100l,
       0x02000100l,0x40000000l,0x42080000l,0x02080100l,
       0x40080100l,0x00000100l,0x20000000l,0x42080000l,
       0x42080100l,0x00080100l,0x42000000l,0x42080100l,
       0x02080000l,0x02000100l,0x40000100l,0x00080000l,
       0x00080100l,0x02000100l,0x40000100l,0x00080000l,
       0x00000000l,0x40080000l,0x02080100l,0x40000100l };
       
       
static unsigned long SP6[64]={ 
       0x20000010l,0x20400000l,0x00004000l,0x20404010l,
       0x20400000l,0x00000010l,0x20404010l,0x00400000l,
       0x20004000l,0x00404010l,0x00400000l,0x20000010l,
       0x00400010l,0x20004000l,0x20000000l,0x00004010l,
       0x00000000l,0x00400010l,0x20004010l,0x00004000l,
       0x00404000l,0x20004010l,0x00000010l,0x20400010l,
       0x20400010l,0x00000000l,0x00404010l,0x20404000l,
       0x00004010l,0x00404000l,0x20404000l,0x20000000l,
       0x20004000l,0x00000010l,0x20400010l,0x00404000l,
       0x20404010l,0x00400000l,0x00004010l,0x20000010l,
       0x00400000l,0x20004000l,0x20000000l,0x00004010l,
       0x20000010l,0x20404010l,0x00404000l,0x20400000l,
       0x00404010l,0x20404000l,0x00000000l,0x20400010l,
       0x00000010l,0x00004000l,0x20400000l,0x00404010l,
       0x00004000l,0x00400010l,0x20004010l,0x00000000l,
       0x20404000l,0x20000000l,0x00400010l,0x20004010l };  
            
static unsigned long SP7[64] = {
    0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
    0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
    0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
    0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
    0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
    0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
    0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
    0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
    0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
    0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
    0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
    0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
    0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
    0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
    0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
    0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
    
static unsigned long SP8[64] = {
    0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
    0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
    0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
    0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
    0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
    0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
    0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
    0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
    0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
    0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
    0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
    0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
    0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
    0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
    0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
    0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };

void deskey(unsigned char *key,short edf, unsigned long *kn);
void cookey(register unsigned long *raw1, unsigned long *dough);
//void cpkey(register unsigned long *into);
//void usekey(register unsigned long *from);
//void des(unsigned char *inblock,unsigned char *outblock);
void scrunch(register unsigned char *outof, register unsigned long *into);
void unscrun(register unsigned long *outof, register unsigned char *into);
void desfunc(register unsigned long *block,register unsigned long *keys);

/*****************  DES Function  *****************/
unsigned long OPENCOMM_DesExpandEncKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesEncKey,
        unsigned long *ulDesEncKeyLen);

unsigned long OPENCOMM_DesExpandDecKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesDecKey,
        unsigned long *ulDesDecKeyLen);

unsigned long OPENCOMM_DesEncRaw(
        unsigned char *pbDesEncKey,
        unsigned long  ulDesEncKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen);

unsigned long OPENCOMM_DesDecRaw(
        unsigned char *pbDesDecKey,
        unsigned long  ulDesDecKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen);


int myic_DESDecrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen);

int myic_DESEncrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen);


void deskey(unsigned char *key,short edf, unsigned long *kn)
{
    register int i, j, l, m, n;
    unsigned long pc1m[56],pcr[56];
    
    
    for ( j = 0; j < 56; j++ ) 
    {
        l = pc1[j];
        m = l & 07;
        pc1m[j] = (((unsigned long) key[l >> 3] & (unsigned long)bytebit[m] ) ? 1:0);
    }
    for ( i = 0;i < 16; i++)
    {
        if ( edf == DE1 )    m = (15 - i) << 1;
        else    m = i << 1;
        n = m + 1;
        kn[m] = kn[n] = 0L;
        for ( j = 0; j < 28; j++ )
        {
            l = j + totrot[i];
            if ( l < 28 )    pcr[j] = pc1m[l];
            else    pcr[j] = pc1m[l-28];
        }
        for (j = 28; j < 56; j++ ) 
        {
            l = j + totrot[i];
            if ( l < 56 )    pcr[j] = pc1m[l];
            else    pcr[j] = pc1m[l-28];
        } 
        for ( j = 0; j < 24; j++ ) 
        {
            if ( pcr[pc2[j]] )    kn[m] |= bigbyte[j];
            if ( pcr[pc2[j+24]] )    kn[n] |= bigbyte[j];
        }
    }
    return;
}

void cookey(register unsigned long *raw1, unsigned long *dough)
{
    register unsigned long *cook,*raw0;
    register int i;
    
    cook = dough;
    for ( i = 0; i < 16; i++, raw1++ ) {
        raw0 = raw1++;
        *cook     = (*raw0 & 0x00fc0000L) << 6;
        *cook    |= (*raw0 & 0x00000fc0L) << 10;
        *cook    |= (*raw1 & 0x00fc0000L) >> 10;
        *cook++    |= (*raw1 & 0x00000fc0L) >> 6;
        *cook     = (*raw0 & 0x0003f000L) << 12;
        *cook    |= (*raw0 & 0x0000003fL) << 16;
        *cook    |= (*raw1 & 0x0003f000L) >> 4;
        *cook++    |= (*raw1 & 0x0000003fL);
    }
    return;
}

void scrunch(register unsigned char *outof, register unsigned long *into)
{
    *into     = (*outof++ & 0xffL) << 24;
    *into    |= (*outof++ & 0xffL) << 16;
    *into    |= (*outof++ & 0xffL) << 8;
    *into++    |= (*outof++ & 0xffL);
    *into     = (*outof++ & 0xffL) << 24;
    *into    |= (*outof++ & 0xffL) << 16;
    *into    |= (*outof++ & 0xffL) << 8;
    *into++    |= (*outof   & 0xffL);
    return;
}

void unscrun(register unsigned long *outof, register unsigned char *into)
{
    *into++     = (unsigned char)((*outof >> 24) & 0xffL);
    *into++     = (unsigned char)((*outof >> 16) & 0xffL);
    *into++     = (unsigned char)((*outof >>  8) & 0xffL);
    *into++     = (unsigned char)( *outof++      & 0xffL);
    *into++     = (unsigned char)((*outof >> 24) & 0xffL);
    *into++     = (unsigned char)((*outof >> 16) & 0xffL);
    *into++     = (unsigned char)((*outof >>  8) & 0xffL);
    *into     = (unsigned char)( *outof          & 0xffL);
    return;
}

void desfunc(register unsigned long *block,register unsigned long *keys)
{
    register unsigned long fval, work, right, leftt;
    register int round;
    
    leftt = block[0];
    right = block[1];
    work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
    
    right ^= work;
    leftt ^= (work << 4);
    work = ((leftt >> 16) ^ right) & 0x0000ffffL;
    
    right ^= work;
    leftt ^= (work << 16);
    work = ((right >> 2) ^ leftt) & 0x33333333L;
    
    leftt ^= work;
    right ^= (work << 2);
    work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
    
    leftt ^= work;
    right ^= (work << 8);
    right = ((right << 1) | ((right >>31) & 1L)) & 0xffffffffL;
    work = (leftt ^ right) & 0xaaaaaaaaL;
    
    leftt ^= work;
    right ^= work;
    leftt = ((leftt << 1) | ((leftt >> 31)&1L)) & 0xffffffffL;
    
    for (round = 0; round < 8; round++) {
        work  = (right << 28) | (right >> 4);
        work ^= *keys++;
        fval  = SP7[ work    & 0x3fL];
        fval |= SP5[(work >>  8) & 0x3fL];
        fval |= SP3[(work >> 16) & 0x3fL];
        fval |= SP1[(work >> 24) & 0x3fL];
        work  = right ^ *keys++;
        fval |= SP8[ work     & 0x3fL];
        fval |= SP6[(work >>  8) & 0x3fL];
        fval |= SP4[(work >> 16) & 0x3fL];
        fval |= SP2[(work >> 24) & 0x3fL];
        leftt ^= fval;
        work  = (leftt << 28) | (leftt >> 4);
        work ^= *keys++;
        fval  = SP7[ work     & 0x3fL];
        fval |= SP5[(work >>  8) & 0x3fL];
        fval |= SP3[(work >> 16) & 0x3fL];
        fval |= SP1[(work >> 24) & 0x3fL];
        work  = leftt ^ *keys++;
        fval |= SP8[ work     & 0x3fL];
        fval |= SP6[(work >>  8) & 0x3fL];
        fval |= SP4[(work >> 16) & 0x3fL];
        fval |= SP2[(work >> 24) & 0x3fL];
        right ^= fval;
    }
    
    right = (right << 31) | (right >> 1);
    work = (leftt ^ right) & 0xaaaaaaaaL;
    leftt ^= work;
    right ^= work;
    leftt = (leftt << 31) | (leftt >> 1);
    work = ((leftt >>  8) ^ right) & 0x00ff00ffL;
    right ^= work;
    leftt ^= (work << 8);
    work = ((leftt >>  2) ^ right) & 0x33333333L;
    right ^= work;
    leftt ^= (work << 2);
    work = ((right >> 16) ^ leftt) & 0x0000ffffL;
    leftt ^= work;
    right ^= (work << 16);
    work = ((right >>  4) ^ leftt) & 0x0f0f0f0fL;
    leftt ^= work;
    right ^= (work << 4);
    *block++ = right;
    *block = leftt;
    return;
}

/*****************************************************************
    OPENCOMM_DesExpandEncKey    : Expand Des Enc Key 扩展des加密密钥
    Return value:
        0         : Success
        other     : failed
    Parameters:
        pbDesKey        : 扩展前的DES密钥(8字节)       input
        ulDesKeyLen     : 扩展前的DES密钥长度          input
        pbDesEncKey     : 扩展后的DES加密密钥(128字节)  output
        *ulDesEncKeyLen : 扩展后的DES加密密钥长度       output
*****************************************************************/
unsigned long OPENCOMM_DesExpandEncKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesEncKey,
        unsigned long *ulDesEncKeyLen)
{
    unsigned long kn[32], dough[32];
    
    if (ulDesKeyLen != 8)
        return 0xEE20;

    deskey(pbDesKey, EN0, kn);
    cookey(kn, dough);
    *ulDesEncKeyLen = DES_KEYBYTES;  //32 long = 128 bytes
    memcpy(pbDesEncKey, dough, *ulDesEncKeyLen);
    
    return 0;
}

/*****************************************************************
    OPENCOMM_DesExpandDecKey    : Expand Des Dec Key 扩展des解密密钥
    Return value:
        0       : Success
        other   : failed
    Parameters:
        pbDesKey        : 扩展前的DES密钥(8字节)      input
        ulDesKeyLen     : 扩展前的DES密钥长度         input
        pbDesDecKey     : 扩展后的DES解密密钥(128字节) output
        *ulDesDecKeyLen : 扩展后的DES解密密钥长度      output
*****************************************************************/
unsigned long OPENCOMM_DesExpandDecKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesDecKey,
        unsigned long *ulDesDecKeyLen)
{
    unsigned long kn[32], dough[32];
    
    if (ulDesKeyLen != 8)
        return 0xEE20;

    deskey(pbDesKey, DE1, kn);
    cookey(kn, dough);
    *ulDesDecKeyLen = DES_KEYBYTES;  //32 long = 128 bytes
    memcpy(pbDesDecKey, dough, *ulDesDecKeyLen);
    
    return 0;
}

/****************************************************************
    OPENCOMM_DesEncRaw        : Des算法加密小整块明文8字节 
    Return value:
        0       : Success
        other   : failed
    Parameters:
        pbDesEncKey    : DES加密密钥    input
        ulDesEncKeyLen : DES加密密钥长度 input
        pbInData       : 待加密的明文    input
        ulInDataLen    : 待加密的明文长度 input
        pbOutData      : 加密后的密文    output
        *ulOutDataLen  : 加密后的密文长度 output
*****************************************************************/
unsigned long OPENCOMM_DesEncRaw(
        unsigned char *pbDesEncKey,
        unsigned long  ulDesEncKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen)
{
    unsigned long work[2], ek[DES_KEYLONGS];
    unsigned char cp[DES_BLOCKLEN];

    if (ulInDataLen != DES_BLOCKLEN)
        return 0xEE20;
    
    if (ulDesEncKeyLen != DES_KEYBYTES)
        return 0xEE20;

    memcpy(cp, pbInData, DES_BLOCKLEN);
    scrunch(cp,work);  // 8 bytes -> 2 long
    memcpy(ek, pbDesEncKey, ulDesEncKeyLen);
    desfunc(work,ek);
    unscrun(work,cp); // 2 long -> 8 bytes
    memcpy(pbOutData, cp, DES_BLOCKLEN);
    *ulOutDataLen = DES_BLOCKLEN;

    return 0;
}

/*****************************************************************
    OPENCOMM_DesDecRaw : Des算法解密小整块密文8字节 
    Return value:
        0     : Success
        other : failed
    Parameters:
        pbDesDecKey    : DES解密密钥     input
        ulDesDecKeyLen : DES解密密钥长度  input
        pbInData       : 待解密的密文     input
        ulInDataLen    : 待解密的密文长度  input
        pbOutData      : 解密后的明文     output
        *ulOutDataLen  : 解密后的明文长度  output
*****************************************************************/
unsigned long OPENCOMM_DesDecRaw(
        unsigned char *pbDesDecKey,
        unsigned long  ulDesDecKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen)
{
    unsigned long work[2], dk[DES_KEYLONGS];
    unsigned char cp[DES_BLOCKLEN];

    if (ulInDataLen != DES_BLOCKLEN)
        return 0xEE20;
    
    if (ulDesDecKeyLen != DES_KEYBYTES)
        return 0xEE20;

    memcpy(cp, pbInData, DES_BLOCKLEN);
    scrunch(cp,work);  // 8 bytes -> 2 long
    memcpy(dk, pbDesDecKey, ulDesDecKeyLen);
    desfunc(work,dk);
    unscrun(work,cp); // 2 long -> 8 bytes
    memcpy(pbOutData, cp, DES_BLOCKLEN);
//    des_enc(pbDesEncKey, pbInData, pbOutData);
    *ulOutDataLen = DES_BLOCKLEN;

    return 0;
}

/*********************   DES    *********************/

int myic_DESEncrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen)
{
    unsigned char DesKeyBuf[32];
    unsigned char DesEncKeyBuf[128];
    int EncKeyLen, KeyLen = 0;
    int retval = 0, loops, i;
    
    if(nInDataLen%8 != 0)
        return 0xEE20;
    
    if(nDesKeyLen != 8)
        return 0xEE20;
    KeyLen = nDesKeyLen;
    memcpy(DesKeyBuf, pDesKey, nDesKeyLen);

    
    retval = OPENCOMM_DesExpandEncKey(DesKeyBuf, KeyLen,
        DesEncKeyBuf, (unsigned long *)&EncKeyLen);
    if(retval != 0)
        return retval;

    loops = nInDataLen/8;
    for(i = 0; i < loops; i++)
    {
        retval = OPENCOMM_DesEncRaw(DesEncKeyBuf, EncKeyLen, pInData + i*8,
            8, pOutData + i*8, (unsigned long *)pOutDataLen);
        if(retval != 0)
            return retval;
    }
    *pOutDataLen = nInDataLen;
    return retval;
}


int myic_DESDecrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen)
{
    unsigned char DesKeyBuf[32];
    unsigned char DesDecKeyBuf[128];
    int DecKeyLen, KeyLen = 0;
    int retval = 0, loops, i;
    
    if(nInDataLen%8 != 0)
        return 0xEE20;
    
    if(nDesKeyLen != 8)
        return 0xEE20;
    KeyLen = nDesKeyLen;
    memcpy(DesKeyBuf, pDesKey, nDesKeyLen);

    retval = OPENCOMM_DesExpandDecKey(DesKeyBuf, KeyLen,
        DesDecKeyBuf, (unsigned long *)&DecKeyLen);
    if(retval != 0)
        return retval;
    
    loops = nInDataLen/8;
    for(i = 0; i < loops; i++)
    {
        retval = OPENCOMM_DesDecRaw(DesDecKeyBuf, DecKeyLen, pInData + i*8,
            8, pOutData + i*8, (unsigned long *)pOutDataLen);
        if(retval != 0)
            return retval;
    }
    *pOutDataLen = nInDataLen;
    return retval;
}


//对称明文数据打pading
void  CW_dataPadAdd(int tag, unsigned char *date, unsigned int dateLen, 
                    unsigned char **padDate, unsigned int *padDateLen)
{
    int           i, padLen;
    unsigned char *pTmp   = NULL;
    
    pTmp = (unsigned char *)malloc(dateLen+24);
    if (pTmp == NULL)
    {
        *padDate = NULL;
        return ;
    }
    memset(pTmp, 0, dateLen+24);
    memcpy(pTmp, date, dateLen);
    
    if (tag == 0)
    {
        padLen = 8 - dateLen % 8;
        for (i=0; i<padLen; i++)
        {
            pTmp[dateLen+i] = (char)padLen;
        }
        *padDateLen = dateLen + padLen;
    }
    else
    {
        padLen = 16 - dateLen % 16;
        for (i=0; i<padLen; i++)
        {
            pTmp[dateLen+i] = (char)padLen;
        }        
    }
    
    *padDateLen = dateLen + padLen;    
    *padDate = pTmp;
}

#define  USER_PASSWORD_KEY "abcd1234"


//数据加密
int DesEnc(
         unsigned char *pInData,
         int            nInDataLen,
         unsigned char *pOutData,
         int           *pOutDataLen)
{
    int                rv;
    unsigned char    *padDate = NULL;
    unsigned int    padDateLen = 0;

    CW_dataPadAdd(0, pInData, (unsigned int )nInDataLen, &padDate, &padDateLen);

    rv = myic_DESEncrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        padDate, (int)padDateLen, pOutData, pOutDataLen);
    if (rv != 0)
    {
        if (padDate != NULL)
        {
            free(padDate);
        }
        return rv;    
    }

    if (padDate != NULL)
    {
        free(padDate);
    }
    return 0;
}


//数据加密
int DesEnc_raw(
    unsigned char *pInData,
    int            nInDataLen,
    unsigned char *pOutData,
    int           *pOutDataLen)
{
    int                rv;
    unsigned char    *padDate = NULL;
    unsigned int    padDateLen = 0;

    rv = myic_DESEncrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        pInData, (int)nInDataLen, pOutData, pOutDataLen);
    if (rv != 0)
    {
        return rv;    
    }
    return 0;
}

//解密分配内存错误
#define  ERR_MALLOC 20
//密码长度不是8的整数倍, 不合法
#define  ERR_FILECONT 20


//用户使用函数des解密
int DesDec(
           unsigned char *pInData,
           int            nInDataLen,
           unsigned char *pOutData,
           int           *pOutDataLen)
{
    int                rv;
    char            padChar;
    unsigned char     *tmpPlain = NULL;
    
    tmpPlain =        (unsigned char *)malloc(nInDataLen+24);
    if (tmpPlain == NULL)
    {
        return ERR_MALLOC;
    }
    memset(tmpPlain, 0, nInDataLen+24);

    //解密
    rv = myic_DESDecrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        pInData, nInDataLen, tmpPlain, pOutDataLen);
    if (rv != 0)
    {
        if (tmpPlain != NULL) free(tmpPlain);
        return rv;
    }

    //去pading
    padChar = tmpPlain[*pOutDataLen - 1];
    if ( (int)padChar<=0 || (int)padChar>8) //异常处理
    {
        if (tmpPlain) free(tmpPlain);
        return ERR_FILECONT;
    }

    *pOutDataLen = *pOutDataLen - (int)padChar;    
    //memset(tmpPlain + *pOutDataLen, 0, (int)padChar);    
    memcpy(pOutData, tmpPlain, *pOutDataLen);
    if (tmpPlain) free(tmpPlain);    
    return 0;
}


//用户使用函数des解密
int DesDec_raw(
    unsigned char *pInData,
    int            nInDataLen,
    unsigned char *pOutData,
    int           *pOutDataLen)
{
    int                rv;
    //char            padChar;
    //unsigned char     *tmpPlain = NULL;

    /*
    tmpPlain =        (unsigned char *)malloc(nInDataLen+24);
    if (tmpPlain == NULL)
    {
        return ERR_MALLOC;
    }
    memset(tmpPlain, 0, nInDataLen+24);
    */

    //解密
    rv = myic_DESDecrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        pInData, nInDataLen, pOutData, pOutDataLen);
    if (rv != 0)
    {
        //if (tmpPlain != NULL) free(tmpPlain);
        return rv;
    }
    /*
    //去pading
    padChar = tmpPlain[*pOutDataLen - 1];
    if ( (int)padChar<=0 || (int)padChar>8) //异常处理
    {
        if (tmpPlain) free(tmpPlain);
        return ERR_FILECONT;
    }

    *pOutDataLen = *pOutDataLen - (int)padChar;    
    //memset(tmpPlain + *pOutDataLen, 0, (int)padChar);    
    memcpy(pOutData, tmpPlain, *pOutDataLen);
    if (tmpPlain) free(tmpPlain);    
    */
    return 0;
}

HwEncdes.cpp 

#include "HwEncdes.h"
#include "des.h"
#include <iostream>

HwEncdes::HwEncdes(void)
{
}


HwEncdes::~HwEncdes(void)
{
}

int HwEncdes::EncData(unsigned char *plain,int plainlen,unsigned char *cryptdata,int *cryptlen)
{
	int ret = 0;
	
	ret = DesEnc(plain,plainlen,cryptdata,cryptlen);

	if (ret!=0)
	{
		printf("func DesEnc() err :%d\n",ret);
		return ret ;
	}
	return ret ;
}
int HwEncdes::DecData(unsigned char *cryptdata,int cryptlen,unsigned char *plain,int *plainlen)
{
	int ret =0;
	
	ret = DesDec(cryptdata,cryptlen,plain,plainlen);

	if (ret!=0)
	{
		printf("func DesEnc() err :%d\n",ret);
		return ret ;
	}
	return ret;
}

mainclass_框架类.cpp 

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"
#include "CSckFactoryImp2.h"
#include "HwEncdes.h"
using namespace std;

//框架类 组合   M（厂商socket 和 des）  V（main函数）   C（框架）
class MainOp
{
public:
	MainOp()
	{
		this->sp = NULL;
		this->des = NULL;
	}
	MainOp(CSocketProtocol *sp,CEncDesProtocol*des)
	{
		this->des = des;
		this->sp = sp;
	}
	//注入 
	void setSp(CSocketProtocol*sp)
	{
		this->sp = sp;
	}
	void setDes(CEncDesProtocol*des)
	{
		this->des = des;
	}
	//带加密的发送接收
	int sendAndRecv(unsigned char *in,int inlen,unsigned char*out,int *outlen)
	{
		int ret =0;
		unsigned char data[4096];
		int datalen=0;

		ret = this->sp->cltSocketInit();
		
		if (ret!=0)
		{
			return -1;
		}

		//发送前对数据加密

		ret = this->des->EncData(in,inlen,data,&datalen);

		printf("密文:%d\n",data);
		printf("长度:%d\n",datalen);

		ret = this->sp->cltSocketSend(data,datalen);

		if (ret!=0)
		{
			return -1;
		}
		ret = this->sp->cltSocketRev(data,&datalen);
		if (ret!=0)
		{
			return -1;
		}
		//对收到的数据进行解密
		ret = this->des ->DecData(data,datalen,out,outlen);

		ret = this->sp->cltSocketDestory();
		if (ret!=0)
		{
			return -1;
		}
		return 0;
	}
protected:
private:
	CSocketProtocol *sp;//类组合
	CEncDesProtocol *des;
};
int main()
{
	MainOp *op = new MainOp ;
	CSocketProtocol *sp = NULL;
	CEncDesProtocol *des = NULL;

	sp = new CSckFactoryImp1;
	des = new HwEncdes;

	op->setSp(sp);//注入
	op->setDes(des);

	unsigned char in[4096];
	int inlen =0;
	unsigned char out[4096];
	int outlen;
	int ret = 0;

	strcpy((char*)in,"abcdefghijklmnopq");

	inlen = strlen((char*)in)+1;//长度包括后面的‘\0’

	op->sendAndRecv(in,inlen,out,&outlen);

	printf("接收到的明文:%s\n",out);

	system("pause");
	return 0;

}



BUS375
关注
专栏目录
面向对象-抽象性思想（知识整理）
D大调奏鸣曲_第七序章_de博客
08-17 926
哲学思辨与现世应用层 从世界观的角度可以认为：面向对象的基本哲学是认为世界是由各种各样具有自己的运动规律和内部状态的对象所组成的；不同对象之间的相互作用和通讯构成了完整的现实世界。因此，人们应当按照现实世界这个本来面貌来理解世界，直接通过对象及其相互关系来反映世界。这样建立起来的系统才能符合现实世界的本来面目。 从方法学的角度可以认为：面向对象的方法是面向对象的世界观在开发方法中的直接运用。它强调系统的结构应该直接与现实世界的结构相对应，应该围绕现实世界中的对象来构造系统，而不是围绕功能来构造系统。
面向对象编程之抽象
江南岸
01-19 2037
面向对象编程 公司投资没有了，人们陆续都离职了，正好可以抽出个时间看看书，C++ Primer第四版，以前粗略的读过一遍，但是一直感觉好多地方就那么过去了，读书这个事情就是这样，每读一遍，都能有许多新的感悟，所以才有那句温故而知新，我是一个不爱读书的人，但是我还是建议大家多多读书，读书百遍，其义自现。好了，感觉再说废话就多了，我们开始吧。 面向对象的概述 面向对象编程总是基于三个概念：抽象，
面向抽象编程通俗理解
hyj1254
07-18 607
程序要隔离变化：首先要抽象、剥离出固定的部分，即使剩余部分再怎么变化，它也是不变的；做到这一点就必须使程序依赖于抽象，而不依赖于实现；这里的“抽象”应该从广义上理解，它可以是interface也可以是抽象类，可以利用ioc，甚至一个方法都行，总之，这部分不能使用具体的实现。 举个生活中的例子：小明接到一个电话找他爸爸，但恰好他不在家，于是小明告诉对方晚点再打过来。过一会儿爸爸回来了，...
一种基于抽象类的思想
牵佳一诺的博客
07-19 290
如果CRUD是很多Service要做的，那么可以抽象出一个BaseService抽象父类，里面去实现一些CRUD方法（非抽象方法）。但会有一个问题，就是里面的DAO（Mapper）是不一样的，抽象类也不能用注入，那怎么办？ 解决方法：在抽象父类中提供一个获取DAO（Mapper）的抽象方法（比如getMapper()），让子类各自实现。那么抽象父类的CRUD方法中就可以使用getMapper()
java编程思想——抽象类
a879365197的专栏
07-26 708
一、抽象类 1、什么是抽象类 对于类的某个方法可以描述这个的某个特性。比如动物的跑等，但是不同的对象可能方法是不一样的。 这就需要对方法进行抽象。这样就可以根据不同的类的特点，进行继承，然后再对抽象的方法进行重写。 abstract class ** { abstract void **（）； } 2、抽象类的特点 （1）抽象类不可以被实例化 （2）抽象类的抽象
11.面向对象编程思想——抽象
weixin_43893483的博客
08-11 341
1. 如何理解抽象 我们在前面去定义一个结构体时，实际上就是把一类事物的共有的属性（字段）和行为（方法）提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。 package main import ( "fmt" ) // 定义一个结构体Account type Account struct { AccountNo string Pwd string Balance float64 } // 方法 // 1. 存款 func (account *Account) D.
Java面向抽象编程
王慧龙的专栏
02-02 2005
一、面向抽象编程 使用多态进行程序设计的核心技术之一是使用上转型对象，即将abstract类声明的对象作为其子类对象的上转型对象 ，那么这个上转型对象就可以调用子类重写的方法。 所谓面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面向抽象类，即所涉及类中的重复 数据是抽象类声明的对象，而不是具体声明的对象。 面向抽象编程的核心是让类中的每种可能的
3.4 面向对象编程高级 【重点！】 万字抽象类与接口笔记-跟着韩老师学JavaSE
一碗菜粥的博客
08-03 568
面向对象编程中非常重要的概念——接口 并研究了抽象类与接口的区别
Delphi面向对象编程思想
01-15
《Delphi面向对象编程思想》是由刘艺编著的一本专著，主要探讨了如何在Delphi编程环境中应用面向对象的思想和技术。面向对象编程（Object-Oriented Programming, OOP）是现代软件开发中的核心概念，它通过封装、继承...
C++编程思想
03-12
此外，C++11引入了纯虚函数和抽象类，进一步强化了多态性设计。 `bitset`是C++标准库中的一个模板类，用于表示固定大小的位集。它可以高效地存储和操作二进制数据，支持位运算，如按位与、按位或、按位异或和按位非...
1.5 面向对象编程中级 面向对象编程最重要的特征 多态 方法重写与覆盖-跟着韩老师学JavaSE
一碗菜粥的博客
07-25 901
面向对象编程中级 第六章 第七章的内容 方法的重写与超级重要的多态！
浅谈依赖注入思想与面向接口编程
iOS学堂
01-07 3605
依赖注入(Dependency Injection) 今天我们讨论的内容核心是面向接口编程，我决定还是要从依赖注入开始讲起，因为DI的思想可以说是面向接口编程思想的特殊表现，也可以说是与面向接口编程相辅相成。 先撇开让人头脑发晕的文字定义，我们还是用我们最忠实和伙伴——代码来了解依赖注入。我们先来一个粗略的例子，由浅入深： 我们有一个公交车类(Bus)，每天早上6点钟需要发车(work)
面向对象编程思想-抽象
aiyan8271的博客
08-25 128
如何理解抽象： 我们在前面去定义一个结构体的时候，实际上就是把一类事物的共有的属性(字段)和行为(方法)提取出来，形成一个物理模型(模板)。这种研究问题的方法称为抽象。 案例演示： type Account struct { 　　AccountNo string 　　Pwd string 　　Balance float64} //方法//1.存款func (account *...
Java面向抽象编程的思想
张启明
11-24 2760
在设计程序时，经常会使用abstract类，其原因是，abstract类只关心操作，但不关心这些操作具体实现的细节，可以是程序的设计者把主要精力放在程序的设计上，而不必拘泥于细节的实现，既避免设计者把大量的时间和经理花费在具体的算法上。 在设计一个程序时，可以通过在abstract类中声明若干个abstract方法，表明这些方法在整个系统设计中的重要性，方法体的内容细节有有它的费abstra
Java编程思想之抽象过程
YiYang15848184726的专栏
06-07 721
 所有编程语言都提供抽象（abstraction）机制。可以认为，你所能够解决的问题的复杂性直接取决于抽象的类型和质量。我所谓的“类型”是指“你所抽象的是什么？”汇编语言是对底层机器的小型抽象。接着出现的许多所谓“命令式（Imperative）”语言（诸如FORTRAN、BASIC、C等）都是对汇编语言的抽象。这些语言在汇编语言之上有了大幅的改进，但是它们所作的主要抽象仍要求你在解决问题时要基于计
继承和抽象类思想
weixin_30532369的博客
03-06 66
访问修饰符 　　public：公共的，共有的，公开的（可以在“任何位置”使用） 　　protected：受保护的（可以在当前类或继承关系中使用） 　　private：私有的（只能在其所在的类中访问） 父类关键词 　　parent代表父类 父类的使用 　　 parent::__construct($p1);//调用父类的构造函数来初始化p1 继承关键字 　　class 子类 ex...
Java中的抽象类与接口类：自上而下的设计思想
最新发布
五更钟动的博客
04-08 529
在抽象类中，一些方法可能已经有了默认的实现，而其他方法可能需要子类提供具体的实现。抽象类的设计思想是自下而上的，即从具体的实现逐步向上抽象出通用的行为。接口类的设计思想是自上而下的，即从更抽象的层次定义了一组方法，然后由具体的类去实现这些方法。抽象类更关注于从具体的实现向上抽象出通用的行为，而接口类更关注于从更抽象的层次定义一组行为。综上所述，抽象类和接口类是Java面向对象编程中的重要概念，深入理解它们的特点和区别，并根据设计需求灵活运用，能够更好地设计出灵活、可扩展的软件系统。是一个接口类，它定义了。
深入理解Java（四）——抽象思想
弄鹊
10-01 1120
抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。而接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。在Java中，抽象类和接口都体现了OPP的抽象思想，故在本文中，我们会对这两类知识点做一个详细的阐述。
软甲架构设计软件_软件架构设计
weixin_39727402的博客
12-19 204
导读本文一文总结软件架构设计常用概念、原则与思想，包括面向对象六大原则，DID原则，ACID、CAP、BASE理论，中间层思想，缓存思想等。面向对象设计六大原则一 单一职责原则(SRP)：定义是就一个类而言，应该仅有一个引起他变化的原因。也就是说一个类应该只负责一件事情；二 开闭原则(OCP)：定义是软件中的对象(类，模块，函数等)应该对于扩展是开放的，但是对于修改是关闭的；当需求发生改变的时候，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值