程序员考试笔记三（精选7篇）
1.程序员考试笔记三 篇一
溶血性贫血
一、发病机制：
1.红细胞易于破坏寿命缩短
(1)红细胞膜的异常
(2)血红蛋白的异常
(3)机械性因素
2.异常红细胞破坏的场所：
(1)血管内：血型不合、pnh。
(2)血管外：遗传性球形红细胞增多症、自身免疫性溶贫。
二、临床表现：
短期大量溶血：严重的腰背及四肢酸痛，伴头痛、呕吐、寒战、高热、面色苍白、血红蛋白尿、黄疸，周围循环衰竭，急性肾衰，慢性溶血：贫血、黄疸、肝脾大。
三、实验室：
1.提示红细胞破坏：
(1)血管外溶血：
a.高胆红素血症
b.粪胆原排出增多
c.尿胆原排出增多
(2)血管内溶血：
a.血红蛋白血症
b.血清结合珠蛋白降低
c.血红蛋白尿
d.含铁血红素尿
2.提示骨髓幼红细胞代偿性增生的实验室检查：
a.网织红细胞增多
b.周围血中出现幼红细胞
3.提示红细胞寿命缩短的实验室检查：
a.红细胞形态改变
b吞噬红细胞现象及自身凝集反应
c.heinz小体
d.红细胞渗透脆性增加
自身免疫性溶贫
一、实验室：
正常细胞性贫血，周围血可见球形细胞，网织红细胞增高，急性溶血白细胞增多，血小板多正常(如伴血小板减少为evans综合症)，骨髓呈增生性反应，以幼红细胞为主。
coombs试验阳性，免疫球蛋白增多，抗核抗体阳性，循环免疫复合物增多，c3低于正常。
二、治疗：
1.病因治疗
2.糖皮质激素
3.脾切除
4.免疫抑制剂：
指征：糖皮质激素和脾切除都不缓解者;脾切除有禁忌;泼尼松量需10mg/d以上才能维持。
2.程序员班asp教学笔记 篇二
第一章：web基础知识
在这一章中我们将要学习以下几点内容： 1:web服务器与客户端： 2:静态网页的概念 3:动态网页的概念 4:什么是脚本语言
5:客户端脚本与服务器端脚本
6:如何区分代码是客户端执行，还是在服务器端执行
web服务器与客户端 1:什么是web服务器
A:web服务器并不是一台物理的机器，你只要在那台计算机中安装了IIS(internet 信息服务)，则这台计算机就 是一台web服器，B:我们通常把网页的执行可以分成客户端与服务器端，存放网页的那一端被称为服务端，而看(浏览)网 页的一端就是客户端
C:要使客户端能够通过IE查看服务端的网页，必须在服务端安装ISS,也就是说我们说的服务器端就是必须安装 IIS的那一端，也即web服务器 D:web服务器就是我们常说的存放网页的服务器，当客户通过IE向web服务器发出要察看一个网页请求时，web服 务器会接受请求并在服务器上找到相应的网页，执行请求，并把执行的结果返回给客户端的IE.客户端(IE)------------(互联网)--------------web服务器(IIS)<-----(处理请求)F:一般而言客户端与服务器在不同的计算机中，当然也可以是同一部机器既是服务器与客户端
静态网页: 在动态网页产生之前，所有的网页都是静态的,静态网页具有以下几个特点：
A:静态网页的代码全部都是用html(hypertext markup lanague)超文本标记语言编写的.B:静态网页里面没有程序代码,在服务器端以是*.htm扩展名来存储的
C:当IE向web服务器发出静态网页的请求时,web服务器会把该网页上的htm代码下载到客户端的IE去执行，也 就是说，web服务器是不会执行任何代码的，web服务器此时只是一个htm代码存放的场合
3.程序员考试笔记三 篇三
需要制作一台可以在网络上被别人访问到的机器。
安装了浏览器的计算机：
browser端 能够提供网络资源的计算机：（网站在这台计算机上），能够提供某种服务。Server端。
B/S是什么意思？ 浏览器/服务器的架构：
请求：浏览器端向服务器端发送数据。Request 响应：服务器向浏览器端发送数据。回应，Response
什么样的计算机叫做服务器端？ 安装了服务器软件的计算机。
Web服务器软件：iis，nginx，apache。
其中apache还是目前与php配合使用最多的服务器软件：
安装apache这个软件，使jsj成为一台web服务器。
http:// Apache的默认的文档目录 apache的安装目录下/htdocs/
什么是静态网站，动态网站？
静态，网站上所有的内容，都是由静态页面提供的。
动态：网站的内容，是来源于某个数据源（数据库，互联网），而，在需要展示某些数据时，通过某种语言，将数据从数据源内提取，然后再展示到页面上。
如果需要做动态网站，需要
1，数据源（数据库）mysql数据库
2，某种语言（用于提取和展示数据之用）PHP
Amp开发：
利用apache作为web服务器，使别人可以访问到我们的网站 利用mysql作为数据源，可以保存动态网站所需要的数据 利用php来获得某个操作所需要的数据。
小测试： 输出1-100 编写php文件：
访问这个php文件：
发现，可以访问到，但是不能解析。
Apache只有提供被访问的功能，而不能提供解析php代码的功能。
因此需要安装php程序，提供解析php代码的功能：
安装PHP：
所有的请求都是web服务器来接收的（apache），但是其中某些资源需要php来处理。通常的处理方式，是将php作为apache内部的一个模块来管理的。
将php安装成apache模块：
使用一个apache的指令，loadModule来完成：
解压php的安装包：
不需要安装可以直接执行 将php软件复制到相应的目录： E:/amp/php
由于不需要安装，目录内的可执行文件直接可以使用：
在php目录内，有个文件，就是php为apache提供的apache模块：
需要使用apache的LoadModule载入这个模块即可：
需要在apache的配置文件内，使用上面的LoadModule指令： apache的配置文件在 apache的安装目录/Conf/httpd.conf
增加如下指令即可：
修改配置文件后，需要重启动apache服务才可以：
配置apache，告知apache，哪样的前请求需要调用php来解析，而哪些不需要： 通过请求的资源的后缀名
使用apache的FilesMatch指令来完成： 当匹配到php后缀时，调用php来处理： Apache的配置文件内:
请求php文件时，php代码可以执行：
大家可以使用phpinfo()函数来测试以下，当前的php运行的环境：
安装php后，需要配置一些最基本的配置项： 修改php的配置文件： Php的安装目录/php.ini
根据需要，将相应的更改成php.ini即可：
由于php作为apache一个模块，因此需要告知apache，在哪里才能找到php的配置文件。利用apache的指令PhpIniDir来完成：
修改配置文件，达到某些目的：
1，时区
2, php扩展文件的目录。Php的很多功能，并不是内置到php的软件内的。在需要使用某个功能时，再载入即可。这个扩展的功能文件是被保存到某个目录内的，称之为php的扩展目录： Extension_dir:
修改完了php的配置，也需要重启apache才能生效
如果我们的php需要操作数据的话，需要利用数据软件了。安装Mysql。
1，安装 2，配置
配置mysql的安装目录，和mysql数据的保存目录：
安装完成时，勾选运行配置向导，完成配置的过程：
配置字符集：
简单介绍Mysql： 数据库服务器：
属于server端。因此，需要等待某个程序请求他才可以运行。
能够对mysql数据库服务器发出请求的我们称之为mysql客户端。
C/S Client客户端
Server服务器
在安装完mysql后，其实安装了2个软件1，mysql的服务器端，2，mysql的客户端。
我们需要使用php来操作mysql。
其实 在php操作mysql的过程中，php就变成了 mysql的客户端。
Php能够作为mysql的客户端，使用php的php_mysql.dll这个扩展完成，而且，这个扩展不是默认开启的。
开启相应的mysql的操作扩展，利用php的指令extension来完成。Php.ini:
B/S C/S
1，服务器在监听（运行），提供某个服务
2，浏览器或者客户端，对服务器发出请求。在发送请求时，请求的数据一定要按照某种数据格式才可以。数据格式在网络数据传输时称之为网络协议。3，服务器接收到请求后，会根据请求数据，进行相应的操作。4，将处理好的结果返回给浏览器（客户端），回应。Response 5，浏览器端（客户端）对回应的数据进行展示输出，b/s 都是用浏览器发出请求的。
http https c/s架构，都是采用某个服务专用的客户端发出的请求。
Bs架构通常，任何两次请求回应周期是没有任何联系的。在发出请求时，都需要先建连接。
Cs通常，在连接一次之后，通常就会保持住这个连接，后续的操作，就不需要再次建立连接了。
PHP与apache联系：
1，php作为apache的模块而存在。loadModule 2，web服务器与php之间通过 CGI方式产生联系。CGI（通用网关接口），IIS+PHP。现在CGI被fastCGI。Nginx+PHP
apache的虚拟主机：
通常一个web服务器，代理的是一个网站。
有时我们需要利用一个web服务器，管理多个站点。不同的站点拥有独立的域名。
通过配置apache服务器，达到，访问
Test.kang.com时，看到的是test目录的内容。Shop.kang.com时，看到的是shop目录的内容
Apache的基于域名的虚拟主机技术：
主机：一个网站，就是一些php文件的集合，一个保存php文件的目录 域名：指向某个网站的名称。
通过修改apache配置文件达到效果：
Apache/comf/httpd.conf 原则上在这个配置文件内写虚拟主机的配置就可以了。但是通常我们都是将虚拟主机的配置写到某个单独的配置文件内，然后将这个虚拟主机配置文件再载入到apache的这个httpd.conf配置文件内。引入的操作：
虚拟主机的专门的配置文件：
编辑这个虚拟主机文件，增加虚拟主机：
在配置文件内，每一个
域名和目录是一个虚拟虚拟主机最基本的必备元素。
完成以上的操作，apache配置已经完成，apache上已经存在两个虚拟主机了：
在配置了虚拟主机之后，我们对web服务器的默认访问（没有使用配置的虚拟主机域名的访问），都会访问到默认的主机上。
默认的主机：
1，在配置了虚拟主机后：默认的主机就是 第一个配置的虚拟主机 2，在没有配置虚拟主机时，是htdocs目录。
那么怎么才能在使用虚拟主机的前提下，让localhost访问到原来的htdocs？
如何能够通过在浏览器上输入相应的虚拟主机域名访问到我们的虚拟主机呢？ 在浏览器端，需要通过相应的域名，解析成目标服务器的ip地址才可以。
可以通过过浏览器端操作系统上自带的 域名解析文件完成。Hosts
配置虚拟主机时，常用的配置：
目录的权限的配置
利用apache的directory指令段完成配置 看 httpd.conf的配置：
目录级别的配置，对当前目录，及其后代目录有效果。
如果在apache的配置文件内，没有对某个目录进行配置，则采用默认的目录配置
可以通过修改默认的配置达到目的，但是通常是针对目录进行单独配置： 增加一个 Directory指令段：
为了将目录与虚拟主机联系起来，通常在VirtualHost内，使用Directory指令 Conf/extra/httpd-vhosts.conf
直接访问目录的配置：
在访问目录时，先检测当前目录是否配置了目录索引页，如果配置了索引页，则展示索引页的内容。目录的索引页使用apache的指令 directoryIndex完成配置。这个指令是可以写到directory段内。
如果没有配置目录索引页：则需要将目录的的内容以列表的形式显示出来，但是是通过配置apache的指令options加以配置，是否可以显示目录的索引列表。
可以在配置 options时 增加上允许符号连接的配置：
Apache的配置文件系统：
Apache程序，只会在apache服务器启动时，读取apache配置文件的内容，称之为apache主配置文件。
一旦配置文件的语法出错，就会导致apache服务器启动失败，提示：
Apache提供一个apache的配置文件检查的功能：
也可以通过 cmd，命令行运行：
Apache还有一个配置文件，称之为apache的分布式配置文件，apache允许在某个目录内部，使用独立的配置文件，来配置当前目录及其后代目录的中的一些设置。但是此时配置文件名称，就不是httpd.conf了 而是.htaccess
在这个.htaccess配置文件中配置的内容，只能是目录级别的配置。
但是默认情况下，分布式配置文件是不可以使用的。可以通过在主配置文件中使用apache的 Allowoverride指令加以配置。由于分布式配置文件是配置目录的，因此 allowoverride也是需要写到Directory段。
分布式与主配置文件的区别：
1，主配置文件需要保存到Conf目录中，而分布式需要保存到所有需要配置的目录中
2，主配置文件只要在apache启动时，才读取，而分布式配置文件，在apache访问到某个目录时都会读取一次。
作业
1，每个人配置一个虚拟主机： 域名是 test.ip.com Test.100.com
2，在test.ip.com上增加一个表单页面 Welcome.html页面
最好在表单提交时，验证姓名不能为空，为空给出提示，不能提交。
分析上面的例子：
4.程序员考试笔记三 篇四
1、多态的特点：
1、成员变量：
当在子父类中出现了相同的非私有成员变量时，在多态调用中的特点：
在编译时：参考引用型变量所属类中是否有调用的成员变量，如果有编译通过，如果没有编译失败。
在运行时：参考引用型变量所属的类中的成员。
简单一句话：对于成员变量无论是编译还是运行都参考引用型变量所属类中的成员变量。
也就是说：成员变量看等号左边。
2、成员函数：
当子父类中出现一模一样的函数时，在多态调用中的特点：
在编译时：参考引用型变量的所属的类中是否有调用的成员函数。在运行时：参考的是对象所属的类中是否有调用的成员函数。
原因是：编译时期应该参考父类，运行时期应该参考子类。因为成员函数上有一个特点覆盖。
简单一句话：对于成员函数，编译看左边，运行看右边。
3、静态函数：
在编译时期：参考引用型变量所属的类中是否调用的静态函数，如果有编译通过，如果没有编译失败。
在运行时期：参考的还是引用型变量所属的类中的静态函数。简单一句话：对于静态函数，无论是编译还是运行都看左边
总结：对于多态成员而言，无论编译还是运行都看左边，只有成员非静态函数，编译看左边，运行看右边，因为覆盖的特性。
2、多态的应用： 代码实现：
Object：所有类的父类，该类中的方法所有对象都具备。代码实现：
Class Demo extends Object { Private int num;Demo(int num){ This.num=num;} 通常都会按照对象自身的特点对对象进行比较，比如：现在要比较两个Demo对象中null值是否相同。} Public boolean compare(Demo b){ Return this.num=d.num;
} 发现Demo继承Oject已经具备了比较对象的方法，所以没有必要再定义新的方法compare了，直接使用equals就可以了，可是Object equals比较的是地址值，不是我们所需的，那就保留的父类的功能声明，建立自身的比较内容，这就是覆盖。Public boolean equals(Object obj){ If(!(Object instanceof Deno))Return false;Demo d=(Demo)obj;向下转型。
Return this.num=d.num;此处体现了多态的特性。} Public String toString(){ Return “demo:”+num;} Class ObjectDemo { Public static void main(String[] args){ Demo d1=new Demo(4);Demo d2=new Demo(4);Sop(d1.toString());Sop(d1);Sop(c1.getName());Sop(d1.compare(d2));} }
4、内部类：
将一个类定义在另外一个类的里面的类称为内部类 当一个类要直接访问另外一个类的成员时，可以将这个类定义到另一个类里面，称为另一个类的内部类。
内部类访问的规则：
1、内部类可以直接访问外部类中的成员。
2、外部类需要创建内部类对象才可以访问内部类中的成员。
在描述事物时，事物中还有具体的事物时，而且这个内部事物在访问着外部的事物时。这时对这个内部事物的描述，就可以用内部类完成。
内部类出于外部类的成员位置上是可以被成员修饰符所修饰的。Public
Private：将内部类私有化时，只能对外提供方法，对内部类的控制。
Static：当内部类中定义了静态的成员时，该内部类必须静态的，否则编译失败。代码体现： Class Outer { Static int num=4;Static class Inner //内部类，为什么要定义内部类？
当一个类要直接访问另一个类中的成员时。可以将这个类定义到另一类里面。{ Static void show(){ Sop(“show run”+num);} Public void method(){ Inner in=new Inner();In.,show();} } } Class InnerClassDemo { Public static void main(String[] args){ //Outer out=new Outer();
//out.method();
//System.out.println(“Hello World!”);
//当访问一个外部类的内部类时，先由外部类对象再有内部类对象。
//Outer.Inner in=new Outer().new Inner();//要指明内部类所处的外部类
//in.show();
//内部类静态化，要调用的非静态的方法show();
//Outer.Inner in=new Outer.Inner();
//in.show();
//如果show方法也是静态的，要调用静态的方法show();
Outer.Inner.show();} }
5、匿名内部类：没名字的内部类。
就是内部类的简化写法。
前提：内部类可以继承或者实现一个外部类。代码实现： 格式：
New 父类名or 接口名(){子类的具体内容} Abstract class AbdsDemo { Abstract void show1();Abstract void show2();} Class Outer { Int num=4;New AbsDemo(){ Void show()//匿名内部类 { Sop(“num===”+num);} }.show();} Public void method2(){ AbsDemo a=new AbsDemo();{ Public void show1();Public void show2();};A.show1();A.show2();//要想调用两个方法，怎么做？起个名称即可
当里面有多个方法的时候建议不要写匿名内部类。
}
-----------------------------interface Inter {
void show();} class Outer {
//补足代码。最好用匿名内部类
static Inter method()//为什么是Inter类型
{
return new Inter()
{
public void show()
{
System.out.println(“show run”);
}
};
} }
class InnerClassTest
{
public static void main(String[] args)
{
Outer.method().show();
/*
Outer.method():Outer类中有一个method方法，而且这个方法是静态的。
Outer.method().show
会返回一个对象，而且这个对象还可以调用show方法
说明这个对象肯定是Inter类型。
*/
} }
------------------------------
6、异常：
是在运行时期发生的不正常情况
Java发现不正常的情况都包含着一些常见信息，并 将这些信息进行了对象的封装。异常这种机制，其实就是java按照面向对象的思想将出现的问题封装成了对象。在进行问题分析时，发现问题有很多种，但是不断向上抽取，最终问题可以归纳为两种，一种是可以针对处理的一种是通常不进行处理的。
在java中的体现一个是Exception ,一个是Error,后者一般针对处理。
无论是异常还是错误，他们都有名称信息等共性的内容。
可以继续抽取形成一个父类：throwable可抛出。Throwable
|---Error |---Exception 异常和错误都有一个特点：其子类的名称的后缀名都是父类名。
该体系具备一个特殊的特性叫做可抛性，该体系中的类可以被关键字throws抛出。
该体系中的类产生的对象可以被Throw抛出，简单说该体系可以被Throws 和throw操作。
Throw 和throws的区别：
Throws：定义在函数上，用于声明函数的可能出现的问题，后面跟异常类，可以跟多个，用逗号隔开、Throw:定义在函数内，用于抛出异常对象因为程序的跳转，后面跟的是异常对象。
If判断和异常处理的区别：
If判断是将正常代码和异常代码写在一起。阅读性极差，异常处理将问题代码和异常处理代码分离。代码实现： Class Demo { 功能的定义着在定义工呢过时，发现该功能容易因为未知内容的不确定性的出现的问题。为了让调用者明确，有可能有问题，需要在函数上对问题进行声明。
需要一关键字throw异常名。
Int div（int a,int b）throws Exception//抛出异常是为声明异常问题，让调用者去处理。{ If(b==0)Throw new ArithmeticException(“除数为零、违反规则”);
Return a/b;} } 对异常的针对性处理方式： Try { 需要被检测的代码； } Cathch（异常类 变量）{ 异常处理代码 } Finaly { 一定会被执行的代码。}
自定义异常：
Java将常见的问题都封装成了对象。
对于自定义项目中出现的问题，java并未给出对应的描述，这时我们就需要按照面向对象的思想自己完成对问题的描述和封装。
自定义异常：
需求：在我的程序中，进行除法运算，除数不可以为负数也不可以为0;对0这种情况，java中有对应的描述，ArithmeticException 对于负数，java中没有。只有我们自己定义，定义一个类来对异常进行描述。
Class FuShuException extends Exception { Private int num;FuShuException(){} FuShuException(String message,int num){ Super(message);This.,num=num;} Public int getNum(){ Return num;} } Class Demo { Int div(int a,int b)throws FuShuException { If(b<0)Throw new FuShuException(“除数不可以为负数”);函数内抛出异常，函数上一定要标示。函数内抛出是什么？函数上就标示什么？ 对方抛出什么异常，我就处理什么异常。Return a/b;} }
Class ExceptionDemo2 { Public static void main(String[] aths){ Demo d=new Demo()； Try
{ Int num=d.div(4,-1);Sop(“num=”+num);} Cathc(FuShuException e){ Sop();e.printStackTrace();} Sop(“over”);} }
自定义应用： 异常分两种：
1、编译被检测的异常：Exception 这种异常通常都需要进行针对性的处理。
2、运行时发生的异常：RuntimeException 对于运行时异常一般是不编写针对性的处理方式，如果该异常发生就让程序停止，对程序进行修正。因为这种的出现往往已经无法让程序继续运算了。
class Demo {
int div(int a,int b)throws ArithmeticException
{
if(b==0)
throw new ArithmeticException(“除数为零”);
return a/b;
} } class ExceptionDemo3
{
public static void main(String[] args)
{
getIndex(null,4);
}
public static int getIndex(int[] arr,int key)
{
if(arr==null)//进行健壮性判断。
throw new NullPointerException(“没有具体的数组”);
for(int x=0;x
{
if(arr[x]==key)
return x;
}
return-1;
}
public static int getElement(int[] arr,int index)
{
if(arr==null)
throw new NullPointerException(“没有具体的数组实例”);
if(index<0||index>=arr.length)
throw new ArrayIndexOutOfBoundsException(“角标越界”);
return arr[index];
} }-------------------异常练习：
/* 需求：
毕老师用电脑上课。按照面向对象思想来描述。名词提炼法
上课过程中出现的问题：
1、电脑蓝屏了。
2、电脑冒烟了。
*/ class LanPinException extends Exception {
LanPinException(String message)
{
super(message);
} } class MaoYanException extends Exception {
MaoYanException(String message)
{
super(message);
}
} class NoPlanException extends Exception {
NoPlanException(String message)
{
super(message);
} } class Computer {
private int state=2;
public void run()throws LanPinException,MaoYanException
{
if(state==1)
throw new LanPinException(“电脑蓝屏了”);
if(state==2)
throw new MaoYanException(“电脑冒烟了”);
System.out.println(“电脑运行”);
}
public void reset()
{
System.out.println(“电脑重启”);
state=0;
} } class Teacher {
private String name;
private Computer cmpt;
Teacher(String name)
{
cmpt=new Computer();
this.name=name;
}
public void prelect()throws NoPlanException//此处冒烟是电脑发生的，能再老师讲课的功能出现这样的异常么？所以抛出的对象不对，老师只能耽误了讲课的进度，所以此时是否应该定义一个关于讲课进度的类来封装这个问题。
{
try
{
cmpt.run();
System.out.println(name+“毕老师讲课”);
}
catch(LanPinException e)
{
System.out.println(e.getMessage());
cmpt.reset();
prelect();
}
catch(MaoYanException e)//这个功能我处理不了，因为冒烟不会了，这时候需要抛出。
{
test();
//throw e;//因为处理不了，继续往外抛。此时在讲课方法上要声明。此处也不能抛出这个异常。因为冒烟是电脑运行时的，不是老师讲课的。
throw new NoPlanException(“课时无法继续进行”);
}
}
public void test()
{
System.out.println(“练习”);
} } class ExceptionTest {
public static void main(String[] args)
{
Teacher t=new Teacher(“毕老师”);
try
{
t.prelect();
}
catch(NoPlanException e)
{
System.out.println(“换人”);
}
} } //到底什么是抛什么处理？
/*
自己能解决的就处理，处理不了就抛。
比如着火了，小火的时候自己可以处理，比如灭火器等
当火势大了，就处理不了，只能交给消防队，自己要跑。
5.程序员考试笔记三 篇五
表定义语句 创建表： 基本形式：
Create table [if not exists] 表名(列定义列表，[索引或约束列表])[表选项列表];说明：
1.上述列表都是指”多项并列项”，每一项之间用(,)分开 2.其中中括号部分是可以省略的 列定义：
每一个列定义的基本形式：
列名
列类型
[列属性列表] 说明：
1.列类型，就是数据类型，其中还可能会需要跟类型有关的相应设定。2.列属性有6个，相互之间用空格隔开就可以：
a)Auto_increment：表示自增长，用于整数类型。一旦设定了此属性，则也同时要求设定一个”key”属性，就是后面那2个：primary key或unique key b)Primary key:表示主键，用于唯一确定一行的数据
c)Unique key :表示唯一键，用于设定某个字段的值在所有行中是唯一的(不可重复的)d)Not null ：表示不能为空(非空属性)e)Default XX值：设定默认值，当该字段没有赋值或赋值为NULL时，自动获得该值
黑马程序员济南中心 编著
f)Comment ‘字段说明文字’：表示一种可以解释该字段含义，但又不属于”注释”的内容。
索引：
索引是一种数据库内部为了加快数据查找(搜索)速度的内部机制，其设定某个字段”有索引”，则该字段作为条件(比如where age=22)进行查找就会极大提高其速度。
索引设定形式：
通用形式：索引类别(字段名1，[字段名2]，[字段名3]....);//至少一个字段 索引类别有：
普通索引：key [索引名](字段列表)
就只有索引的作用
唯一索引：unique key [索引名](字段列表)具有索引作用，而且具有唯一性 主键索引：primary key(字段列表)
具有索引作用，而且具有主键特性 外键索引：foreign key[索引名](字段列表)reference 其他表(对应字段列表)具有索引作用，而且具有对应其他表的字段值的作用(外键作用)全文索引：fulltext key [索引名](字段列表)具有索引作用，但mysql对中文无法正常发挥作用 索引的弊端：
降低(减慢)增删改数据的效率(速度)约束：
约束是指数据库中预先设定的对数据的”规定”,”要求”,”条件”等等
约束，是指在”建表”的时候，预先设定好的，以期对”后续写入数据”进行”检查”来决定是否满足设定的约束条件，结果有两种可能：满足写入成功，不满足写入失败。
有以下几种约束：
黑马程序员济南中心 编著
唯一约束
: unique key(字段列表)主键约束
：primary key(字段列表)外键约束
：foreign key(字段列表)references 其他表(对应字段列表)非空约束
：not null 默认约束
：default XX值 检查约束
：check(某字段的条件)说明: 1.前3个约束，其实同时也是索引，无需额外设定 2.非空约束和默认约束是”字段属性”，无需额外设定 3.检查约束mysql不支持该功能。。
表选项：
表选项是对一个表的额外属性的设定，多个设定之间用逗号(,)隔开 如下几个选项可设定：
Auto_increment = 自增长数字的起始值 Charset = 字符编码名 定
Collate = 排序规则名
//可以不设定，使用数据库级别的设定
//可以不设定，默认为1
//可以不设定，就是使用数据库级别的设Comment = ‘表说明文字’ Engine = 存储引擎名 存储引擎
存储引擎其实就是将”成千上万”的数据，存入到硬盘(文件)的内部机制(方式).不同的存储引擎在性能(速度)，功能，资源消耗方面有所不同。
//可以不设定，默认是”InnoDB”
黑马程序员济南中心 编著
一个重要的观念：没有一个性能最好，功能最全，资源消耗最小的存储引擎。主要存储引擎如下：
修改表： 总体思想：
1.修改表是一个表建立之后的补救工作，不应该当做一个”常规工作”.2.建表能完成的事情，修改表几乎都能完成 3.语法：
Alter table 表名 修改项1，修改项2.....;其中，修改项可以包括：
字段：可以增删改 索引(约束)：可以增删； 表选项：只能修改(从新设定)
黑马程序员济南中心 编著
删除表：
drop table 【if exists】 表名；
其他相关语句：
显示所有表: show tables；
显示某表的结构: desc 表名； 或：describe 表名； 显示某表的创建语句：show create table 表名； 重命名表：rename table 旧表名 to 新表名； 删除索引：drop index 索引名 on 表名。
6.Perl函数(子程序)学习笔记 篇六
一、函数定义
子程序即一段分离的代码,它可以使减少重复代码且程序易读.perl中,子程序可以出现在程序的任何地方.但一般放在程序的开始或结尾.
代码如下:
sub subroutine{
statements;
}
sub开始,子程序名同变量的命名规则,可与变量同名,最好不要与内部函数同名,如果与内部函数同名则用$subroutine区分,不用&是内部函数,用&是定义函数,但省略&时混淆.
带有原型说明的子程序定义:
代码如下:
sub subroutine($$){ #需要两个简单变量的参数
statements;
}
说明:
1.中的符号表示参数的类型,以一个字符表示一个参数.
2.$ 简单变量 @ 列表 % 散列 & 匿名子程序 * 引用
3.前加为强制类型一致,;分隔必须的参数和可选参数.
4.@$;$表示第一个参数为列表,第二个参数为简单变量,第三个参数简单变量可选.
二、函数返回值
1.缺省子程序中最后执行的一个语句的值将用作返回值,如果在if块中为最后执行的语句,虽然不是子程序的最后一句,也是返回值.
代码如下:
$a=1;
不用等于,直接$retval;
代码如下:
split(/:/,@a) 返回数组.
2.语句return(retval) 退出子程序并返回值retval,retval可以为列表.
3.返回错误
return 返回错误undef
用eval(‘subroutine‘) 函数,错误由$@变量中取得.
三、函数参数传递
形式:
代码如下:
$sub1($num1,$unm2,$num3); 调用
sub sub1{
my($num1,$unm2,$num3)=@_;
}
my $num1=shift;
my $num2=shift;
my $num3=pop;
说明:
1.所有参数在数组@_中,每个元素为$_[0],$_[1]
2.@_,$_[]为局部变量,当子程序内再调用子程序时,@_不改变,会新生成另一份@_.
3.改变@_内元素的值如$_[0]会改变主程序的参数值.
7.程序员考试复习题 篇七
1）经过以下栈运算后，x的值是_____________。
InitStack(s);Push(s,a);Push(s,b);Pop(s,x);GetTop(s,x);A.a
B.b C.1
D.0 2)经过以下栈运算后，StackEmpty(s)的值是___________。
A.st.top==-1;
B.st.top!=-1;
C.st.top!=Maxsize;D.st.top==Maxsize;13)判定一个顺序栈st为（元素个数最多为Maxsize）满的条件为______________.A.st.top!=-1;
B.st.top= =-1;
C.t.top!=Maxsize-1;D.st.top== axsize-1;14)递归模型f(n=f(n-1)+n(n>1)的递归出口是___________.A..f(1)=0 B.f(1)=1 C.f(0)=1 D.f(n)=n
InitStack(s);Push(s,a);Push(s,b);Pop(s,x);Pop(s,y);
A.a
B.b
C.1
D.0 3)设一个栈的输入序列为A,B,C,D, 则借助一个栈所得到的输出序列不可能是___________.A).A.B.C.D
B)D.C.B.A
C).A.C.D.B
D).D.A.B.C 4)一个栈的进栈序列是a.b.c.d.e, 则栈的不可能的输出序列是___________’
A.edcb B.decba
C.dceab D.abcde 5)已知一个栈的进栈序列是 1,2,3,……,n,其输出序列的第一个元素是i，则第j个出栈元素是_______________’
A.j
B.n-I
C.z-i+1
D.不确定 6）已知一个栈的进栈序列是1,2,3,…..,n, 其输出序列是p1,p2,……,pn, 若p1=n, 则p1的值是_____________.A.I
Bn-I
Cn-i+1
D 不确定 7）设n个元素的进栈序列为p1,p2,p3,……,pn, 其输出序列为1,2,3,……,n, 若pn=1,则pi(1<=i<=n-1)的值___________.A.n-i+1 B.I
C.I
D.有多种可能 8）栈是一种具有_________________特性的线性表。
9)顺序栈和链栈的区别仅在于_____________的不同？
10)如果栈的最大长度难以估计，那么最好使用__________________栈。
11）一个栈的输入序列是12345，则栈的输出序列12345可不可能出现。12）判定一个顺序栈st为（元素个数最多为Maxsize）空的条件为_____________.15)经过以下队列运算后，队头的元素是____________.InitQuue(qu);enQueue(qu,’a’);enQueue(qu,’b’);enQueue(qu,’c’);deQueue(qu);
A.a
B.b
C.1 D.0
16)元素A,B,C,D顺序连续进入队列qu后，队头元素是____________,队尾元素是_______.A.A
B.B
C.C
D.D
17)一个队列的入列序列为1234，则队列可能的输出序列是______________.A.4321 B.1234 C.1432 D.3241
18)队列是一种具有___________特性的线性表。
19）顺序队和连队的区别仅在于______________的不同。
20）如果队列的最大长度难以估计，则最好使用_____________.21）环形队列qu的队满条件是_______________.A.(qu.rear+1)%maxSize ==(qu.front+1)%MaxSize
B.(qu.rear+1)%MaxSize==qu.front+1;
C.(qu.rear+1)%MaxSize==qu.front+1;
D.qu.rear==qu.front
22)最适合用作列队的列表是__________.A.带队首指针和队尾指针的循环单连表
B.带队首指针和队尾指针的非循环单链表
C.只带队首指针的循环单链表 D.只带队尾指针的循环单链表 23）最不合适用做链队的链表是
A.只带队首指针的非循环双链表。B．只带队首指针的循环双链表。C.只带队尾指针的循环双链表。D.只带队尾指针的循环单链表。24）.假设一个练队的队尾和队首指针分别为rear front则判断队空的条件是
A front==rear B front!==NULL C rear!==NULL D front==NULL 25)用单链表表示的链队的队头在链表的_______位置 A.链头
B．链尾 C．链中
D．以上都可以
26）用单链表表示的链队的队尾在链表的_______位置
A.链头 C．链中
B．链尾D．以上都可以
27）对于链队在进行删除操作时 A 仅修改头指针 B仅修改尾指针
C 头尾指针都要修改 D头尾指针可能都要修改 填空题
1． 若用带表头结点的单链表表示则队列为空的标志是_______.2． 若用不带表头结点的单链表表示则创建一空队列的所要执行的操作是_______.3． 若用带头结点的单链表表示则创建一空队列的所要执行的操作是_______.4． 已知链队的头尾指针分别是f和r则将值x如队的操作是
P=(QNode *)malloc(sizeof(QNode));p->data=x;
_____________;________;_________;5． 表达式23+（（12*3-2）/4+34*5/7）+108/9的后缀表达式是_____________________ 6．;程序：
1． 有如下算法：
Void print(int w){
Int i;
If(w!=0)
{
Print(w-1);
For(i=1;i<=w;i++)
Printf(“%d”,w);
Printf(“n”);
}}
调用语句print（4）的结果_______。2．有如下递归过程：
Void reverse（int m）{printf(“%d”,n%10);
If(n/10!=0)reverse(n/10);}
调用语句reverse(582)的结果是________。
3.递归函数sum(int a[], int n)的返回值是数组a[]的前n个元素之和。
Int sum(int a[], int n)
{if(n>0)return_______;
Else ________;}
4.递归函数int dec(int a[], int n)判断数组a[]的前n个元素是否递增，递增返回0；
int dec(int a[], int n)
{if(n<=1)________;If(a[0]
Else ________;}
5.递归函数invert(int a[], int k)将指定数组中的前k 个元素逆置
Void invert(int a[], int k)
{int t;
If(_______){invert(____________);
T=a[0];
A[0]=a[k-1];a[k-1]=t;
} }
6.int dec(int n)的功能是计算n!.如调用dec(6)后函数的反回值是120
int dec(int n){if(n<2)_________;
else return(________);
} 7.递归函数 int fib(int n)的功能是计算fibonacci 数列的第n 项
int fib(int n){ if(n==0)________;
else if(_________)return 1;
else _________;
} 判断：
1）栈低元素是不能删除的元素。2）顺序栈中元素值的大小是有序的。3）在n个元素进栈后，他们的出栈顺序和进栈顺序正好相反。
4）栈顶元素和栈底元素有可能是同一元素。
5）若用s[1]~s[m]表示顺序栈的存储空间，则对栈的进栈，出栈操作最多只能进行m次。
6）栈是一种对进栈，出栈操作总次数做了限制的线性表。
7）对顺序栈进行进栈，出栈操作，不涉及元素的前后移动问题。8）栈是一种对进栈，出栈操作的次序做了限制的线性表。9）空栈没有栈顶指针。
10)栈和队列都是限制存取端的线性表。11）队列是一种对进队列，出队列操作的次序做了限制的线性表。
12）n个元素进队列的顺序和出队列的顺序总是一致的。
13）顺序队中有多少元素，可以根据队首指针的值和队尾指针的值来计算。
14）若用“队首指针的值和队尾指针的值相等”作为环形顺序队为空的标志，则在设置一个空队时，只需给队首指针和队尾指针赋同一个值，不管什么值都可以。
15）无论是顺序队还是链队，进队，出队操作的时间复杂度都是 O(1).解答题：
1）设有一个数列的输入顺序为123456，若采用栈结构，并以A和D分别表示进栈和出栈操作，试问通过进栈和出栈操作的合法序列。
（1）能否得到输出序列为325641的序列？
（2）能否得到输出序列为154623的序列？
2）说说线性表，栈和队列的异同。
3）设栈s和队列q的初始状态都为空，元素 a,b,c,d,e和f依次通过栈s，一个元素出栈后既进入队列q，若6个元素出队的序列是bdcfea, 则栈s的容量至少应该存多少个元素？ 程序题：
1> 写出下列程序字段的输出结果（栈的元
素类型SElemType为char）Void main(){Stack S;Char x,y;InitStack(S);X=’c’;y=’k’;
Push(S,x);
push(S,’a’);push(S,y);Pop(S,x);
push(S,’t’);push(S,x);Pop(S,x);
push(S,’s’);
While(!StackEmty(S)){pop(S,y);printf(y);} Printf(x);}
2> 简述以下算法的功能（栈的元素类型
SElemType为int）Status algo2(Stack S,int e){Stack T;int d;InitStack(T);
While(!StackEmpty(S)){pop(S,d);
If(d!=e)push(T,d);}
While(!StackEmpty(S)){pop(T,d);Push(S,d);} }
3> 写出以下程序段的输出结果（队列中元
素类型QElemType为char）Void main()
{Queue Q;InitQueue(Q);Char x=’e’,y=’c’;EnQueue(Q,’h’);EnQueue(Q,’r’);EnQueue(Q,y);
DeQueue(Q,x);EnQueue(Q,x);DeQueue(Q,x);EnQueue(Q,’a’);While(!QueueEmpty(Q)){DeQueue(Q,y);
Printf(y);
}
Printf(x);} 4>函数MultibaseOutput(long n,int B)的功能是：将一个无符号十进制数n转换成B（2<=B<=16）进制整数并输出。该函数先将转换过程中得到的各位数字入栈，转换结束后把B进制从栈中输出。有关操作的各函数功能见相应函数中的注释。C代码中的符号常量及栈的类型定义如下： #define MAXSIZE 32 Typedef struct { Int *elem;/*栈的存储区*/ Int max;/*栈的容量，即栈中最多能存放的元素个数*/ Int top;/*栈的指针*/ }Stack;C代码
Int InitSack(Stack *s,int n){S->elem=(int *)malloc(n*sizeof(int));If(S->elem==NULL)return-1;S->max=n;_____________=0;Return 0;} ` Int push(Stack *S,int item)/*将整数item压入栈中*/ {if(S->top==S->max){printf(*Stack is full!n);
Return-1;} _____________=irem;
Return 0;}
Int StackEmpty(Stack S){
Return(!S.top)?1:0;/*判断栈是否为空*/ }
Int pop(Stack *S)栈顶元素出栈*/ {
If(S->top){printf(“pop an empty stack!n”);
Return-1;
}
Return __________;
}
Void MultibaseOutput(long n,int B){
Int m;Stack S;
If(InitStack(&S,MAXSIZE)){printf(“Failure!n”);
Return;
}
Do{if(push(&S,________)){printf(“Failure!n”);
Return;}
N=________;
}while(n!=0);
While(!StackEmpty(S))/*输出B进制数*/ {m=pop(&S);
If(m<10)printf(“%d”,m);/*小于10，输出数字*/
Else printf(“%c”,m+55);/*大于或等于10，输出相应的字符*/ }
【程序员考试笔记三】推荐阅读：
在线考试程序09-13
技能考试程序+经验总结09-15
自学考试考生自考通过本科毕业论文的程序07-27
991“数据结构与C语言程序设计”考试大纲(2018版)08-04
中级执法资格考试(交警)第三章 事故处理程序.doc单选09-09
程序员简历封面模板06-21
程序员实习报告07-27
程序员调查报告08-10
程序员常用英语词汇09-09