培训第二课，Oracle。

第一讲 关系数据库概述

数据库简介

数据库

数据库是按照数据结构来组织、存储和管理数据的仓库
目前按照发展事件可分为两类：
1.现代数据模型：最经典的就是面向对象模型
2.传统的数据模型：包括层次模型、网状模型和关系模型三种。

1. 层次模型：用树形结构自顶向下表示实体和实体间1:n联系
2. 网状模型：用网状图形结构表示实体和实体间的m:n联系，网中结点之间的联系不受层次限制
3. 关系模型：用二维表格的形式来表示实体和实体间联系

数据库管理系统

数据库管理系统(Database Management System)是一种操纵和管理数据库的大型软件，用于建立、使用和维护数据库，简称DBMS。它对数据库进行统一的管理和控制，以保证数据库的安全性和完整性。用户通过DBMS访问数据库中的数据，数据库管理员也通过DBMS进行数据库的维护工作。它可使多个应用程序和用户用不同的方法在同时或不同时刻去建立，修改和询问数据库。大部分DBMS提供数据定义语言DDL（Data Definition Language）和数据操作语言DML（Data Manipulation Language），供用户定义数据库的模式结构与权限约束，实现对数据的追加、删除等操作。

数据库层次结构

硬件 - 操作系统 - 数据库、数据库管理系统 - 数据库应用系统 - 用户

用户指与数据库系统打交道的人员，包括三类人员：最终用户、数据库应用系统开发员、数据库管理员。

数据库应用系统指为满足用户需求、采用各种应用开发工具（Java、C++、PB、Delphi等）和开发技术开发的数据库应用软件。

数据库是存储在计算机上的、可共享的、有组织的、长期的、大量的数据的集合。

数据库管理系统是位于操作系统和关系型数据库应用系统之间的数据库管理软件。

关系数据库

关系数据库，是建立在关系数据库模型基础上的数据库，借助于集合代数等概念和方法来处理数据库中的数据，同时也是一个被组织成一组拥有正式描述性的表格，该形式的表格作用的实质是装载着数据项的特殊收集体，这些表格中的数据能以许多不同的方式被存取或重新召集而不需要重新组织数据库表格。关系数据库的定义造成元数据的一张表格或造成表格、列、范围和约束的正式描述。每个表格（有时被称为一个关系）包含用列表示的一个或更多的数据种类。 每行包含一个唯一的数据实体，这些数据是被列定义的种类。当创造一个关系数据库的时候，你能定义数据列的可能值的范围和可能应用于那个数据值的进一步约束。而SQL语言是标准用户和应用程序到关系数据库的接口。其优势是容易扩充，且在最初的数据库创造之后，一个新的数据种类能被添加而不需要修改所有的现有应用软件。主流的关系数据库有oracle、db2、sqlserver、sybase、mysql等。

目前关系数据库是数据库应用的主流，许多数据库管理系统的数据模型都是基于关系数据模型开发的。
1）关系数据库：在一个给定的应用领域中，所有实体及实体之间联系的集合构成一个关系数据库。
2）关系数据库的型与值：关系数据库的型称为关系数据库模式，是对关系数据库的描述，若干域的定义，在这些域上定义的若干关系模式；关系数据库的值是这些关系模式在某一时刻对应的关系的集合，通常简称为关系数据库。
关系数据库分为两类：一类是桌面数据库，例如Access、FoxPro和dBase等；另一类是客户/服务器数据库，例如SQL Server、Oracle和Sybase等。一般而言，桌面数据库用于小型的、单机的应用程序，它不需要网络和服务器，实现起来比较方便，但它只提供数据的存取功能。客户/服务器数据库主要适用于大型的、多用户的数据库管理系统，应用程序包括两部分：一部分驻留在客户机上，用于向用户显示信息及实现与用户的交互；另一部分驻留在服务器中，主要用来实现对数据库的操作和对数据的计算处理。

关系数据库就是以关系作为数据模型，对数据进行组织和管理的数据库系统
模型中以二维表的形式来描述数据
对于每个二维表，我们有一些限制条件，每个属性列有唯一的名称、属性的次序无所谓、元组的次序无所谓、每个属性中的数据必须具有相同的数据类型。

培训第一课，Java。

课程目标
熟练掌握Java语言，学会用Java编写代码
掌握面向对象在编程中的应用
熟练掌握异常的处理机制
熟练运用Java完成开发任务
熟练使用开发工具编写，调试和运行程序

第一讲 认识Java

Java的主要特点

1. 简单：语法与C和C++类似
2. 面向对象：类、对象；封装、继承、多态
3. 健壮：异常处理、垃圾回收、无指针
4. 与平台无关：通过二进制字节码(.class)和Java虚拟机(JVM)实现
   

Java安装与配置

官网下载JDK(Java开发工具包)，包含开发环境和运行环境，然后按照安装提示一步步进行。

环境变量

配置位置：右击“我的电脑”->“属性”项 -> “高级系统设置” ->“环境变量”

测试配置

打开命令提示行，输入java --version或者javac --version，按回车键，若能正常显示JDK的版本信息，就表明JDK已经安装和配置完成。

Java开发过程

Java开发的基本规则

1. Java源文件必须以”.java”为扩展名。源文件的基本组成部分是类(class)，class 关键字后面的即类名，如本例中的HelloWorld类。
2. 一个源文件中最多只能有一个public类，其他类的个数不限。如果源文件包含一个public类，则必须以类名命名源文件。
3. Java应用程序的执行入口是main()方法，它有固定的书写格式。
4. Java严格区分大小写。
5. 每条Java语句由分号结束。

   1 2 3

   public static void main(String [] args){ //main方法主体 }

第二讲 Java语言概述

Java语言基本元素

1. 标识符

标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。
定义规则
以英文大小写字母、下划线“_”、或“$”开始的一个字符序列。
数字不能作为标识符的第1个字符。
标识符不能是Java的关键词。
标识符大小写敏感且长度没有限制。

2. 关键字

关键字是程序里事先定义的，有特别意义的标识符，有时又叫保留字，不能当作一般的标识符使用。

3. 变量

是指在程序的运行过程中随时可以发生变化的量，是程序中数据的临时存放场所。定义变量的语法规则为：
变量数据类型 变量名 [ = 变量初值] ;
若要同时声明多个相同数据类型的变量，可以分别声明它们，也可以把它们都写在同一个语句中，每个变量之间以逗号分开，如下面的写法：
变量数据类型 变量名1[ = 变量初值1] ，变量名2 [ = 变量初值2]，变量名3 [ = 变量初值3];

4. 常量

指程序里持续不变的值，在整个程序运行过程中它是不可改变的。例如整数常量、字符串常量。
Java中用关键字final来声明常量，并且必须声明它所预保存的数据类型。

5. 数据类型

graph LR  A[数据类型] --> B[基本类型]  A --> C[引用类型]  B --> D[数值型]  B --> E[字符型]  B --> F[布尔型]  C --> G[类]  C --> H[接口]  C --> I[数组]  D --> J[整数类型]  D --> K[浮点类型]

boolean（逻辑型） 只有两种取值true or false，占用一个字节。
byte(字节类型) 一个byte 8位，占用1个字节（-128~127）
short(短整型) 一个short 16位，占用2个字节（-32768~32767）
int(整型)一个int 32位，占用4个字节（-2147483648~2147483647）
long(长整型) 一个long 64位占用8个字节（-2^63~2^63-1）
char(字符型) 一个char16位，占用2个字节，用于表示字符。
float（单精度浮点型） 一个float 32位，占用4个字节（-3.4E38 ~3.4E38）
double(双精度浮点型) 一个double 64位，占用8个字节 （-1.7E308 ~1.7E308）

1. 整数类型（byte、short、int默认、long）
   1、Java各整数类型有固定的表数范围和字段长度，其不受操作系统的影响，以保证Java程序的可移植性。
   2、Java语言的整形常量默认为int型，声明long型后面需加上l或者L，否则会出错。
2. 浮点数类型（float、double默认）
   1、与整数类型相似，Java浮点数类型有固定的表数范围和字段长度，不受平台影响。
   2、Java浮点型常量默认为double型，如要声明一个常量为float型，则需在数字后面加f或F，否则出错。
3. 字符类型（char）
   char类型的值通常用单引号(‘和’)括起来。
   例如：'a'、'中'、'\n'、'\u03A6'
4. 布尔类型（boolean）
   boolean类型适于逻辑运算且只有两个值：true 和 false

自动类型转换（隐式类型转换）
有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后进行计算。
boolean类型不可以转换为其他的数据类型。
整型、字符型、浮点型的数据在混合运算中相互转换，转换时遵守以下原则：

byte、short、char之间不会相互转换，他们三者在计算时首先会转换为int类型。得到的计算结果为int类型。

强制类型转换（显式类型转换）
容量大的数据类型转换为容量小的数据类型时，需要使用强制类型转换，其格式如下：

1
2

int b = 1; 
byte a = (byte)b;

在强制类型转换过程中，源类型的值可能大于目标类型，因此可能造成精度降低或溢出，使用时需注意。

浮点数
当两个整数相除时，小数点以后的数字会被截断，使得运算的结果保持为整数。想要得到运算的结果为浮点数，就必须将两个整数中的其中一个（或是两个）强制转换类型为浮点数
只要在变量前面加上欲转换的数据类型，运行时就会自动将此行语句里的变量做类型转换的处理，但这并不影响原先所定义的数据类型。

6.运算符

程序是由许多语句组成的，而语句的基本单位是表达式与运算符。
每个语句结束时，必须以分号“ ;”做结尾。
表达式是由操作数与运算符所组成：操作数可以是常量、变量也可以是方法，而运算符可以是数学运算符、逻辑运算符、地址运算符等。以下面的表达式（ z+100）为例，“ z”与“ 100”都是操作数，而“ +”就是运算符。

1. 按操作数的数目分：
   一元运算符：++ --
   二元运算符：+ - < > =
   三元运算符：?:
2. 按功能分：
   算术运算符：+，-，*，/，%，++，--
   关系运算符：>，>=，<，<=，==，!=
   逻辑运算符：!，&&，||
   赋值运算符：=，+=，-=，*=，/=
   条件运算符：?:
3. 运算符的优先次序
   1) ()
   2) ++ , -- , !
   3) * , / , %
   4) + , -
   5) > , < , >= , <=
   6) == , !=
   7) &
   8) |
   9) &&
   10) ||
   11) ?:
   12) = , += ，-=

自加(++)、自减(–)运算符
++(–)在前时先运算再取值
++(–)在后时先取值再运算

1
2
3
4

int i=0;
int j=i++ + ++i;
int k=--i + i--;
System.out.println(“j=” + j + ”,k=” + k);

结果为j=2,k=2

7.代码注释

1. // 注释一行
2. /* 注释多行 */
3. /** 文档注释 */

其中，用文档注释（/**……*/）的注释内容会被解释成程序的正式文档，并能包含进如 javadoc之类的工具生成的文档里，用以说明该程序的层次结构及其方法

控制语句

顺序结构

程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾。

graph TDA(开始) --> B[语句1]B --> C[语句n]C --> D(结束)

选择结构

根据条件的成立与否，再决定要执行哪些语句的结构。

graph TDA(开始) --> B{判断条件}B -->|True| C[语句1]B -->|False| D[语句2]C --> E[语句3]D --> EE --> F(结束)

