目录
 
 

  
区位码
  
国标码(交换码)
  
内码(机内码)
  
区位码、国际码、内码的转换
  

   

    
为什么要加上20H
    
为什么加上80H
   
 
  
外码
  
字形码(字型码、字模码、输出码)
  
汉字的打印及显示
 
 
 
 
本文以GB2312为例，讲述区位码、国标码、内码、外码、字形码
 
区位码
 
整个GB2312字符集分成94个区，每区有94个位，每个区位上只有一个字符，即每区含有94个汉字或符号，用所在的区和位来对字符进行编码(实际上就是字符编号、码点编号)，因此称为区位码。
 
换言之，GB2312将包括汉字在内的所有字符编入一个94 * 94的二维表，行就是“区”、列就是“位”，每个字符由区、位唯一定位，其对应的区、位编号合并就是区位码。
 
比如“中”字在54区48位，所以“中”字的区位码是：5448（注意，GB类汉字编码为双字节编码，因此，45相当于高位字节，82相当于低位字节）。
 
国标码(交换码)
 
虽然GB2312为中文编码，我们也要使用到英文字母等字符，况且当时ASCII已经通用，所以要使GB2312能够

1 格雷码：
 
1.1 格雷码引言：
 
在数字系统中，常要求代码按一定顺序变化。
 