代码大体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

if (判断条件) {
  语句 1 ；
  语句 2 ；
  …
  语句 n ；
}

or

if (判断条件){
  语句主体 1 ；
}
else{
  语句主体 2；
}

or

if (条件判断 1){
  语句主体 1;
}
else if (条件判断 2){
  语句主体 2;
}
… // 多个 else if()语句
else{
  语句主体 3;
}

or

switch (表达式){
  case 选择值 1:
    语句主体 1;
    break;
  case 选择值 2:
    语句主体 2;
    break;
    …….
  case 选择值 n:
    语句主体 n;
    break;
  default:
    语句主体;
}

switch表达式的返回值类型必须是int、byte、char、short中的一种。
case子句中的值value必须是常量，而且所有case子句中的值应是不同的。
default子句是可选的。
break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。

循环结构

根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。

graph TDA(开始) --> B{判断条件}B -->|True| C[语句1]B -->|False| D[语句2]C --> B[语句3]D --> E(结束)

代码大体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

for (赋值初值; 判断条件; 赋值增减量){
  语句 1;
  ….
  语句 n;
}

or

while (判断条件){
  语句 1;
  语句 2;
  …
  语句 n;
}

or

do{
  语句 1;
  语句 2;
  ….
  语句 n;
} while (判断条件)

当循环语句中又出现循环语句时，就称为嵌套循环。如嵌套 for 循环、嵌套 while循环等，当然读者也可以使用混合嵌套循环，也就是循环中又有其他不同种类的循环。

关键词

1. break
   离开当前层的循环主体，继续执行循环外的语句
2. continue
   跳出本次循环，回到循环起点，继续执行下一次循环
3. return
   从被调函数返回到主调函数继续执行

程序结构

包

1. 命名
   程序中使用package语句来声明包。
   package 包名;
2. 规则：
   • package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。
   • 包名可以是一个合法的标识符，也可以是若干个标识符加“.“分割而成。
   • 如果一个类有包名，那么存储文件的目录中必须包含有相应的结构。
3. 包语句
   程序如果使用了包语句，例如：
   package com.dareway.codec;
   那么存储文件的目录中必须包含有如下的结构：
   …\com\dareway\codec

如果在源程序中用到了除java.lang这个包以外的类，并且引用的类与源程序不在同一个包中，那么无论是系统的类还是自己定义的包中的类，都必须用import语句标识，以通知编译器在编译时找到相应的类文件。

类

1. 命名：
   Java 程序是由类（class）所组成。

   1 2 3

   public class HelloWorld { // 类声明 … }

2. 规则：
   在完整的 Java 程序里，至少需要有一个类。
   public修饰的类所在的原始程序的文件名不能随意命名，必须和 public 类名称一样。
   在一个独立的原始程序里，只能有一个 public 类，可以有许多非public 类。

大括号、段、主体

• 左大括号“ {”为主体开始的标记，至右大括号“ }”结束。
• 类和方法的主体要通过大括号进行标记。
• 每个命令语句结束时，必须以分号“ ;”做结尾。
• 当某个命令的语句不只一行时，必须以一对大括号“ {}”将这些语句包括起来，形成一个程序段（segment）或是块（block）。
• 在使用选择结构或是循环结构时，需要使用大括号将分支语句或是循环主体包括起来。

方法

1
2
3
4
5

[访问控制符] [修饰符] 返回值类型 方法名称（类型 参数 1，类型 参数 2， …）
{
程序语句 ；
return 表达式；
}

如果不需要传递参数到方法中，只需要将方法名称后面的()写出，不必填入任何内容。
如果方法没有返回值，则 return 语句可以省略，并且返回值类型应该为void

main方法
main()方法为程序的主方法，在一个Java应用程序中有且只能有一个 main()方法，它是程序运行的开端，有固定的格式，如下所示：

1
2
3
4

public static void main(String args[]) // 主程序入口   
{
  …
}

一维数组

声明数组

1. 格式
   • 类型名[] 数组名;
   • 类型名 数组名[];
2. 示例
   • int[] a，b；等价于 int a[],b[]；
   • int a[]，b；此处的b不是数组类型
   • float[] a = new float[10]；
   • float a[10]; 格式非法

创建数组

1. 格式：
   • 数组名 = new 类型名[长度]；
2. 举例
   • a = new int[20]；
   • float[] f = new float[100]；

数组初始化

1. 格式：
   • 数组类型 数组名[] = {元素1，元素2，…}
   • 数组类型 数组名[] = new 数据类型[]{元素1，元素2，…}
2. 示例：
   • int a[] = {1,2,3,4,5};
   • int[] b = new int[] { 1, 2, 3, 4, 5 };

数组访问

1. 格式：
   • 数组名[下标值]
   • 数组的下标值从0开始计
   • 每个数组都有一个属性length指明数组长度，即元素个数，格式：数组名.length
2. 示例：

   1 2 3 4 5

   int[] a = new int[]{1,2,3,4,5}; for(int i=0; i<a.length; i++){ a[i]=a[i]+1; System.out.print(a[i]+", "); }

多维数组

声明数组

1. 格式
   • 数组类型 数组名[][]
   • 数组类型[][] 数组名;
   • 数组类型[] 数组名[];
2. 示例
   • int a[][];
   • int[][] b;
   • int[] c[];
3. 特性
   • Java中没有真正的多维数组，只有数组的数组。
   • Java中多维数组不一定是规则矩阵形式。

创建数组

1. 格式：
   • 数组名 = new 数据元素类型[行数] [列数] ;
   • 数组名 = new 数据元素类型[行数] [] ;
2. 举例
   • int a[][] = new int[3][4];
   • int[][] b = new int[3][];
   • int[] c[] = newint[][4]; 非法，必须声明行的个数

数组初始化

1. 格式：
   • 数组类型 数组名[][] = { {元素11，元素12，…} , {元素21，元素22，… } }
   • 数组类型 数组名[][] = new 数据类型[][] { {元素11，元素12，…} , {元素21，… } }
2. 示例：
   • int a[][] = { {1,2,3}, {4,5}, {7} };
   • int b[][] = new int[][]{ {1,2,3}, {4,5}, {7} };

第三讲 面向对象基础

面向对象——实例

• 面向对象的编程思想力图使在计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能地一致。
• 类（class）和对象（object）就是面向对象方法的核心概念。
• 类是对某一类事物的描述，它们具有相同的属性和行为，是抽象的、概念上的定义。
• 对象是实际存在的该类事物的个体，因而也称实例（Instance）。

面向对象的特征

封装

将相关的数据以及对数据的操作结合在一起，保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法。
其有两层含义：

1. 相关的数据及其操作结合在一起，形成一个不可分割的独立单位，即对象。
2. 信息隐蔽，把不需要让外界知道的信息隐藏起来，或只允许使用对象的功能，而尽可能隐蔽对象的内部细节。

继承

首先拥有反映事物一般特性的类，然后在其基础上派生出反映特殊事物的类。被继承的类称为父类或超类，而经继承产生的类称为子类或派生类。根据继承机制，派生类继承了超类的所有成员，并相应地增加了自己的一些新的成员。
面向对象程序设计中的继承机制，大大增强了程序代码的可复用性，提高了软件的开发效率，降低了程序产生错误的可能性，也为程序的修改扩充提供了便利。

多态

多态是允许程序中出现重名现象。多态具体表现为：

1. 方法重载
   在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。
   同一个类中的多个方法有相同的方法名，不同的参数列表（参数个数不同或者对应位置上的参数类型不同）。
   只有返回类型不同不是重载。
2. 成员覆盖
   子类与父类允许具有相同的变量名称，数据类型相同，具有相同的方法名称，但完成的功能不同。
   若子类中的属性与父类的某一属性同名，则称该属性被覆盖。
   在子类中可以通过 super.属性名的方式调用父类中被子类覆盖的属性。
   若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数列表，我们说该方法被覆盖。
   在子类中可以通过 super.方法(参数列表)的方式调用父类中被子类覆盖的方法。

类

定义

Java 的每一个程序都是由类构成的，函数必须是属于某个类的。在使用类之前，必须先定义它，然后才可利用所定义的类来声明变量，并创建对象。

1
2
3
4
5
6
7

[类修饰符] class 类名{
    数据类型 属性 ；
    …. 
    数据类型 方法名称（参数 1，参数 2…） {
        程序语句 ；
    }
}

格式

1. 成员变量定义格式：
   [修饰符] 类型 属性名=[默认值];

2. 成员方法定义格式：

   1 2 3 4

   [访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…) { 方法体 }

3. 规则：

   • 类的修饰符一般为public，也可以没有修饰符。
   • 类的成员包含：成员变量（属性）、成员方法（方法）。
   • 通过“.”调用其属性和方法

构造方法

1
2
3
4
5
6
7
8

class 类名称
{
    访问权限 类名称（类型1 参数1，类型2 参数2，…）
    {
      程序语句 ；
      … // 构造方法没有返回值
    }
}

规则

• 构造方法名称必须和类名称一致。
• 构造方法没有返回值。
• 一个类可有多个构造方法（重载）。
• 构造方法不能被子类继承。
• 每个类至少需要一个构造方法，若某个类一个构造方法都未提供，系统将自动提供一个什么也不做（即无参且方法体为空）的默认构造方法。
• 只要某个类定义了任何一个构造方法，系统不再提供默认构造方法。
• 不能在构造方法中用return返回一个值。
• 构造方法只能被new运算符自动调用。

注意：构造方法不含返回值的概念不同于“void”，是指方法名之前不加返回值类型的修饰词；如果在定义构造方法时加上了“void”，这个方法就不再被自动调用了。

访问修饰符

1. public（公共）
   可以在其他任何位置访问，一般用来修饰类、方法和构造器
2. protected（保护）
   修饰的内容可以被同一个包的其他类访问，也可以被不同包中的子类访问，一般用来修饰只开放
   给子类使用的属性、方法和构造方法
3. 无访问控制符（默认）
   修饰的内容可以被同一个包中的类访问，一般用于修饰一个包内部的功能类
4. private
   修饰的内容是私有的，限制最大，只能在本类中访问，而不能被类外部的任何类访问，一般用来
   修饰类的属性或只在本类内部使用的方法

关键字

static

1. 静态变量
   用static 关键字声明的成员变量称为“ 静态成员变量”，或者称“ 类变量“，而没有用static声明的成员变量称为“ 实例成员变量”。
   访问修饰符 static 数据类型 变量名;static只能修饰类的成员变量，不能修饰局部变量。
   静态（类）成员变量是它所属类所有对象共享的，不管该类创建了一个对象，还是多个对象，甚至一个对象都没有创建，只要类装载时静态成员变量就已经存在，并且只具有一个静态数据值，因此，它是属于整个类而不是属于某个具体对象。
   实例成员变量只有在创建一个对象时才生成该对象的实例成员变量，且不同的对象具有不同的实例成员变量值，即各对象间的实例成员变量值是互相独立的。
   静态（类）变量可以通过类名直接访问，也可以通过对象名调用。
2. 静态方法
   static关键字修饰的方法为“静态方法”，又叫“类方法”。
   访问修饰符 static 返回值类型 方法名（参数列表）{……}
   静态（类）方法无需实例化就可以调用，可以直接使用类名调用，也可以通过对象名调用。
   静态（类）方法不能访问实例变量，只能访问静态（类）变量或静态（类）方法。

this

当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。

• this(参数列表)：调用其他构造函数。
• this.属性名：调用本对象的属性
• this.方法名：调用本对象的方法
  this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this

规则

通过this调用另一个构造方法，用法是this(参数列表)。
使用this（参数列表）语句调用其他构造方法时必须放在当前构造方法的第一行。
函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式。在没有同名的情况下，可以直接用成员变量的名字，也可以用this .成员变量名。
在方法中，需要引用该方法所属类的当前对象时候，直接用this。

extends

继承通过关键字extends实现

1
2
3
4
5
6
7
8
9

class 父类 // 定义父类
{
…
}
class 子类 extends 父类 
// 用 extends 关键字实现类的继承
{
…
}

super

如果在子类中想要调用父类的属性或方法，可以使用super关键字，super是用来指向当前对象的父对象的引用

• super(参数列表)：调用父类的构造函数。
• super.属性名：调用子类继承的父类属性
• super.方法名：调用子类继承的父类方法

规则

• 通过super调用父类的构造方法，用法是super (参数列表)。
• 使用super（参数列表）语句调用父类构造方法时必须放在子类构造方法的第一行。
• 子类的成员变量和父类成员变量同名的情况下，父类成员变量被屏蔽，此时要访问父类成员变量则需要用“super.成员变量名”的方式来引用父类成员变量。在没有同名的情况下，可以直接用成员变量的名字，也可以用super.成员变量名。
• 子类对象在实例化时会默认先去调用父类中的构造方法，之后再调用本类中的相应构造方法。
• 即使没有在子类构造方法中明确使用super（参数列表）调用父类构造方法，系统也会在子类构造方法的第一行隐含一句“super（）；”语句。当明确使用了super（参数列表）调用父类构造方法时，就不会再隐含“super（）；”语句了。

final

在 Java 中声明类、属性和方法时，可使用关键字 final 来修饰。

• final 标记的类不能被继承。
• final 标记的方法不能被子类复写。
• final 标记的变量（成员变量或局部变量）即为常量，只能赋值一次。

abstract

抽象方法

使用关键字abstract修饰的方法叫做抽象方法
abstract 返回值的数据类型 方法名称（参数…）；
抽象方法只需声明，而不需实现，不需要写{}

抽象类

使用关键字abstract修饰的类叫做抽象类

1
2
3
4
5
6
7
8
9

abstract class 类名称 // 定义抽象类
{
声明数据成员;
abstract 返回值的数据类型 方法名称(参数…);//抽象方法
访问权限 返回值的数据类型 方法名称(参数…)
{  //正常方法
    … 
}
}

• 抽象类和抽象方法都必须用 abstract 关键字来修饰。
• 抽象类不能被实例化，也就是不能用 new 关键字去产生对象。
• 抽象方法只需声明，而不需实现。
• 抽象类中可以没有抽象方法，但是含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

interface

接口interface的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有以下两点不同：

1. 接口里的数据成员必须初始化，且数据成员均为常量。
2. 接口里的方法必须全部声明为 abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。

1
2
3
4
5
6

interface 接口名称 
{
  final 数据类型 成员名称 = 常量; // 数据成员必须赋初值
  abstract 返回值的数据类型 方法名称(参数…);
  // 抽象方法，注意在抽象方法里，没有定义方法主体，不写｛｝
}

implements

利用接口打造新的类的过程，称之为接口的实现implements

1
2
3
4

class 类名称 implements 接口 A,接口 B {
  // 可以同时实现多个接口，用逗号隔开
  …
}

子类可以在继承一个父类的同时实现接口

1
2
3
4

class 子类 extends 父类 implements 接口 A,接口 B // 继承父类，同时实现接口
{
……
}

extends必须放在implements前面。
抽象类和接口都是无法直接实例化的，但可以通过子类对其进行实例化

对象

创建对象

1. 语法格式
   类名 对象名 = new 构造器
2. 示例
   Employee zhang = new Employee()

对象名实际是指向对象的一个引用，而引用和它所指的对象是两个不同的实体。

访问对象

1. 语法格式
   • 访问属性： 对象名称.属性名；
   • 访问方法： 对象名称.方法名()；
2. 示例:
   • Employee p=new Employee();
   • p.name; 访问对象p的name属性
   • p.sayHello();调用对象p的sayHello方法

比较对象

1. ==
   比较的是两个操作数的值是否相等，当操作数是对象时比较的是两个变量在堆中存储的地址是否相同
2. equals()
   比较的是两个对象的内容是否相同。

对象回收

对象名 = null；
通过将对象名指向null可以断开引用与对象之间的联系，当没有任何引用变量指向某个对象时，这个对象就成为无用对象。
Java虚拟机会自动地检测出那些不再使用的对象并自动地释放它们所占用的内存空间，这一功能是由Java虚拟机中的一个称为垃圾收集器（Garbage Collector ）的程序模块来完成的。

第四讲 常用类库介绍

String类

String类作为字符串的标准格式，是Java中最常用的字符串操作类。String 类对象的内容一旦被初始化就不能再改变。通常用来操作内容固定的字符串。

创建

1
2
3
4

String str1 = "Hello,dareway!";
 // 静态赋值，在常量池创建
String str2 = new String("Hello,dareway!");
// 动态赋值，在堆区创建

字符串连接

1
2

String str3 = "I am " + name + "!";
String str4 = str1 + str3;

查看字符串长度

1

str.length();

字符串比较

1
2
3
4

s1.equals(s2) //如果s1等于s2，返回true，否则为false。
s1.equalsIgnoreCase(s2) //忽略大小写,如果s1等于s2，返回true，否则为false。
s1.compareTo(s2) //如果s1<s2，返回小于0；如果s1=s2，返回0；如果s1>s2，返回大于0。
s1.compareToIgnoreCase (s2) //忽略大小写,如果s1<s2，返回小于0；如果s1=s2，返回0；如果s1>s2，返回大于0。

查找字符或子串

indexOf(); lastIndexOf();
返回值int型，找不到返回-1

1
2
3
4
5
6
7
8
9
10

String s1 = "Hello,dareway!";
String s2  = "da";
System.out.println(s1. indexOf ('e'));
//返回s1中字符e在字符串中第一次出现的位置。
System.out.println(s1. indexOf (s2));
//返回s2在s1中第一次出现的位置。
System.out.println(s1. lastIndexOf (‘e’));
//返回字符e在s1中最后一次出现的位置。
System.out.println(s1. lastIndexOf (s2));
//返回s1中字符char在字符串中最后一次出现的位置。

提取字符或子串

charAt();提取单个字符
substring();提取子串

1
2
3
4
5
6
7

String s1 = "Hello,dareway!";
System.out.println(s1.charAt(5));
//返回s1中第6个字符。其中，index是下标号，从0开始。
System.out.println(s1.substring(6));
//截取s1中下标从6开始的所有字符。
System.out.println(s1.substring(6,10));
//截取s1中下标从6到10的所有字符，不包含10 。

过滤首尾空格

trim()

1
2

String s1 = "     Hello,dareway!     ";
System.out.println(s1.trim()); // 输出Hello,dareway

大小写转换

toLowerCase();转换小写
toUpperCase();转换大写

1
2

System.out.println(s1.toLowerCase());//小写
System.out.println(s1.toUpperCase());//大写

StringBuffer类

StringBuffer对象可以方便地在缓冲区内被修改，如增加、替换字符或子串，适合于处理可变字符串。当完成缓冲字符串数据操作后，可以通过调用其方法StringBuffer.toString( )或String构造器把它们有效地转换回标准字符串格式。

创建

1
2

StringBuffer strbuf= new StringBuffer();
StringBuffer strbuf= new StringBuffer(“abc”);

常用方法

1
2
3
4
5
6
7
8

append(String str);//在字符串末尾添加内容
toString();//转换为不变字符串
length();//获取字符串的长度:
setLength(int len);//设置字符串缓冲区的大小
insert(int offset, String str),在offset位置插入字符串。
delete(int start,int end)//删除指定字符串中的字符
substring(int start) //返回从start下标开始以后的字符串
substring(int start,int end) //返回从start到 end-1字符串

包装类

Java 对数据既提供基本数据的简单类型，也提供了相应的包装类。基本数据类型和相应包装类的对应关系如下：

基本数据
包装类 对象 = new 包装类(基本数据/String);
包装类 对象 = 包装类.valueOf(基本数据/String);
Character类只能根据基本数据得到包装类对象

1. 得到基本数据
   包装类对象.xxxValue(); 转换成相应类型
   包装类.parseXxx(String); 转换成原始类型
2. 得到字符串
   String s1 = int c.toString();
String s2 = Integer.toString(10);
3. 比较
   obj1.equals(obj2);相同或者不同包装类对象比较
   obj1.compareTo(obj2);同一包装类对象比较

ArrayList

创建方法

ArrayList表示大小可变的数组，可以动态的增加和减少元素。
创建对象的方法如下：

1
2
3

ArrayList list1 = new ArrayList();
ArrayList<String> list2 = new ArrayList<String>();
ArrayList<Integer> list3 = new ArrayList<Integer>();

常用方法

1
2
3
4
5
6
7
8

add(element) //添加一个元素到当前列表的末尾
addAll(Collection)//添加一组元素到当前列表的末尾
remove(int) //移除指定位置的元素
size() //查看列表长度
get(int) //获取指定下标的元素
set(int , element) //设置指定下标的元素
contains(Object) //查找某个对象在不在列表之中
toArray()//把ArrayList的元素复制到一个新的数组中

HashMap

创建方法

基于哈希表的 Map 接口的实现。通过“键-值”对（key-value）访问，并允许使用 null 值和 null 键。 创建对象的方法如下：

1

HashMap<String,String>map = new HashMap<String,String>();

常用方法

1
2
3
4
5
6
7

put(key,value) //添加一组键值对到map中
get(key)//获取key对应的value
isEmpty () //是否为空
containsKey(key) //查找某个对象在不在map之中
size() //获取map元素数量
keySet() //获取所有key列表
values() //获取所有values列表

第五讲 断点调试

断点调试

1. 设置断点
2. 单步运行

应用场景分析

1. 查看控制台报错
2. 分析控制台报错
3. 断点跟踪

第六讲 Java异常处理

异常

运行期间出现的错误，而不是编译时的语法错误。

• 打开一个不存在的文件。
• 网络连接中断。
• 操作数组越界等。
• …

抛出(throw)异常

• 在Java程序执行过程中如果出现异常事件，
• 系统会发出异常报告，
• 这时系统将生成一个异常类对象，
• 异常类对象封装了异常事件的信息并将其提交给Java运行时系统，
• 运行时系统寻找相应的代码来处理这一异常,
• 这一过程称为抛出(throw)异常。

捕获(catch)异常

• 当Java运行时系统得到一个异常对象时，
• 它将会沿着方法的调用栈逐层回溯，
• 寻找处理这一异常的代码。
• 找到能够处理这种类型的异常的方法后，
• 运行时系统把当前异常对象交给这个方法进行处理，
• 这一过程称为捕获(catch)异常。

继承关系

• Java通过面向对象的方法来处理程序异常
• 不同异常有不同的分类
• 但所有的异常类都直接或间接地继承于java.lang.Throwable类。
• 当Java程序出现意外时，会实例化一个从Throwable类继承的对象。

Error类

错误Error类指的是系统错误或运行环境出现的错误，这些错误一般是很严重的错误，即使捕捉到也无法处理，由Java虚拟机生成并抛出，包括系统崩溃、虚拟机错误等，在Java程序中不做处理。

Exception类

异常Exception类则是指一些可以被捕获且可能恢复的异常情况，是一般程序中可预知的问题。对于异常又可分为两类：

运行时异常

Java虚拟机在运行时生成的例外，由系统检测, 用户可不做处理，系统将它们交给缺省的异常处理程序。

非运行时异常

一般程序中可预知的问题，其产生的例外可能会带来意想不到的结果，因此Java编译器要求Java程序必须捕获或声明所有的非运行时异常。

异常处理

1
2
3
4
5
6
7
8
9
10
11

try{
  //接受监视的程序块,在此区域内发生的异常,由catch中指定的程序处理
}catch(MyException e){
  //处理异常
}catch(Exception e){
  //处理异常
}
…
}finally{
  //最终处理（可选）
}