在机器视觉里面，编码结构光也是按照一定的顺序进行变化，最常用的就是Binary,但是，二进制的纯粹的编码，由于二进制的进制关系(每个位是有权的），如果发生一个错码（在机器视觉里面，错码的发生可能是一个背景的干扰，也可能是测试物体的一个比较陡峭的轮廓变更），一个错码往往他的数字权重不是一位，比如二进制的最高为，错了一位，那么就是整个数值发生一半的变化。
 
去掉权重的好处就是，如果模拟量或者是采样的数据发生了一个微小的变化，在整个测量的范围内，这个微小的变化都只能变更一个格雷码数位，而不论这个测量的数值位于整个测量量程的哪个位置：
 
 
【案】在上面这个例子中，假设测量的量程为16，我们测量到7和8之间的模拟量，你看看二进制，红色表示要变更所有的数位来表示，而格雷码只要变更一位。
 
那么，在我们表示这个数据的时候，二进制码所有的位都必须不能出错，否则数据会大变化。而格雷码就不会出现这个问题。 
 
后来，弗兰克·格雷（Frank Gray，18870913-19690523）专利“Pulse Code Communication” 发明了一种新的顺序编码的方式，这个方式也是每个数值是唯一的二进制标识，但是，每个相邻的位只有一个位值的变化，这样就极大的减少了测量可能发生误差。
 
1.2 格雷码的定义：
 
在一组数的编码中，若任意两个相邻的代码只有一位二进制数不同，则称这种编码为格雷码（Gray Code），另外由于最大数与最小数之间也仅一位数不同，即“首尾相连”，因此又称循环码或反射码。
 
格雷码是一种具有反射特性和循环特性的单步自补码，其循环和单步特性消除了随机取数时出现重大错误的可能，其反射和自补特性使得对其进行求反操作也非常方便，所以，格雷码属于一种可靠性编码，是一种错误最小化的编码方式，因此格雷码在通信和测量技术中得到广泛应用。
 
Gray Code(格雷码) C++多方法实现_越前浩波的博客-CSDN博客
 
3位格雷码的顺序编码_几种简单的编码（为什么使用ASCII码）_乔拉爵士的博客-CSDN博客
 
1.3 认识格雷码
 
下为3位元的Gray Code：Gray Code是一个数列集合，每个数使用二进位来表示，假设使用n位元来表示每个数好了，任两个数之间只有一个位元值不同
 
 
 
 
 
000 001 011 010 110 111 101 100
 
 
1.3.1 位元
 
位元就是数列的基础数是由几个二进位数来表示，就是几个位元。
 
上面的例子里面：000 是3个二进制数，那么就是3个位元，那么2^3 = 8,总共8个位值
 
 
 
0000 0001 0011 0010 0110 0111 0101 0100 1100 1101 1111 1110 1010 1011 1001 1000
 
 
上面，0000 等是4个 二进制数，那么就是4个位元，那么4^3 = 16,总共16个位值
 
1.3.2 （格雷）码值
 
001 就是一个码值
 

2 格雷码的生成：
 
2.1 方法1：按照定义排列生成格雷码
 
回到前面的3位元的格雷码：
 
 
 
000 001 011 010 110 111 101 100
 
 
如果推广到N个位元，那么码值的数量应该是2^N个
 
2.1.1 产生的基本规律原则和标准做法
 
其实就是3个步骤，
 
 
 
第一步，改变最右边的位元值；
 
 
第二步，改变右起第一个为1的位元的左边位元；
 
 
第三步，第四步重复第一步和第二步，直到所有的格雷码产生完毕（换句话说，已经走了(2^n) - 1 步）。
 
 
举例3位元的产生步骤：
 
 
 
　　假设产生3位元的格雷码，原始值位 000
 　　第一步：改变最右边的位元值： 001
 　　第二步：改变右起第一个为1的位元的左边位元： 011
 
 
重复1：
 　　第三步：改变最右边的位元值： 010
 　　第四步：改变右起第一个为1的位元的左边位元： 110
 
 
重复2：
 　　第五步：改变最右边的位元值： 111
 　　第六步：改变右起第一个为1的位元的左边位元： 101
 
 
重复3：
 　　第七步：改变最右边的位元值： 100 #已经走了(2^n) - 1  = 7步，完成所有码字的产生。
 
 
 
 
 2.1.2 实现算法如下：
 
#include <stdio.h> 
#include <stdlib.h>
#define MAXBIT 20
#define TRUE 1
#define CHANGE_BIT(x) x = ((x) == '0' ? '1' : '0')
#define NEXT(x) x = (1 - (x))

    int main(void) {
        char digit[MAXBIT]; int i, bits, odd;

        printf("输入位元数："); scanf("%d", &bits);

        for(i = 0; i < bits; i++) { digit[i] = '0';
            printf("0");
        }
        printf("\n"); odd = TRUE; while(1) {
            if(odd)
                CHANGE_BIT(digit[0]);
            else {
                // 计算第一个1的位置
                for(i = 0; i < bits && digit[i] == '0'; i++) ; if(i == bits - 1) // 最后一个Gray Code
                    break; CHANGE_BIT(digit[i+1]);
            }
            for(i = bits - 1; i >= 0; i--)
                printf("%c", digit[i]);

            printf("\n"); NEXT(odd);
        }

        return 0;
    }
 
方法2：
 
///产生n位格雷码(直接排列方法构建)
void generateGraycode2(int n)
{
	int i;
	char code[20];
 
	for (i = 0; i < n; i++)
		code[i] = '0';
	code[n] = '\0';
	printf("%s\n", code);
 
	while (1)
	{
		if (code[n - 1] == '0')
			code[n - 1] = '1';
		else
			code[n - 1] = '0';
		printf("%s\n", code);
 
		i = n - 1;
		while (code[i] == '0') i--;
		if (i == 0)
			break;
 
		if (code[i - 1] == '0')
			code[i - 1] = '1';
		else
			code[i - 1] = '0';
 
		printf("%s\n", code);
	}
}
 
 
方法3：
 
vector<int> grayCode(int n) {
        int count = 1 << n;
        vector<int> res(count,0);
        for(int i = 1 ; i < count; i ++)
        {
            int cur = res[i - 1];
            if(i % 2 == 1)
                cur  = cur ^ 1;
            else
            {
                int k = 0;
                while(((cur >> k) & 1) == 0) 
                    k ++;
                cur = cur ^ (1 << (k + 1));
            }
            res[i] = cur;
        }
        return res;
    }
 
 
 
  C++经典算法题-格雷码（Gray Code）_逍遥云恋-CSDN博客_c++格雷码
 

2.2 方法2：通过二进制和格雷码的转码规律生成：
 
格雷码（从零基础讲解，C++版）_不负AC不负卿的博客-CSDN博客
 
 Gray Code(格雷码) C++多方法实现_越前浩波的博客-CSDN博客
 
 
观察上表，我们可以得出格雷码和二进制码之间的基本换算逻辑如下：
 
 
 
 
 2.2.1 二进制转码为格雷码（编码）
 
 
 
 
原理：如果二进制码字的第 i 位和 i+1 位（从右边开始数）相同，则对应的格雷码的第i位为0，否则为1（当i+1=n时，二进制码字的第n位被认为是0，即第n-1位不变）
 
 
/*编码模板 */
#include <iostream>
using namespace std;

int gray_encode(int num)
{
	return num ^ (num >> 1);		// >>是位移运算符，^是异或运算符
}
 
方法2：
 
class Solution {
public:
    vector<int> grayCode(int n) {
        int num = 1 << n;
        vector<int> ret;
        ret.reserve(num);
        
        for(int i = 0; i < num; i++)
        {
            ret.push_back(i ^ (i >> 1));
        }
        
        return ret;
    }
};
 
 
 
 2.2.1 格雷码转成二进制（解码）
 
 
 
 
 
 原理：从左边第二位起，将每位与左边一位解码后的值进行异或，作为该位解码后的值（最左边一位依然不变），直到最低位。
 
 
 这里因为转成二进制的权重的位，所以要取对数log，并以2为底，用数值去除log2
 
/*解码模板 */
#include<math.h>		// log对数函数需要用到的头文件
#include <iostream>
using namespace std;

int gray_decode(int num)
{
	int head;
	if(!num) return 0;
	head = 1 << int(log(num) / log(2));	//C++没有直接以2为底的对数，我们创造一个以2为底的对数
   return head + gray_decode((num^head) ^ (head>>1));
 
 

2.3 镜像排列生成格雷码（对称法）
 
格雷码编解码学习(一)：格雷码编码原理与C++代码实现_Color Space的博客-CSDN博客
 
 
上面这个列表，分别给出位元为1,2,3的三组格雷码，其中灰色的部分是镜像分割线，黑色的格雷码码字和蓝色的格雷码码字是针对镜像分割线对称的。
 
算法原理：
 
C++ 递归产生格雷码_永远在路上啊的博客-CSDN博客
 
 
 
当只有一位的时候，格雷码要么是0,要么是1.
         如果有两位的时候，格雷码是首先由  0
                                     1
         然后镜像对称得到后两位:            1
                                     0
         然后再在上面两行前面加上0，下面两行加1得到:
                                     00
                                     01
                                     11
                                     10
         这就是二位的格雷码产生的过程。所以可以使用递归的方法去产生格雷码：
                         {    0,1                                n==1
                 f(n)  = {   f(n-1)                            n >=2
                         {    对称翻转，然后上一半加0，后一半加1
 
 
2.3.1 实现算法1，C++,二维数组
 
template<typename T,unsigned int N> void recursive::grayCodeGeneration(T (*list)[N],std::size_t size)const{
    if(size==1){//最后需要翻转输出
        list[0][size-1]=0;
        list[1][size-1]=1;
    }
    else{
        grayCodeGeneration(list,size-1);
        //下面做的是对称翻转
        for(int i= std::pow(2,size-1),j=std::pow(2,size)-1;i < std::pow(2,size);++i)
            for(int k = 0;k<N;k++)
                list[i][k] = list[j-i][k];//对应的逆序的行进行保存，这个时候用到的是
                                        //需要逆序保存的两个行之和是pow(2,size)-1;
        //这一步做的是前一部分加0，后一步分加1
        for(int i = 0;i < std::pow(2,size);i++){
            if(i <= (std::pow(2,size)/2-1))
                list[i][size-1]=0;
            else
                list[i][size-1]=1;
        }
    }
}
 
pow 就是求某数的指数的函数 
 
2.3.2 实现算法2，C++,
 
 C++ 生成代码如下：
 
#include <iostream>
#include <vector>
#include <string>
 
using namespace std;
 
///产生n位格雷码(镜像排列方法构建)
vector<string> generateGraycode(int n)
{
	vector<string> nGraycode;
	if (n == 1)
	{
		nGraycode.push_back("0");
		nGraycode.push_back("1");
	}
	else
	{
		vector<string> mid_ans = generateGraycode(n - 1);
		for (vector<string>::iterator iter = mid_ans.begin(); iter != mid_ans.end(); ++iter)
		{
			string temp = *iter;
			temp.insert(0, "0");
			nGraycode.push_back(temp);
		}
		for (int i = mid_ans.size() - 1; i >= 0; --i)
		{
			string temp = mid_ans[i];
			temp.insert(0, "1");
			nGraycode.push_back(temp);
		}
	}
	return nGraycode;
}
 
int main()
{
	vector<string>nGraycode;
	nGraycode = generateGraycode(3);
	for(int i = 0; i < nGraycode.size(); i++)
		cout << nGraycode.at(i) << endl;
	return 0;
}
 
 C++ 另一种表述为：
 
#include <iostream>
#include<vector>
using namespace std;

vector<string> getGray(int n) {
        // write code here
    vector<string> result;
    if(n == 1){
      result.push_back("0");
      result.push_back("1");
       return result;
    }else{
        result = getGray(n-1);
        int currentsize = (int)result.size();
        for(int i = 0; i < currentsize; i++){
            result.push_back(result.at(i));
        }
        for(int i = 0; i < currentsize; i++){
                 result.at(i) = "0" + result.at(i);
        }
        for(int i = currentsize; i < (int)result.size(); i++){
            result.at(i) = "1" + result.at(i);
        }
         return result;
        }
    }
int main(){
    vector<string> v;
    v = getGray(2);
    for(int i = 0; i < v.size(); i++){
        cout << v.at(i) << " ";
    }
    cout << endl;
    return 0;
}
 
实现算法另一种表述、
 
[C++]LeetCode: 86 Gray Code （格雷码）_cindy_niu的专栏-CSDN博客
 
class Solution {
public:
    vector<int> grayCode(int n) {
        vector<int> ret{0};
        
        for(int i = 0; i < n; i++)
        {
            int curCnt = ret.size();
            //把当前数字按照逆序顺序添加到ret中
            while(curCnt)
            {
                curCnt--;
                int curNum = ret[curCnt];
                curNum += (1 << i);
                ret.push_back(curNum);
            }
        }
        
        return ret;
    }
};

 
 
 
 
 
2.3.3 实现算法3，C，二维数组
 
c 语言表述：
 
算法实验-格雷码_中位数问题 分治法-CSDN博客_格雷码分治
 
//用分治策略设计一个算法对任意的n构造相应的Gray码。
#include<iostream>
#include<fstream>
using namespace std;
//构造n位格雷码，格雷码数m个
//利用格雷码除第一位外对称的原理
char** countgary(int n)
{
	int  m = 1;
	for (int a = 0; a < n; a++)
		m = m * 2;
	char** garycode = new char *[m];
	for (int a = 0; a < m; a++)
		garycode[a] = new char[n];
	if (n == 1)
	{
		garycode[0][0] ='0';
		garycode[1][0] ='1';
		return garycode;
	}//1的格雷码为0和1
	char** temp = countgary(n - 1);
	for (int a = 0; a < m / 2; a++)
	{
		garycode[a][0] = '0';
		garycode[a + m / 2][0] = '1';
		//m个格雷码前一半的第一位为0，后一半第一位为1
		for (int b = 1; b < n; b++)
		{
			garycode[a][b] = temp[a][b - 1];
			garycode[m-a-1][b] = temp[a][b - 1];
			//将n-1的格雷码呈上下对称放在n格雷码的前半段和后半段
		}
	}
	return garycode;
}
int main()
{
	ifstream f1("C:\\Data\\3.txt");
	ofstream f2("C:\\Data\\4.txt");
	int n; int m = 1;
	f1 >> n;
	for (int a = 0; a < n; a++)
		m = m * 2;
	char **garycode = countgary(n);
	for (int a = 0; a < m; a++)
	{
		for (int b = 0; b < n; b++)
		{
			f2 << garycode[a][b] << "\t";
			cout << garycode[a][b] << "\t";
		}
		cout << "\n";
		f2 << "\n";
	}
	f1.close();
	f2.close();
	return 0;
}
 

格雷码的算法实现_(っ°Д°)っ　　＃-CSDN博客_格雷码算法
 
2.4 正序逆序生成格雷码（对称法）
 
 
 
在正序的基础上将1左移n-1位，再加在逆序上，即得green code 格雷码。
 
 
算法返回的是10进制的值
 
 
class Solution {
public:
    vector<int> grayCode(int n) {
        vector<int> res;
        int c=1;
        res.push_back(0);
        for(int i=0;i<n;i++){
            for(int j=res.size()-1;j>=0;j--)
                res.push_back(res[j]+c);
            c<<=1;
        }
        return res;
    }
    
};
 
C++经典算法题-格雷码（Gray Code）_逍遥云恋-CSDN博客_c++格雷码
 
(1条消息) [C++]LeetCode: 86 Gray Code （格雷码）_cindy_niu的专栏-CSDN博客
 

本文重要参考：
 
C++经典算法题-格雷码（Gray Code）_逍遥云恋-CSDN博客_c++格雷码

数据库逻辑设计
 
R:关系名
 U:组成该关系的属性名集合
 D∶属性组U中属性所来自的域
 DOM:属性
 到域的映射
 F:属性组U上的一组数据依赖
 
由于D、DOM对模式设计的关系不大，这里把关系模式简化为一个三元组:
 R<U, F>，当且仅当U上的一个关系P满足F时，R称为关系模式R<U,F>的一个关系。
 
 
 1、关系数据库设计的核心:关系模式的设计。
 
 
 2、关系模式的设计目标:按照一定的原则从数量众多而又相互关联的数据中，构造出一组l既能较好地反映现实世界，而又有良好的操作性能的关系模式。
 
 
新奥尔良法，数据库设计步骤:
 
需求分析—〉概念结构设计（E-R图）—〉逻辑结构设计（关系模式设计）—)物理结构设计
 数据依赖的类型
 
函数依赖（Functional Dependency,FD)
 普遍存在于生活中，这种依赖关系类似于数学中的函数y=f(×)，自变量x确定之后，相应的函数值y也就唯一地确定了。
 如关系:公民(身份证号入姓名，地址，工作单身份证号一确定，则其地址就唯一确定，因此地函数依赖身份证号。 而姓名一确定，不一定能确定地址。
多值依赖(Multivalued Dependency ,MD）
 教师号可能多值依赖课程号，因为给定一个（课程号，参考书号)的组合，可能有对应多个教师号。这是因为多个老师可以相同或不同的参考书上同一门课。
 简单点讲，函数就是唯一确定的关系；多值依赖却不能唯一确定。 函数依赖的几种特例 1、平凡函数依赖与非平凡函数依赖
 
如果X→Y，且YSX，则X→Y称为非平凡函数依赖。
 若YC X，则称X→Y为平凡函数依赖。由于Y CX时，一定有X→Y，平凡函数依赖必然成立，没有意义，所以一般所说的函数依赖总是指非平凡函数依赖。
 
 
 
完全函数依赖分析
 
成绩依赖于学号和课程号两个字段的组合；但只知道学号无法确定成绩，同理只知道课程号也无法确定成绩；只有学号和课程号组合在一起才能标识哪个学生哪门课程的成绩；
 
因此（学号，课程号）---->成绩 是“完全函数依赖”。
 
 
部分函数依赖分析
 姓名、性别和班级三个属性只依赖于主键中的学号，与“课程号”无关。 因此（学号，课程号）——>姓名 是“部分函数依赖” （学号，课程号）——>性别 是“部分函数依赖” （学号，课程号）——>班级 是“部分函数依赖”
 课程名和学时数只依赖于课程号，
 因此（学号，课程号）----->课程名是“部分函数依赖”
 
 
传递函数依赖分析
 
班主任依赖于班级，与学号无关，与课程号也无关
 
又因班级依赖于学号，所以班主任间接依赖于学号
 
因此，（学号，课程号）----->班主任是“传递函数依赖”
 
 
主码 候选码 码
 
 
ps：元组理解为一张表的某一行，属性理解为一张表的某一列，属性名就是列的名字（字段）。
 
1（码）：码是可以确定一个元组的所有信息的属性名或属性名组。
 
例如在 { a, b, c, d } 中，
 
假设知道 a 的值就能确定 a, b, c, d 的值，
 
假设知道 c, d 的值就可以确定 a, b, c, d 的值，
 
那么 { a } 就是码，{ c, d } 就是码。
 
并且 { a, b }, { a, c }, { a, b, c }, { a, b, c, d } 等也都是码，因为它们也可以确定一个元组的所有值，即使很多余。
 
2（候选码）：候选码的真子集中不存在码，候选码可以有多个。
 
就上面的例子而言，{ a } 是候选码，{ c, d } 是候选码，因为它们的真子集中不存在码。
 
而诸如 { a, b } 并不是候选码，因为它的真子集中含有 { a }， 且 { a } 是码。
 
3（主码）：主码就是主键的意思，主码是任意一个候选码。
 
还是上面的例子，主码是候选码 { a }， { c, d } 中的其中一个。
 
既可以是 { a }， 也可以是 { c, d }。
 
 
 
更清晰的讲解见博客https://blog.csdn.net/sumaliqinghua/article/details/85872446?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162709035016780269848416%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=162709035016780269848416&biz_id=0&spm=1018.2226.3001.4187
 
 
 
范式这里就不说课本、网上那些晦涩难懂的概念了。
 
1NF:无重复的列（数据库表中的每一列都是不可分割的基本数据项）
 
2NF：满足1NF且非主键列都完全函数依赖于主键。
 
3NF：满足2NF且非主属性列都不传递依赖于主键。
 
BCNF：满足3NF且不允许主键的一部分被另一部分或其它部分所决定（即满足3范式，并且主属性之间没有依赖关系）。
 
习题会讲解的非常详细，请一定认真看。
 
题目：设有关系模式 R（职工名，项目名，工资，部门名，部门经理）
如果规定，每个职工可参加多个项目，各领一份工资；每个项目
只属于一个部门管理；每个部门只有一个经理。
 
试写出关系模式 R 的基本函数依赖和主码。
说明 R 不是 2NF 模式的理由，并把 R 分解成 2NF 。
进而将 R 分解成 3NF ，并说明理由。
 
分析
 
依赖关系我们使用 → 表示，可以理解为指向谁就代表可以推出谁，或者归谁管。
 
比如在这里，职工名和项目名合在一起可以推出工资是多少就可以表示为：(职工名，项目名)→工资；
 
再者，项目归部门管，可以表示为：项目名→部门名；部门归部门经理管可以表示为：部门名→部门经理。
 
好了，到现在为止我们就已经将第一问中的函数依赖写出来了，我们再来捋一下：
 
 
 
部门经理依赖于部门，也就是说要先确定部门才能确定部门经理，所以是依赖关系；
 而部门依赖于项目，要先确定项目才能确定部门；
 工资依赖于两个属性：职工名和项目名。
 
 
 
那么主码又是什么呢？
 
主码也叫主键，是指可以通过它唯一确定一条数据的这样一个属性。
 
比如学号就可以做主键，因为一个学号对应一个学生。
 
那么这里的主键是什么呢？
 
我们就要找通过谁可以唯一确定一条记录，项目名肯定不行，因为他和职工名一起才可以确定工资，那职工名肯定也不行，但是把它们合在一起就可以了，这样就可以确定唯一的一条记录。
 
所以，主键为(职工名，项目名)。
 
 
 
 
所以答案就是：
 
 
函数依赖关系： (职工名，项目名)→工资 项目名→部门名 部门名→部门经理 主键为(职工名，项目名)。
 
 
 
 来看第二问：说明 R 不是 2NF 模式的理由，并把 R 分解成 2NF 。
 2NF 是什么呢？
 
 
就是一种规范，他规定不能存在部分依赖，部分依赖是啥意思呢？就是我们只看依赖于主键的属性，这里有工资和部门名，但是他们两个的区别是工资对应的全部的主键，也就是两个值，但是部门名只依赖于项目名，少了一个，所以是部分依赖。
 
所以他存在了部分依赖就不是 2NF 模式了，那么怎么把它化成 2NF 呢？
 
一般我们只能通过分解的方式来消除，就是把一个关系拆成两个关系：
 
 
R1（项目名，部门名，部门经理）
R2（职工名，项目名，工资）
 
这样每个关系中就不存在部分依赖了。
 
 
 
来看第三问：进而将 R 分解成 3NF ，并说明理由。
 
 
那么 3NF 又是啥
 
 
 
我们先来观察上面那个 2NF
 的关系，发现有一个关系R1（项目名，部门名，部门经理），他比较特殊，就是项目名→部门名，部门名→部门经理，他是连续的，就是传递性的依赖关系，3NF
 就是要去掉这种依赖关系。
 
那么我们来去掉可得：
 
 
可以把 R1 再分成两个关系：
 
R11（项目名，部门名）
R12（部门名，部门经理）
 
最后总结一下 2NF 和 3NF 的关系：更详细例题请见该博客。
 ————————————————

 
上海交大JAVA第3次作业
 
JFrame默认的布局管理器是
 
选择一项：
 
a. CardLayou
 
b. BorderLayout
 
c. FlowLayout
 
d. GridLayout
 
每个Java小程序必须定义为
 
选择一项：
 
a. Frame类的子类
 
b. JFrame类的子类
 
c. Window类的子类
 
d. Applet类或JApplet类的子类
 
SQL中，“DELETE FROM 表名”表示
 
选择一项：
 
a. 从基本表中删除重复元组
 
b. 从基本表中删除所有属性
 
c. 从基本表中删除所有元组
 
d. 从数据库中撤消这个基本表
 
下列关于ODBC的叙述正确的是
 
选择一项：
 
a. 是一个C语言编写的API，适合在Java中使用
 
b. 保持了简单事物的简单性，又允许复杂的特性
 
c. 是一个C语言编写的API，不适合在Java中使用
 
d. 可以完全精确地实现从C代码ODBC到Java API写的ODBC的转换
 
如何设置线程的优先级？
 
选择一项：
 
a. 通过将优先级作为参数传递给线程的构造方法
 
b. 通过使用Thread类的setPriority()方法
 
c. 以上两种方法均正确
 
d. 以上两种方法均不正确
 
Swing提供的顶层容器不包括
 
选择一项：
 
a. JButton
 
b. JApplet
 
下列方法中不可用来实现线程间通信的是
 
选择一项：
 
a. wait()
 
b. notifyAll()
 
c. notify()
 
d. start()
 
Swing的选项面板是
 
选择一项：
 
a. JTabbedPane
 
b. JScrollPane
 
c. JLayeredPane
 
d. JSplitPane
 
在Applet中显示文字、图形等信息时，应使用的方法是
 
选择一项：
 
a. start()
 
b. destroy()
 
c. init()
 
d. paint()
 
一个基本的JDBC程序开发步骤中包括
 
选择一项：
 
a. 分配Statement对象
 
b. 分配Connection对象
 
c. 用Statement对象进行查询
 
d. 分配Connection对象、分配Statement对象、用Statement对象进行查询
 
以下关于外码和相应的主码之间的关系，正确的是
 
选择一项：
 
a. 外码一定要与相应的主码同名
 
b. 外码一定要与相应的主码同名而且唯一
 
c. 外码一定要与相应的主码同名，但并不一定唯一
 
d. 外码并不一定要与相应的主码同名
 
JDBC包含在java的哪个包中？
 
选择一项：
 
a. java.jdbc
 
b. javax.sql
 
c. java.sql 和 javax.sql
 
d. java.sql
 
Connection接口中不可用来向数据库发送SQL语句的对象的方法是
 
选择一项：
 
a. commit()
 
b. prepareCall()
 
c. prepareStatement()
 
d. createStatement()
 
下面哪个事件将导致线程死亡？
 
选择一项：
 
a. wait()方法被调用
 
b. start()方法被调用
 
c. run()方法执行结束
 
d. sleep()方法被调用
 
下列说法中正确的是
 
选择一项：
 
a. Thread类为抽象类
 
b. 实现Runnable接口的对象调用run()方法将创建一个新线程
 
c. 实现Runnable接口的类必须定义一个名为start的方法
 
d. Thread类实现了Runnable接口
 
扩展Thread类以提供线程的行为时，应重载哪个方法？
 
选择一项：
 
a. start()
 
b. resume()
 
c. begin()
 
d. run()
 
对给定程序理解正确的是()
 
public class ThreadPrint {
 
static Thread makeThread(final String id, boolean daemon) {
 
Thread t = new Thread(id) {
 
public void run() {
 
System.out.println(id);
 
}
 
};
 
t.setDaemon(daemon);
 
t.start();
 
return t;
 
}
 
public static void main(String[] args) {
 
Thread a = makeThread("A", false);
 
Thread b = makeThread("B", true);
 
System.out.println("End\n");