try…catch语句

try{…}选定捕获异常的范围；每个try代码块可以伴随一个或多个catch语句。
catch语句只需要一个形式参数指明它所能够捕获的异常类型，这个类必须是Throwable的子类。
在catch块中是对异常对象进行处理的代码。
捕获异常的顺序和catch语句的顺序有关，一旦捕获到一个异常，剩下的catch语句就不再进行匹配。由于所有的子类实例都可以使用父类接收，因此在安排catch语句的顺序时，首先应该捕获最特殊的异常（范围小），然后再逐渐一般化（范围大）。也就是一般先安排子类，再安排父类。

finally语句

finally语句放在try …catch语句后。
fianlly语句中的代码块不管异常是否被捕获总是要执行。
通常在finally语句中可以进行资源的清除操作，如：关闭打开文件、删除临时文件。
对应finally代码中的语句，即使try代码块和catch代码块中使用了return语句退出当前方法或break跳出某个循环，相关的finally代码块也会执行。
当try或catch代码块中执行了System.exit(0)时，finally代码块中的内容不被执行

不要在finally中试图return一个值，这样可能会导致一些意想不到的逻辑错误，finally仅用来释放资源的！

throws语句

如果一个方法中的语句执行时可能生成某种异常，
但是并不能确定如何处理，
则可以在程序所在的函数声明后，
使用throws关键字回避异常，
通知潜在调用者，如果发生了异常，必须由调用者处理。

1
2
3
4

[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…)  throws 异常类
 { 
    方法体 
}

规则：
位置：函数参数列表的后面。
throws关键字后面，可以跟多个异常，中间用逗号分割
throws关键字抛出的异常，由调用该函数的函数处理

throw语句

可以在程序中抛出明确的异常，使用 throw 这个关键字。
throw 异常类实例对象;

规则：
throw语句用在方法体内,表示抛出异常,由方法体内的语句处理。
throw语句不能单独使用，要么和try.. catch…一起使用，要么和throws一起使用。
throw语句的操作数一定是Throwable类类型或Throwable子类类型的一个对象。

秋招进行中，记录我的笔试编程题目。

多益网络

题目：不使用递归，实现二叉树的后序遍历
算法思想：从根开始然后依次将左节点入栈当到达该树最左时，输出此节点、出栈此节点并开始将栈中的节点的右子树入栈，然后重复上述过程直到栈空
代码：

吉比特

1.指数幂求模

题目：求 $a^p \mod b$ 的结果
输入：$a<10000 , p<10000000000 , b<10000$

1

9 5 33

输出：

1

12

算法思想：
代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;

int PowMod(int n, long long p,int M){
int ans = 1;
while (p > 0){
if (p % 2 == 1){
ans = (ans*n) % M;
}
p /= 2;
n = (n*n) % M;
}
return ans;
}

int main() {
int a,mod;
long long b;
cin >> a >> b >> mod;
cout << PowMod(a,b,mod);
return 0;
}

2.摊位问题

题目：学校摆摊，已知摊位能拜访的所有位置，两摊位之间不能相邻（斜着不算），总共有多少种摆摊方法
输入：第一行确定矩阵大小$n*m$，接下来给出矩阵元素，1表示可以摆摊，0表示不能摆摊

1
2
3

2 3
1 1 1
0 1 0

输出：实际结果对987654321取余

1

9

算法思想：
代码：

JSP开发环境的配置运行

（一）JDK安装与配置

1．安装JDK

运行下载的JDK软件包，可安装SDK，在安装过程中可以设置安装路径及选择组件，系统默认的安装路径为C:\ jdk1.5(当然也可以自己设定)，默认的组件选择是全部安装。

2．JDK环境变量的配置

第一步：进入系统属性选择高级属性。

第二步： 进入环境变量界面。

第三步： 添加环境变量值。

第四步：添加PATH路径 C:\jdk1.5\bin(即JDK安装目录下的bin目录)

（二）Tomcat安装与配置

1．安装Tomcat

运行下载的Tomcat软件包，可安装SDK，在安装过程中可以设置安装路径及选择组件，安装路径为C:\Tomcat5，默认的组件选择是全部安装。

2．Tomcat环境变量的配置

第一步：进入系统属性选择高级属性。

第二步：进入环境变量界面。

第三步：添加环境变量值。

第四步：添加PATH路径 C:\Tomcat5.0\bin

（三）Eclipse的安装与配置

1．安装Eclipse

先解压eclipse-SDK-3.2.1-win32.zip文件，然后运行MyEclipseEnterpriseWorkbenchInstaller_5.0.1GA_E3.2.exe软件。并选择安装路径，当安装提示要选择Eclipse SDK时，选择已经解压好的eclipse文件目录，然后照提示完成安装。

2．Eclipse的环境配置

先运行MyEclipse 5.0GA软件，第一次运行时需要建立一个工程文件目录，这里根据个人习惯自行建立。进入Eclipse界面后：
第一步：选择windows菜单选择Preferences项。

第二步：进入Preferences界面在type filter text中选择MyEclipse再选Application Server再选择Tomcat 5。后面操作如下图，分别选择Tomcat的安装路径，并选择Enable激活。

第三步：配置JDK。点开Tomcat，选择JDK。并点add。

第四步：添加JDK。在“JRE name：”写上JRE的名称（可以任意命名），在“JRE home directory”栏点browse选择JDK的安装路径。然后点确定，最后点击完成。

第五步：测试安装是否成功。检测是否能启动Tomcat。

（四）在Eclipse上建立一个JSP

1．建立一个新的工程文件，名为exam1。

2．建立一个JSP，名为First.jsp

3． 编写JSP程序。

在First.jsp中编写：

1
2
3

<body>
  hello! This is my the First JSP page. <br>
</body>

（五）部署JSP工程文件

1．进入开部署界面

点击

2．部署：在Project中选择要部署的工程文件，再点add。

（六）启动Tomcat服务器

（七）浏览JSP

打开浏览起，在地址栏输入：http://localhost:8080/exam1/First.jsp 。

JSP Servlet技术

Web应用程序有严格定义的目录结构，它需要一个称为部署描述文件的文件web.xml来配置。对应用程序的每个Servlet，可以在web.xml中定义若干个初始化参数，然后通过ServletConfig对象获取这些参数。

ServletContext对象表示该应用程序的环境，通过该对象可以获得应用程序范围的初始化参数、容器版本信息、资源的URL、在其中存放共享数据以及登录日志等。

Servlet事件监听

在Web应用程序中，事件的处理也是通过事件监听器接口处理的。Web应用事件处理的原理为：当Web应用中某些状态改变时，Servlet容器就产生某种事件，如ServletContext对象初始化时会产生ServletContextEvent事件，此时Servlet容器就会从注册的事件监听器中寻找处理该事件的监听器对象，并执行相应的代码。

在Servlet 2.4规范中共定义了6种事件类型和8个事件监听器接口，它们可以处理三种对象上的事件，如下表所示：

Servlet过滤器的使用

过滤器是web服务器上的组件，它们对客户和资源之间的请求和响应进行过滤。

过滤器的工作原理是：当servlet容器接收到对某个资源的请求，它要检查是否有过滤器与之关联。如果有过滤器与该资源关联，servlet容器将把该请求发送给过滤器。在过滤器处理完请求后，它将做下面3件事：

1. 产生响应并将其返回给客户；
2. 如果有过滤器链，它将把（修改过或没有修改过）请求传递给下一个过滤器；
3. 将请求传递给不同的资源。

当请求返回到客户时，它是以相反的方向经过同一组过滤器返回。过滤器链中的每个过滤器够可能修改响应。
过滤器API主要包括：Filter、FilterConfig和FilterChain接口。

JSP 会话管理

HTTP协议是无状态的协议。在很多情况下，Web服务器必须能够跟踪客户的状态。比如，对于一个购物网站，在一个时刻可能有多个客户购物，Web服务器必须能够区分不同的客户。一般情况下，Web服务器为每个客户配置了虚拟的购物车（ShoppingCart）。当某个客户请求将一个商品放入购物车时，Web服务器必须根据发出请求的客户的身份，找到该客户的购物车，然后把商品放入其中。

Web服务器跟踪客户的状态通常有4种方法：
（1）使用HttpSession对象管理会话；
（2）使用持久的Cookie对象；
（3）使用URL重写机制；
（4）使用隐藏的表单域。

JSP基本语法与页面指令

JSP语法元素有<% %>、<%@ %>、<%= %>和<%! %>四种，分别是运行Java代码、jsp的初始化以及导入、输出java表达式的值和java初始化代码

JSP有三个指令元素：page、include和taglib。这些指令元素是针对JSP引擎的，并不会产生任何看得见的输出。它们都包含在<%@和%>标签内。主要学会使用page指令。

<%@ page %>指令作用于整个JSP页面，包括静态包含的页面，但不包括动态包含的页面。可以在一个页面中包含多个<%@ page %>指令，但其属性除import外只能在整个页面中出现一次。<%@ page %>指令可以放在页面的任何位置，但为了JSP程序的可读性，一般将<%@ page %>指令放在页面的前面。<%@ page %>主要包含以下几种基本属性：1）import、引用类文件；2）language，指定脚本语言；3）contentType，指定jsp编码方式；

JSP隐含对象与作用域

在JSP页面的转换阶段（JSP页面转换后定义的类名为：implicit_jsp，该类继承了org.apache.jasper.runtime.HttpJspBase），JSP引擎在_jspService()方法中声明并初始化了9个隐含对象，它们主要是为了方便在JSP页面对这些对象的访问。这些隐含对象包括：application、session、request、response、out、page、pageContext、config、exception。

在上述9个隐含对象中，有下面4个作用域对象，它们是：application、session、request、pageContext。它们主要用来在不同作用域中共享数据。

一）request对象

request对象是javax.servlet.http.HttpServletRequest对象的一个实例。每次客户端请求一个页面时，JSP引擎都会创建一个新的对象来表示那个请求。
request对象提供方法来获取HTTP头信息，包括表单数据，cookies，HTTP方法等。

二）response对象

response对象是javax.servlet.http.HttpServletResponse对象的一个实例。当服务器创建request对象时，它也创建了代表客户端响应的对象。
response对象还定义了接口，可以处理创建的新的HTTP 头。通过这个对象JSP程序员可以添加新的cookies或日期stamps，HTTP状态码等。

三）out对象

out隐式对象是javax.servlet.jsp. JspWriter对象的一个实例，用于在响应中发送内容，在Servlet中可以通过pageContext.getOut()来获取该对象。
最初的JspWriter对象被实例化不同程度地取决于页面是否缓冲。通过使用页面指令的buffered='false'属性，缓冲可以很容易地关掉。
JspWriter对象包含大部分与java.io.PrintWriter类相同的方法。然而，JspWriter对象有一些额外的方法用来处理缓冲。与PrintWriter对象不同，JspWriter抛出IOException。

四）session对象

session对象是javax.servlet.http.HttpSession的一个实例，且行为与Java Servlet中的session对象完全相同，在Servlet中可以通过pageContext.getSession()来获取该对象。
session对象是用来跟踪客户端请求之间的客户端会话。

五）application对象

application对象是用于生成的Servlet的ServletContext对象的直接包装器，且实际上是javax.servlet.ServletContext对象的一个实例，在Servlet中可以通过pageContext.getServletContext()来获取该对象。
这个对象是JSP页面整个生命周期的一个代表。当初始化JSP页面时，这个对象被创建，当JSP页面由jspDestroy()方法删除时，该对象也会被删除。
通过为application添加属性，可以确保生成web应用程序的所有JSP文件可以访问它。

六）config对象

config对象是javax.servlet.ServletConfig的一个实例，且是用于生成的servlet的ServletConfig对象的直接包装器，在Servlet中可以通过pageContext.getServletConfig()来获取该对象。
该对象允许JSP程序员访问Servlet或JSP引擎初始化参数，如路径或文件位置等。
下面的config方法是唯一一个可能曾经使用的方法，且它的使用很简单：config.getServletName();
这返回servlet的名称，该名称是包含在定义在web-inf\web.xml文件中元素中的字符串。

七）pageContext对象

pageContext对象是javax.servlet.jsp.PageContext对象的一个实例。pageContext对象用于表示整个JSP页面。
这个对象是作为一种手段来访问页面信息的，同时避免了大部分的实现细节。
这个对象为每个请求存储了请求引用和响应对象。application，config，session，out对象是通过访问该对象的属性派生出来的。
pageContext对象还包含发布到JSP页面的指令信息，包括缓冲信息，errorPageURL，页面范围。
pageContext类定义了几个领域，包括PAGE_SCOPE，REQUEST_SCOPE，SESSION_SCOPE，和APPLICATION_SCOPE，它确定了这四个范围。它还支持40多个方法，大约一半的方法是继承了javax.servlet.jsp.JspContext类的。
重要方法之一是removeAttribute()，该方法接受一个或两个参数。例如，pageContext.removeAttribute(“attrName”)从全部范围中删除属性，而下面的代码仅从页面范围中删除它：pageContext.removeAttribute("attrName", PAGE_SCOPE);

八）page对象

这个对象是一个页面实例的真实引用。它可以被认为是一个对象，代表了整个JSP页面。page对象实际上是this对象的一个直接的同义词。

九）exception对象

exception对象是一个包装器，包含来自先前页面的异常抛出。它通常用于为错误条件生成一个适当的响应。

JSP组件重用与JavaBean

通过重用Web组件可以提高应用程序开发的效率和其可维护性。在JSP中可以通过包含机制和JavaBean实现Web组件的重用。

包含分为静态包含和动态包含。静态包含通过include指令实现，动态包含通过标准动作jsp:include实现。

在JSP页面中使用JavaBean是最重要的组件重用技术，这主要是通过下面3个标准动作实现的：
<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>

表达式语言

表达式语言（EL）是JSP 2.0新增的功能。它是一种简洁的数据访问语言，通过它可以在JSP页面中方便地访问应用程序数据，无需使用JSP表达式（<%=和%>）。EL的目标是使动态网页的设计、开发和维护更加容易。JSP表达式语言（EL）使得访问存储在JavaBean中的数据变得非常简单。JSP EL既可以用来创建算术表达式也可以用来创建逻辑表达式。在JSP EL表达式内可以使用整型数，浮点数，字符串，常量true、false，还有null。

EL的特点是访问数据可以使用点（.）运算符或方括号（[]）运算符；可以访问隐含对象；有自己的运算符构造表达式；可以使用Java语言编写的函数等。

JSTL与标签文件

JSP标准标签库（JSP Standard Tag Library，简称JSTL）是一个为实现Web应用程序的常用功能而开发的标签库集合。功能包括基本输入输出、流程控制、XML文件解析、数据库查询、国际化和文本格式化等。JSTL主要由下面几个库组成：核心标签库；XML标签库；格式化/国际化标签库；数据库标签库；函数标签库。

这些库都很有用，但我们这里只学习核心库的使用。核心库的标签又可以分成四类，如下表所示：

标签文件（tag file）也是JSP 2.0新增的功能，它的目的是使JSP页面开发人员仅使用JSP语法就能开发标签库而无须编写Java程序。所谓标签文件就是直接使用JSP语法编写的标签。标签文件的扩展名一般为.tag或.tagx，如果标签文件包含其他完整的或片段的标签文件，JSP 2.0建议其扩展名为.tagf。
在JSP页面中使用标签文件，需要在taglib动作中使用tagdir属性指定标签文件所在的目录，例如：
<%@ taglib prefix="mytag" tagdir="/WEB-INF/tags"%>

JSTL的安装
要在JSP页面中使用JSTL标签，首先必须安装JSTL库。可以到Jakarta网站下载最新版本的JSTL。
如果安装了Tomcat，可以在示例应用程序中获得JSTL，它位于\webapps\ examples\WEB-INF\lib目录中，共有两个文件：jstl.jar和standard.jar。将这两个文件复制到你的Web应用程序的WEB-INF\lib目录中，就安装了JSTL。

使用JSTL我们不用建立标签库描述文件，因为该文件已经包含在standard.jar文件中了，JSP容器可以找到该文件。另外，也可以不用配置web.xml文件，因为JSP容器使用隐含映射的方式可以将标准的URI映射到适当的标签库上。

这个学期，我们开始学习游戏程序制作，同时也接触到了两个2d游戏引擎，Cocos2d-x和Unity，现在就来讲讲Unity的学习心得

这个学期，我们开始学习利用Android Studio制作手机游戏程序，现在就先讲讲我的学习心得

这个学期，我们开始学习游戏程序制作，同时也接触到了两个2d游戏引擎，Cocos2d-x和Unity，现在就先讲讲Cocos2d-x的学习心得

在这个寒假，家里人都在问我有没有考研计划，我苦思良久，终于还是决定试上一试。GG

考研科目共分为四项：两门公共课、一门基础课、一门专业课
两门公共课（各100分）：政治（马原24分、毛概30分、史纲14分，思修16分、形政16分）、英语（完型10分、阅读A40分、阅读B（即新题型）10分、翻译10分、大作文20分、小作文10分）
一门基础课（150分）：数学一（高数84分、线性代数33分、概率统计33分）
一门专业课（150分）：计算机（数据结构45分、计算机组成原理45分、操作系统35分、计算机网络25分）

考研数学

简单粗暴数学复习法——常规三阶段：

1. 基础阶段（从零开始，夯实基础）（3月——6月，基础差的可以提前复习）
   （1）视频
   杨超（或汤家凤）高数基础班（跟着做题，他写什么你写什么） 链接：http://pan.baidu.com/s/1hrRdr5U 密码：dejs
   张宇2012线性代数强化班（对线代宏观把握，对线代全新认识）
   （2）书籍
   高数课本（定积分、不定积分、多元函数、重积分这几章课后习题一定要做！打基础别偷懒！！）
   线代课本（只做一些证明除外的练习题）
   1800题（做前面的基础题，高数和线代）

2. 强化阶段（加强训练，深化理解）（7月——9月）
   （1）视频
   张宇高数强化班(14跨考版)——（记笔记、重在概念理解！） 链接：http://pan.baidu.com/s/1c1Xrd3i 密码：f5ki
   李永乐线代强化班——（重中之重，多听两遍都不为过） 链接：http://pan.baidu.com/s/1eRZoSxW 密码：xewb
   张伟概率强化班13版——（概率重点） 链接：http://pan.baidu.com/s/1qXV6JXq 密码：a7db（重点）
   链接：http://pan.baidu.com/s/1hsgCvWS 密码：txc5（补充）
   （2）书籍
   高数：李王复习全书（红皮）（主） +张宇高数18讲（辅）
   线代：李永乐线性代数讲义
   概率：张伟概率强化班讲义1800题（全科练手）

3. 冲刺阶段（攻克难点，真题模拟）（10月——靠前）
   （1）视频
   高数 杨超高分题型精讲——（看一遍，理解，自己做一遍） 链接：http://pan.baidu.com/s/1mii6bfq 密码：0a96
   其他视频只看自己的薄弱点部分，对症下药，自己总结下难点，逐一攻克，实在不懂的看之前强化班或者基础班的视频，还不会问同学，上贴吧找组织。 至于数学冲刺班，基本没有太多作用，可看可不看
   （2）书籍
   1800题+1000题（大量训练）
   李永乐真题试卷版（红皮）（近十年真题做至少两遍）
   合工大超越五套卷 链接：http://pan.baidu.com/s/1kVc23UB 密码：yg2m
   A4纸重点难点集合本（详细用法请看我的其他答案）
   在强化结束之余，如果复习感觉还不错的同学，希望你能将下列的内容予以掌握，这可以帮助你更深刻的理解考研数学，可以帮你极大提高你的计算速度，而且这些内容并不会花费你太多时间。学会这些实为锦上添花。但切勿本末倒置，基础为王，谨记。

4. 细节补充（本文特色所在 ！ ！ ！ ！ ！）
   微分方程——陈文灯微分算子法（解题速度极快！）—— 一天搞定
   无穷级数——毛纲源老师的数学复习全书无穷级数部分，很有用！—— 一个下午搞定
   不定积分——多项相乘用陈文灯老师的表格法！——不到两个小时掌握
   线性代数——张宇老师用一个向量将第一章到第六章所有内容穿针引线、一气呵成
   多维随机分布——方浩老师应用的卷积公式计算起来很方便—— 一个下午搞定

一、高等数学

二、线性代数

三、概率论与数理统计

考研专业

参考书目：王道单科以及真题，另外王道赠送模拟8套卷。

一.数据结构

严蔚敏的数据结构

二.计算机组成原理

唐朔飞的计算机组成原理

三.操作系统

汤子瀛的操作系统

四.计算机网络

谢希仁的计算机网络

考研英语

考研政治

基础的HTML标签及属性，简单的CSS样式

HTML标签

注释内容

1

<!--网页HTML语言的注释方法-->

根标签

1
2
3

<html>
    网页主框架，最外层嵌套的标签
</html>

头部标签

1
2
3

<head>
    网页主框架内的第一大类标签，主要用于设定网页的基本设置
</head>

标题栏标签

1
2
3

<title>
    网页标题内容
</title>

正文类型标签

1
2
3

<style>
    网页内嵌样式表
</style>

正文标签

1
2
3

<body>
    网页主框架内的第二大类标签，网页的主体，也是用户能看到的部分
</body>

普通标签

段落文本

代码：<p>段落</p>
样式：

段落

标题文本

代码：<hx>标题x</hx> x属于1到6 分别代表6级标题
样式：

斜体强调

代码：<em>斜体</em>
样式：斜体

加粗强调

代码：<strong>加粗</strong>
样式：加粗

单独样式

代码1：<span>单独</span>
样式1：单独
代码2：<div>单独</div>
样式2：

引用文本

代码1：<q>引用句</q>
样式1：引用句
代码2：<blockquote>引用段</blockquote>
样式2：

引用段

换行

代码：换行<br/>换行
样式：换行
换行

空格

代码：空格 空格
样式：空格 空格

水平线

代码：<br/>
样式：

联系地址信息

代码：<address>联系地址</address>
样式：

代码行

代码1：<code>代码</code>
样式1：代码
代码2：<pre>代码</pre>
样式2：pre>代码

列表（无序，在信息内容前加点；有序，在信息内容前加序号）

代码1：<ul><li>内容1</li><li>内容2</li></ul>
样式1：

• 内容1
• 内容2

1. 内容1
2. 内容2

超链接文本

代码：<a href="链接地址或邮件地址" target="打开链接的方式" title="提示内容">超链接</a>
样式：超链接

图片

代码：<img scr="图片地址" alt="加载失败后的提示" title="提示文本" />
样式：

表格标签

代码：

1
2
3
4
5
6
7
8
9
10
11
12

<table>
    <thead>
        <tr>
            <th>表头1</th><th>表头2</th><th>表头3</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>单元格</td><td>单元格</td><td>单元格</td>
        </tr>
    </tbody>
</table>

样式：

表头1	表头2	表头3
单元格	单元格	单元格

说明：

表单标签

代码：

1
2
3
4
5
6
7
8
9
10

<form method="传送方式 post/get" action="服务器文件 输入数据的目标文件">
    <input type="password/text 类型 密码显示或普通文本" />
    <textarea cols="列数" rows="行数"></textarea>
    <input type="radio/checkbox 类型 单选或多选" checked="checked 设置默认选中" />
    <select multiple="multiple 设置多选">
        <option selected="selected 设置为默认值"></option>
    </select>
    <input type="submit/reset 提交或重置表单"/>
    <label for="控件ID"></label>
</form>

样式：

说明：

CSS层叠样式表

1. 位置：于头标签的style标签内增添
2. 格式：由选择符与声明组成，其中声明又是由属性和值组成，多条声明之间由分号(;)分隔
3. 注释：格式为/*注释内容*/

形式

1. 内联式：在控件或标签处，调用属性style=”CSS代码（即声明）”
2. 嵌入式：对某一选择符标签的内容同意设置，内容嵌于<style type="text/css"></style>中
3. 外部式：将CSS样式单独保存于一个文件中，在<head>标签中用<link>标签将文件链接

<link>标签属性： href=”CSS地址” rel=”stylesheet” type=”text/css”
优先级 内联式 > 嵌入式 > 外部式
一般情况下符合就近原则

选择器

标签选择器

即选择器为HTML标签类型

类选择器

用英文.号+类名称作为选择器名，在需要的标签中添加class="类名"属性即可使用类名设定的CSS样式

ID选择器

用英文#号+ID名称作为选择器名，在需要的标签中添加id="ID名"属性即可使用ID名设定的CSS样式
ID是具有唯一性的，能且只能被一个标签调用；而类可以被重复使用；
一个标签可以拥有多个类设定的样式，调用时用空格隔开。

通用选择器

用英文*号作为选择器名，设定所有标签和控件的样式

特殊选择器

1. 伪类选择器：某种状态下的样式，有选择器名+英文:号+状态名构成新的选择器名，如hover，即鼠标移动到目标标签时的状态
2. 分组选择器：令多个选择器具有相同的样式，不同选择器之间用英文,号分开
3. 子选择器：指定某选择器下的第一代某种子元素的样式，一般两个选择器之间用英文>号分开
4. 后代选择器：指定某选择器下的所有某种子元素的样式，一般两个选择器之间用空格分开

特性

1. 继承性：某些样式具有继承性，即某选择器下所有元素军设定为某一样式；颜色可继承，边框不可继承
2. 特殊性：同一元素应用不同样式时，根据权值选择实际应用样式（标签选择器为1；类选择器为10；ID选择器为100；继承的权值最低），当权值相同时，越靠后的越优先
3. 重要性：!important最高权值，放在声明的分号前

声明

部分基本声明

批注：属性中的长度值单位一般为像素，即px；但有时也可以是字长，即em

元素

分类：块状；内联、内联块状

块状元素

用CSS声明display:block强制转换

1. 独占一行，每个块状元素新起一行
2. 元素的高度、宽度、行高、顶底边距都可以自行设置
3. 宽度默认为父容器的100%

常用元素： div p hx ol ul dl table address blockquote form

内联元素

用CSS声明display:inline强制转换

1. 与其他元素同行
2. 元素的高度、宽度、行高、顶底边距都不可自行设置
3. 宽度、高度都随着内容改变而变化

常用元素： a span br i em strong label q var cite code

内联块状元素

用CSS声明display:inline-block强制转换

1. 与其他元素同行
2. 元素的高度、宽度、行高、顶底边距都可以自行设置

常用元素： img input

盒子模型

边界(margin)

边界只有一个属性：size，可以分别设置某个方向上的边界，声明margin- + top/bottom/left/right即可
也可以统一设置，共有四种方式
margin: + 上+右+下+左/上下左右/上下+左右/上+左右+下

边框(border)

边框有三个属性：宽度、样式、颜色；样式有dashed(虚线)、dotted(点)、solid(实线)
可以分别设置某个方向的边框，只要在声明时，声明border- + top/bottom/left/right即可

填充(padding)

填充只有一个属性：size，可以分别设置某个方向上的填充，声明padding- + top/bottom/left/right即可
也可以统一设置，共有四种方式
padding: + 上 右 下 左/上下左右/上下 左右/上 左右 下

布局模型

流动(Flow)

块状元素自上而下依次排列，默认宽度为100%；
内联元素自左而右依次排列，水平显示

浮动(Float)

块状元素根据设置自左而右/自右而左依次排列
在CSS中声明float: + left(自左而右)/right(自右而左)

层(Layer)

使所有元素如同图层一般层叠显示
共有三种定位方式：position: + absolute(绝对定位，相对于父元素的位置)/relative(相对定位，相对于元素本身原来的位置)/fixed(固定位置，相对于浏览器视图的位置)
设置定位后在CSS中设置top和left属性即可确定位置

CSS小技巧

水平居中

1. text-align:center 适用于行内元素
2. margin: .. auto 适用于块状元素
3. 标签，将不定宽转为定宽
4. display:inline 将块状转换为行内

垂直居中

1. 设置height的值和line-height的值相同
2. 设置属性vertical-align:middle

数字图像处理技术概念

1. 图像
   图像是人类获取视觉信息的重要手段。
   “图”，就是物体投射或反射光的分布；“像”是人的视觉系统接收视觉信息而在人的大脑中形成的印象或认识。
   前者是客观存在的，而后者是人的感觉，图像应是两者的结合，即图像是对客观存在的物体的一种相似性的、生动的写真或描述。
   图像分为三类：
   1)可见图像：全部人眼可见（可接收到）的图像，包含了客观存在的光学图像和人类用各种不同方法人工生成的图像。
   2)不可见物理图像：各种可测到（客观存在) 的物理特征量的空间分别所构成的一大类图像。
   3)数学图像：抽象的数学图像，即用数学函数表达的图像，包括连续型和离散型。
2. 图像处理技术
   图像处理技术分为模拟图像处理和数字图像处理。模拟图像处理包括光学处理（利用透镜）和电子处理，如照相、电视信号处理等，其速度快，可并行处理，但精度和灵活性差。
   因此产生数字图像处理，它利用数字计算机或其他高速、大规模集成数字硬件，对图像信息转换来的数字电信号进行某些数字运算或处理，以期提高图像质量或达到人们所需要求的某些预期结果。
   数字图像处理的主要特点是图像信息量大、图像处理技术综合性强、图像信息理论与通信理论密切相关。
   数字图像处理技术的基本应用：图像增强/恢复；艺术级效果；医学可视化；工业检验；法律执行；人机交互。
   数字处理图像在生物医学 、遥感 、工业 、军事、通信、公安等领域有着广泛的应用。
3. 图像处理的内容
   图像信息的获取；
   图像信息的存贮；
   图像信息的传送；
   图像信息处理；
   图像信息的输出和显示。
4. 图像的数字化
   由一幅模拟图像获取一幅满足需求的数字图像，使图像便于计算机处理、分析。
5. 图像感知和获取
   图像形成模型在特定坐标(x,y)处，通过传感器转换获得的f值为一正的标量。
   函数f(x,y)由：①入射到观察场景的光源总量； ②场景中物体反射光的总量 组成。
6. 图像取样和量化
   获取图像的目标是从感知的数据中产生数字图像，但是传感器的输出是连续的电压波形，因此需要把连续的感知数据转换为数字形式。这一过程由图像的取样与量化来完成。数字化坐标值称为取样；数字化幅度值称为量化。图像的取样率：单位距离的取样数目（在两个空间方向上）。
   步骤可以分为：模拟图像信号=>空间采样=>灰度级(强度)量化
   坐标的数字化称为采样，幅度值的数字化称为量化。
7. 数字图像的表示
   由矩阵表示，矩阵的每个元素表示为图像的一个像素。
8. 空间和灰度分辨率
   空间分辨率是指图像中可分辨的最小细节，主要由采样间隔值决定。采样间隔值越小，空间分辨率越高
   灰度分辨率是指灰度级别中可辨别的最小变化，通常也把灰度级L称为灰度分辨率，一般情况L=2k，灰度级为L的图像一般也称为k位图像
9. 相邻像素
   处于4邻域、对角邻域、8邻域的像素
10. 邻接性
    像素的相邻仅说明了两个像素在位置上的关系，若再加上取值相同或相近，则称两个像素邻接。
    令V是用于定义邻接性的灰度值集合（相似性准则），存在三种类型的邻接性：
    (1)4邻接:若像素p和q的灰度值均属于V中的元素，且q在N4(p)中，则p和q是4邻接的；
    (2)8邻接:若像素p和q的灰度值均属于V中的元素，且q在N8(p)集中,则p和q是8邻接的；
    (3)m邻接(混合邻接):若像素p和q的灰度值均属于V中的元素，{①q在N4(p)中,或者②q在ND(p)中}且{集合N4(p)∩N4(q)没有V值的像素},则具有V值的像素p和q是m邻接的。m邻接可以消除8邻接所带来的（通路）二义性。
11. 通路
    像素$p(x_0,y_0)$到像素$q(x_n,y_n)$的通路定义为特定的像素序列：$(x_0,y_0),(x_1,y_1), (x_2,y_2) …,(x_n,y_n), st.(x_i,y_i)$和$(x_(i-1),y_(i-1))$(对于1≤i≤n)是邻接的。n是通路的长度。若$(x_0,y_0)=(x_n,y_n)$,则通路是闭合通路。
12. 连通性
    若S是图像中的一个象素子集，对任意的p,q∈S，如果存在一条由S中像素组成的从p到q的通路，则称p在图像集S中与q连通。
    如果S中仅有一个连通分量，则S叫连通集；
    所有属于S的连通到某一点p的像素点的集合被称为连通分量。
13. 区域
    R是图像中的像素子集，如果R是连通集，则称R为一个区域；两个区域，如果联合（并）为一个区域，则称这两个区域为邻接区域。①定义区域时，必须指明灰度相似性准则V={ }；②定义邻接区域时，还必须指明邻接类型；
14. 边界
    假设一副图像S中有K个不连接区域，且它们都不接触图像边界。前景就是所有连通分量的并集；背景就是图像出去前景的剩余像素；内边界就是一个区域的边缘或轮廓线。（即：该区域中和其背景相邻接的点的集合）
15. 距离
    像素的距离一共有四种定义方式：
    1)欧氏距离 = $\sqrt{(x-s)^2+(y-t)^2}$；
    2)D4(城市街区距离)距离 = $|x-s|+|y-t|$；
    3)D8(棋盘距离)距离 = $max⁡(|x-s|,|y-t|)$；
    4)Dm距离：用点间最短的通路定义。

数字图像处理基本操作

VisualStudio图片打开与保存

1.打开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;
// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}
// 生成打开图像文件的对话框
CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;
// 清楚之前打开的图像文件
m_sImage.Destroy();
m_rImage.Destroy();
// 将外部图像文件装载到CImage对象中
hResult = m_sImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}
if (m_sImage.GetBPP() != 24)
{
m_sImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}
bFileIsOpen = true;
// 设置主窗口标题栏内容
CString str;
str.LoadString(AFX_IDS_APP_TITLE);
AfxGetMainWnd()->SetWindowText(str + " - " + dlg.GetFileName());
InvalidateRect(NULL, NULL, FALSE);

2.保存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

if (m_rImage.IsNull()) {
AfxMessageBox(_T("你还没有生成一个要保存的图像文件！"));
return;
}
CString strFilter;
strFilter = "位图文件|*.bmp|JPEG 图像文件|*.jpg|GIF 图像文件|*.gif|PNG 图像文件|*.png||";
CFileDialog dlg(FALSE, NULL, NULL, NULL, strFilter);
if (IDOK != dlg.DoModal())
return;
// 如果用户没有指定文件扩展名，则为其添加一个
CString strFileName = dlg.GetPathName();
CString strExtension = dlg.GetFileExt();
if (strExtension.IsEmpty())
{
switch (dlg.m_ofn.nFilterIndex)
{
case 1:
strExtension = "bmp"; break;
case 2:
strExtension = "jpg"; break;
case 3:
strExtension = "gif"; break;
case 4:
strExtension = "png"; break;
default:
break;
}
strFileName = strFileName + _T(".") + strExtension;
}
// 图像保存
HRESULT hResult = m_rImage.Save(strFileName);
if (FAILED(hResult))
{
AfxMessageBox(_T("保存图像文件失败！"));
}

图像文件基本处理

1.图像文件信息读取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 图像打开判断
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}
// 图像属性
int x, y;
int nRows = m_sImage.GetHeight(); // 图像像素行数 即图像高度
int nCols = m_sImage.GetWidth(); // 图像像素列数 即图像宽度
int nBPP = m_sImage.GetBPP(); // 图像颜色位数
// 清空并创建目标图像
m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
return;
// 读取像素数组（由一维数组储存二维数组）
BYTE *sImageData = (BYTE*)m_sImage.GetBits(); // 原图像的像素数组
BYTE *rImageData = (BYTE*)m_rImage.GetBits(); // 目标图像的像素数组
int nRowBytes = m_sImage.GetPitch(); // 原图像的像素数组每行长度
int nLineBytes = m_rImage.GetPitch(); // 目标图像的像素数组每行长度

2.图像缩小

行、列的删除

1
2
3

// 缩小n倍
if (!m_rImage.Create(nCols/n, nRows/n, nBPP))
return;

3.图像放大

1)最近邻域内插法

在原图像上寻找最靠近的像素并把它的灰度值赋给栅格上的新像素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

void CDigitalImageProcessingDoc::OnNearestInterpolationScaling()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

int x;
int y;

CDialogScalingFactor mdlg;
if (mdlg.DoModal() != IDOK)   //输入水平和垂直方向放大系数
{
return;
}
if (mdlg.mHoriScalingFactor < 0 || mdlg.mVeriScalingFactor < 0)
{
AfxMessageBox(_T("缩放参数错误！"));
return;
}

int sWidth = m_sImage.GetWidth();  //原始图像宽度
int sHeight = m_sImage.GetHeight(); //原始图像高度

int rWidth = (int)(sWidth * mdlg.mHoriScalingFactor + 0.5);  //目标图像宽度
int rHeight = (int)(sHeight * mdlg.mVeriScalingFactor + 0.5);//目标图像高度
m_rImage.Destroy();
if (!m_rImage.Create(rWidth, rHeight, m_sImage.GetBPP(), 0))
return;

int sRowBytes = m_sImage.GetPitch();
int rRowBytes = m_rImage.GetPitch();

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();


for (y = 1; y < rHeight - 1; y++)
for (x = 1; x < rWidth - 1; x++)
{
int i = (int)(x / mdlg.mHoriScalingFactor);
int j = (int)(y / mdlg.mVeriScalingFactor);
rImageData[y*rRowBytes + x * 3] = sImageData[j * sRowBytes + i * 3];
rImageData[y*rRowBytes + x * 3 + 1] = sImageData[j * sRowBytes + i * 3 + 1];
rImageData[y*rRowBytes + x * 3 + 2] = sImageData[j * sRowBytes + i * 3 + 2];
}

UpdateAllViews(NULL); // 强制调用OnDraw
return;
}

2)双线性内插法

通过公式计算新像素的灰度值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

void CDigitalImageProcessingDoc::OnBilinearInterpolationScaling()
{
// TODO: 在此添加命令处理程序代码

if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

int x;
int y;

CDialogScalingFactor mdlg;
if (mdlg.DoModal() != IDOK)
{
return;
}
if (mdlg.mHoriScalingFactor < 0 || mdlg.mVeriScalingFactor < 0)
{
AfxMessageBox(_T("缩放参数错误！"));
return;
}

int sWidth = m_sImage.GetWidth();
int sHeight = m_sImage.GetHeight();

int rWidth = (int)(sWidth * mdlg.mHoriScalingFactor + 0.5);
int rHeight = (int)(sHeight * mdlg.mVeriScalingFactor + 0.5);

m_rImage.Destroy();

if (!m_rImage.Create(rWidth, rHeight, m_sImage.GetBPP(), 0))
return;

int sRowBytes = m_sImage.GetPitch();
int rRowBytes = m_rImage.GetPitch();

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();

for (y = 1; y < rHeight - 1; y++)
for (x = 1; x < rWidth - 1; x++)
{
double u = x / mdlg.mHoriScalingFactor;
double v = y / mdlg.mVeriScalingFactor;
int i = (int)u;
int j = (int)v;
u = u - i;
v = v - j;

if ((i >= sWidth - 1) && (j >= sHeight - 1))
{
rImageData[y*rRowBytes + x * 3] = sImageData[(sHeight - 1) * sRowBytes + (sWidth - 1) * 3];
rImageData[y*rRowBytes + x * 3 + 1] = sImageData[(sHeight - 1) * sRowBytes + (sWidth - 1) * 3 + 1];
rImageData[y*rRowBytes + x * 3 + 2] = sImageData[(sHeight - 1) * sRowBytes + (sWidth - 1) * 3 + 2];
}
else if (j >= sHeight - 1)
{
*(rImageData + y*rRowBytes + x * 3) = sImageData[(sHeight - 1) * sRowBytes + i * 3];
*(rImageData + y*rRowBytes + x * 3 + 1) = sImageData[(sHeight - 1) * sRowBytes + i * 3 + 1];
*(rImageData + y*rRowBytes + x * 3 + 2) = sImageData[(sHeight - 1) * sRowBytes + i * 3 + 2];
}
else if (i >= sWidth - 1)
{
rImageData[y*rRowBytes + x * 3] = sImageData[j * sRowBytes + (sWidth - 1) * 3];
rImageData[y*rRowBytes + x * 3 + 1] = sImageData[j * sRowBytes + (sWidth - 1) * 3 + 1];
rImageData[y*rRowBytes + x * 3 + 2] = sImageData[j * sRowBytes + (sWidth - 1) * 3 + 2];
}
else
{
rImageData[y*rRowBytes + x * 3] = (BYTE)((1 - u)*(1 - v)*(sImageData[j * sRowBytes + i * 3])
+ (1 - u)*v*(sImageData[(j + 1)*sRowBytes + i * 3])
+ u*(1 - v)*(sImageData[j*sRowBytes + (i + 1) * 3])
+ u*v*(sImageData[(j + 1)*sRowBytes + (i + 1) * 3]));
rImageData[y*rRowBytes + x * 3 + 1] = (BYTE)((1 - u)*(1 - v)*(sImageData[j * sRowBytes + i * 3 + 1])
+ (1 - u)*v*(sImageData[(j + 1)*sRowBytes + i * 3 + 1])
+ u*(1 - v)*(sImageData[j*sRowBytes + (i + 1) * 3 + 1])
+ u*v*(sImageData[(j + 1)*sRowBytes + (i + 1) * 3 + 1]));
rImageData[y*rRowBytes + x * 3 + 2] = (BYTE)((1 - u)*(1 - v)*(sImageData[j * sRowBytes + i * 3 + 2])
+ (1 - u)*v*(sImageData[(j + 1)*sRowBytes + i * 3 + 2])
+ u*(1 - v)*(sImageData[j*sRowBytes + (i + 1) * 3 + 2])
+ u*v*(sImageData[(j + 1)*sRowBytes + (i + 1) * 3 + 2]));
}
}

UpdateAllViews(NULL); // 强制调用OnDraw
return;
}

数字图像基本操作

1.算数操作

算术运算只涉及一个空间位置（象素）的运算；
算术运算在相同大小的图像之间进行；

1)加

作用：去除“叠加性”噪音；图像叠加。
定义：g(x,y) = f(x,y) + h(x,y)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

void CDigitalImageProcessingDoc::OnImageAdd()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

CImage lsImage;
CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;

// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}

CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;

lsImage.Destroy();

// 将外部图像文件装载到CImage对象中
hResult = lsImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}

if (lsImage.GetBPP() != 24)
{
lsImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}

if ((lsImage.GetHeight() != m_sImage.GetHeight()) || (lsImage.GetWidth() != m_sImage.GetWidth()))
{
lsImage.Destroy();
AfxMessageBox(_T("本软件只处理相同大小图像的逻辑与代数运算！"));
return;
}

CDialogImageAddRatio mdlg;
if (mdlg.DoModal() != IDOK)
{
lsImage.Destroy();
return;
}

double lambuda = mdlg.addRatio / 100.0;

int x;
int y;
int nRows = m_sImage.GetHeight();
int nCols = m_sImage.GetWidth();
int nBPP = m_sImage.GetBPP();

m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
{
lsImage.Destroy();
return;
}

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *lsImageData = (BYTE *)lsImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();
int nRowBytes = m_sImage.GetPitch();

int sRowBytes = m_sImage.GetPitch();

for (y = 0; y < nRows; y++)
for (x = 0; x < nCols; x++)
{
rImageData[y * nRowBytes + x * 3 + 0] = (int)(lambuda * sImageData[y * nRowBytes + x * 3 + 0] + (1 - lambuda) * lsImageData[y * nRowBytes + x * 3 + 0]);
rImageData[y * nRowBytes + x * 3 + 1] = (int)(lambuda * sImageData[y * nRowBytes + x * 3 + 1] + (1 - lambuda) * lsImageData[y * nRowBytes + x * 3 + 1]);
rImageData[y * nRowBytes + x * 3 + 2] = (int)(lambuda * sImageData[y * nRowBytes + x * 3 + 2] + (1 - lambuda) * lsImageData[y * nRowBytes + x * 3 + 2]);
}

lsImage.Destroy();

UpdateAllViews(NULL);
}

2)减

作用：去除不需要的叠加性图案；检测两幅图像之间的差别；计算物体边界的梯度（差分运算）；
定义：g(x,y) = f(x,y) - h(x,y)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

void CDigitalImageProcessingDoc::OnImageSub()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

CImage lsImage;
CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;

// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}

CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;

lsImage.Destroy();

// 将外部图像文件装载到CImage对象中
hResult = lsImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}

if (lsImage.GetBPP() != 24)
{
lsImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}

if ((lsImage.GetHeight() != m_sImage.GetHeight()) || (lsImage.GetWidth() != m_sImage.GetWidth()))
{
lsImage.Destroy();
AfxMessageBox(_T("本软件只处理相同大小图像的逻辑与代数运算！"));
return;
}

CDialogImageAddRatio mdlg;
if (mdlg.DoModal() != IDOK)
{
lsImage.Destroy();
return;
}

double lambuda = mdlg.addRatio / 100.0;

int x;
int y;
int nRows = m_sImage.GetHeight();
int nCols = m_sImage.GetWidth();
int nBPP = m_sImage.GetBPP();

m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
{
lsImage.Destroy();
return;
}

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *lsImageData = (BYTE *)lsImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();
int nRowBytes = m_sImage.GetPitch();

int sRowBytes = m_sImage.GetPitch();
int nrgb;
for (y = 0; y < nRows; y++)
for (x = 0; x < nCols; x++)
{
nrgb = (int)(lambuda * sImageData[y * nRowBytes + x * 3 + 0] - (1 - lambuda) * lsImageData[y * nRowBytes + x * 3 + 0]);
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 0] = nrgb;
nrgb = (int)(lambuda * sImageData[y * nRowBytes + x * 3 + 1] - (1 - lambuda) * lsImageData[y * nRowBytes + x * 3 + 1]);
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 1] = nrgb;
nrgb = (int)(lambuda * sImageData[y * nRowBytes + x * 3 + 2] - (1 - lambuda) * lsImageData[y * nRowBytes + x * 3 + 2]);
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 2] = nrgb;
}

lsImage.Destroy();

UpdateAllViews(NULL);
}

3)乘

作用：图象的局部显示（用二值模板图像与原图像做乘法）
定义：g(x,y) = f(x,y) × h(x,y)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

void CDigitalImageProcessingDoc::OnImageMul()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

CImage lsImage;
CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;

// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}

CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;

lsImage.Destroy();

// 将外部图像文件装载到CImage对象中
hResult = lsImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}

if (lsImage.GetBPP() != 24)
{
lsImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}

if ((lsImage.GetHeight() != m_sImage.GetHeight()) || (lsImage.GetWidth() != m_sImage.GetWidth()))
{
lsImage.Destroy();
AfxMessageBox(_T("本软件只处理相同大小图像的逻辑与代数运算！"));
return;
}

int x;
int y;
int nRows = m_sImage.GetHeight();
int nCols = m_sImage.GetWidth();
int nBPP = m_sImage.GetBPP();

m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
{
lsImage.Destroy();
return;
}

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *lsImageData = (BYTE *)lsImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();
int nRowBytes = m_sImage.GetPitch();

int sRowBytes = m_sImage.GetPitch();
int nrgb;
for (y = 0; y < nRows; y++)
for (x = 0; x < nCols; x++)
{
nrgb = (int)(sImageData[y * nRowBytes + x * 3 + 0] * lsImageData[y * nRowBytes + x * 3 + 0]);
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 0] = nrgb;
nrgb = (int)(sImageData[y * nRowBytes + x * 3 + 1] * lsImageData[y * nRowBytes + x * 3 + 1]);
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 1] = nrgb;
nrgb = (int)(sImageData[y * nRowBytes + x * 3 + 2] * lsImageData[y * nRowBytes + x * 3 + 2]);
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 2] = nrgb;
}

lsImage.Destroy();

UpdateAllViews(NULL);
}

4)除

作用：增强两幅图像的差异。
定义：g(x,y) = f(x,y) ÷ h(x,y)
实际运算是将一幅图像取反后乘上另一幅图像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

void CDigitalImageProcessingDoc::OnImageDiv()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

CImage lsImage;
CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;

// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}

CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;

lsImage.Destroy();

// 将外部图像文件装载到CImage对象中
hResult = lsImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}

if (lsImage.GetBPP() != 24)
{
lsImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}

if ((lsImage.GetHeight() != m_sImage.GetHeight()) || (lsImage.GetWidth() != m_sImage.GetWidth()))
{
lsImage.Destroy();
AfxMessageBox(_T("本软件只处理相同大小图像的逻辑与代数运算！"));
return;
}

int x;
int y;
int nRows = m_sImage.GetHeight();
int nCols = m_sImage.GetWidth();
int nBPP = m_sImage.GetBPP();

m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
{
lsImage.Destroy();
return;
}

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *lsImageData = (BYTE *)lsImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();
int nRowBytes = m_sImage.GetPitch();

double alpha = 0.0001;
int sRowBytes = m_sImage.GetPitch();
int nrgb;
for (y = 0; y < nRows; y++)
for (x = 0; x < nCols; x++)
{
nrgb = (int)(sImageData[y * nRowBytes + x * 3 + 0] / (lsImageData[y * nRowBytes + x * 3 + 0] + alpha));
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 0] = nrgb;
nrgb = (int)(sImageData[y * nRowBytes + x * 3 + 1] / (lsImageData[y * nRowBytes + x * 3 + 1] + alpha));
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 1] = nrgb;
nrgb = (int)(sImageData[y * nRowBytes + x * 3 + 2] / (lsImageData[y * nRowBytes + x * 3 + 2] + alpha));
nrgb = (nrgb < 0) ? 0 : ((nrgb>255) ? 255 : nrgb);
rImageData[y * nRowBytes + x * 3 + 2] = nrgb;
}

lsImage.Destroy();

UpdateAllViews(NULL);
}

2.逻辑操作

在逻辑运算中，象素灰度值作为二进制串处理
“与”、“或”操作可用来从一幅图像中提取子图像。

1)与(&)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

void CDigitalImageProcessingDoc::OnImageAnd()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

CImage lsImage;
CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;

// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}

CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;

lsImage.Destroy();

// 将外部图像文件装载到CImage对象中
hResult = lsImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}

if (lsImage.GetBPP() != 24)
{
lsImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}

if ((lsImage.GetHeight() != m_sImage.GetHeight()) || (lsImage.GetWidth() != m_sImage.GetWidth()))
{
lsImage.Destroy();
AfxMessageBox(_T("本软件只处理相同大小图像的逻辑与代数运算！"));
return;
}


int x;
int y;
int nRows = m_sImage.GetHeight();
int nCols = m_sImage.GetWidth();
int nBPP = m_sImage.GetBPP();

m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
{
lsImage.Destroy();
return;
}

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *lsImageData = (BYTE *)lsImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();
int nRowBytes = m_sImage.GetPitch();

int sRowBytes = m_sImage.GetPitch();

for (y = 0; y < nRows; y++)
for (x = 0; x < nCols; x++)
{
rImageData[y * nRowBytes + x * 3 + 0] = sImageData[y * nRowBytes + x * 3 + 0] & lsImageData[y * nRowBytes + x * 3 + 0];
rImageData[y * nRowBytes + x * 3 + 1] = sImageData[y * nRowBytes + x * 3 + 1] & lsImageData[y * nRowBytes + x * 3 + 1];
rImageData[y * nRowBytes + x * 3 + 2] = sImageData[y * nRowBytes + x * 3 + 2] & lsImageData[y * nRowBytes + x * 3 + 2];
}

lsImage.Destroy();

UpdateAllViews(NULL);
}

2)或(|)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

void CDigitalImageProcessingDoc::OnImageOr()
{
// TODO: 在此添加命令处理程序代码
if (m_sImage.IsNull())
{
AfxMessageBox(_T("请打开要处理的图像！"));
return;
}

CImage lsImage;
CString strFilter;
CSimpleArray<GUID>  aguidFileTypes;
HRESULT hResult;

// 获取CImage支持的图像文件的过滤字符串
hResult = m_sImage.GetExporterFilterString(strFilter, aguidFileTypes, _T("All Image Files"));
if (FAILED(hResult))
{
AfxMessageBox(_T("GetExporterFilter函数失败!"));
return;
}

CFileDialog dlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, strFilter);
if (IDOK != dlg.DoModal())
return;

lsImage.Destroy();

// 将外部图像文件装载到CImage对象中
hResult = lsImage.Load(dlg.GetPathName());
if (FAILED(hResult))
{
AfxMessageBox(_T("图像文件加载失败！"));
return;
}

if (lsImage.GetBPP() != 24)
{
lsImage.Destroy();
AfxMessageBox(_T("只处理24位色图像！"));
return;
}

if ((lsImage.GetHeight() != m_sImage.GetHeight()) || (lsImage.GetWidth() != m_sImage.GetWidth()))
{
lsImage.Destroy();
AfxMessageBox(_T("本软件只处理相同大小图像的逻辑与代数运算！"));
return;
}


int x;
int y;
int nRows = m_sImage.GetHeight();
int nCols = m_sImage.GetWidth();
int nBPP = m_sImage.GetBPP();

m_rImage.Destroy();
if (!m_rImage.Create(nCols, nRows, nBPP))
{
lsImage.Destroy();
return;
}

BYTE *sImageData = (BYTE *)m_sImage.GetBits();
BYTE *lsImageData = (BYTE *)lsImage.GetBits();
BYTE *rImageData = (BYTE *)m_rImage.GetBits();
int nRowBytes = m_sImage.GetPitch();

int sRowBytes = m_sImage.GetPitch();

for (y = 0; y < nRows; y++)
for (x = 0; x < nCols; x++)
{
rImageData[y * nRowBytes + x * 3 + 0] = sImageData[y * nRowBytes + x * 3 + 0] | lsImageData[y * nRowBytes + x * 3 + 0];
rImageData[y * nRowBytes + x * 3 + 1] = sImageData[y * nRowBytes + x * 3 + 1] | lsImageData[y * nRowBytes + x * 3 + 1];
rImageData[y * nRowBytes + x * 3 + 2] = sImageData[y * nRowBytes + x * 3 + 2] | lsImageData[y * nRowBytes + x * 3 + 2];
}

lsImage.Destroy();

UpdateAllViews(NULL);
}