万本电子书0元读

万本电子书0元读

顶部广告

零基础学编程系列(全5册)励志改变人生,编程改变命运电子书

售       价:¥

49人正在读 | 0人评论 6.2

作       者:张昆,戴艳,康莉,李宽,黄传禄,常建功,陈浩,张克强,赵越,岂超凡

出  版  社:机械工业出版社

出版时间:2020-07-02

字       数:226.0万

所属分类: 科技 > 计算机/网络 > 程序设计

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
《零基础学算法(第4版)》   本书从日常生活中常见的实例入手,引领读者进入算法和数据结构的抽象世界。由于数据结构、算法的知识比较抽象,使许多读者望而却步。本书在编写过程中,尽量使用读者容易理解的、简单的语言来描述算法和数据结构,对于一些复杂的内容,采用图文并茂的方式介绍其原理,使读者能很快理解相关知识。第1~5章介绍了常用算法和数据结构的相应代码,第6~8章介绍了使用数据结构和算法解决一些经典问题的程序,第9章介绍了信息学奥赛部分试题的解题代码,第10章给出了与算法和数据结构相关的常见面试题。书中的所有程序都是在Dev-C++开发环境中编写而成的,本书附录简单介绍了该开发环境的使用。   《零基础学C语言(第4版)》   本书分为“C语言基础”“一窥C语言门径”“C语言进阶”“C语言程序设计实例与面试题解析”四篇,系统全面地介绍了C语言各个方面的知识,从简单的“Hello World”程序写起,逐步深化、细化,篇。书中对每个知识和技术要点都给出了翔实的示例及代码分析。和其他书籍中罗列代码的做法不同,本书中的代码力求短小精悍,直击要点,避免了细枝末节对读者思维的干扰。在讲解知识点的同时辅以笔者多年的C语言编程经验解析,可加深读者的理解。   《零基础学Java(第5版)》   Java语言拥有面向对象、跨平台、分布式、高性能、可移植等优点和特性,是目前应用广泛的编程语言之一。Java语言不仅可以制作网站后台,而且还能够操作各种操作系统;不仅可以应用于多媒体开发,而且还可以制作大型网络游戏;目前流行的手机操作系统Android也是在Linux内核的基础上通过Java语言实现的。本书的目的是让读者对Java语言的语法有更进一步的了解,尤其为新手进入编程行业提供一个全面学习的阶梯。笔者结合自己多年的学习和编程经验,为广大程序员详细介绍了Java的全部语法,使程序员能够夯实自己的基础知识,完善自己的知识结构,拓宽自己的知识面。在讲解知识点时,笔者采用由浅入深、逐级递进的学习方式。本书是Java语言初、中级学习者的绝佳入门指南。   《零基础学Python(第2版)》   作为流行的脚本语言之一,Python具有内置的高级数据结构和简单有效的面向对象编程思想实现。同时,其语法简洁清晰,类库丰富强大,非常适合进行快速原型开发。另外,Python可以运行在多种系统平台下,从而使得只需要编写一次代码,就可以在多个系统平台下都保持同等的功能。为了使广大读者既能够掌握Python语言的基础知识,又能够将Python语言应用于某个特定的领域(如Web开发),本书将全面介绍和Python相关的内容。在学习完本书之后,读者应该能够很好地掌握Python语言,同时可以使用Python语言进行实际项目的开发。   《零基础学:微信小程序开发》   本书从微信小程序的结构及其常用的API开始,讲解了微信开发工具各面板的功能和使用、常用框架的搭建、UI组件的功能和使用、API的使用、事件的监听和处理、数据的交互和处理等知识点。书中包含大量的实战项目,方便读者更快地掌握微信小程序的知识运用、项目接口和各种功能模块的编写思路。
目录展开

零基础学算法(第4版)

目录

前言

上篇 算法与数据结构基础

第1章 基础算法思想

1.1 编程的灵魂:数据结构+算法

1.2 算法的作用:猜价格游戏

1.2.1 算法的作用

1.2.2 实例:看商品猜价格

1.3 枚举(穷举)算法思想

1.3.1 算法思路

1.3.2 实例:填数游戏

1.3.3 实例:填运算符

1.4 递推算法思想

1.4.1 算法思路

1.4.2 顺推实例:斐波那契数列

1.4.3 逆推实例:该存多少钱

1.5 递归算法思想

1.5.1 算法思路

1.5.2 实例:求阶乘

1.5.3 实例:数制转换

1.6 分治算法思想

1.6.1 算法思路

1.6.2 实例:乒乓球比赛日程安排

1.7 贪婪算法思想

1.7.1 算法思路

1.7.2 实例:找零钱

1.8 试探算法思想

1.8.1 算法思路

1.8.2 实例:生成彩票号码组合

1.9 模拟算法

1.9.1 算法思路

1.9.2 实例:猜数游戏

1.9.3 实例:掷骰子游戏

1.10 算法的评价

1.10.1 算法评价原则

1.10.2 算法的效率

1.11 上机实践

第2章 简单数据结构

2.1 最简单的结构:线性表

2.1.1 线性表的概念

2.1.2 操作顺序表

2.1.3 操作链表

2.1.4 实例:用链表制作通讯录

2.2 后进先出结构:栈

2.2.1 栈的概念

2.2.2 操作栈

2.2.3 实例:算术表达式求值

2.3 先进先出结构:队列

2.3.1 什么是队列

2.3.2 操作队列

2.3.3 循环队列的操作

2.3.4 实例:银行排号程序

2.4 上机实践

第3章 复杂数据结构

3.1 层次关系结构:树

3.1.1 树的概念

3.1.2 二叉树的概念

3.1.3 二叉树的存储

3.1.4 操作二叉树

3.1.5 遍历二叉树

3.1.6 测试二叉树

3.1.7 线索二叉树

3.1.8 最优二叉树(赫夫曼树)

3.2 网状关系:图

3.2.1 图的定义和基本术语

3.2.2 图的存储

3.2.3 图的创建

3.2.4 图的遍历

3.2.5 最小生成树

3.2.6 最短路径

3.3 上机实践

第4章 常用算法——排序

4.1 排序概述

4.1.1 排序算法分类

4.1.2 数据准备

4.2 冒泡排序法

4.2.1 冒泡排序法概述

4.2.2 改进的冒泡排序法

4.3 快速排序法

4.3.1 算法描述

4.3.2 算法实现

4.4 简单选择排序法

4.5 堆排序法

4.5.1 算法描述

4.5.2 算法实现

4.6 直接插入排序法

4.6.1 算法描述

4.6.2 算法实现

4.7 希尔(Shell)排序法

4.7.1 算法描述

4.7.2 算法实现

4.8 合并排序法

4.8.1 算法描述

4.8.2 算法实现

4.9 排序算法的选择

4.9.1 选择基准

4.9.2 各种排序算法的优缺点

4.10 上机实践

第5章 常用算法——查找

5.1 查找的基本概念

5.2 简单查找

5.2.1 顺序查找

5.2.2 折半查找

5.3 二叉排序树

5.3.1 二叉排序树的定义

5.3.2 插入节点

5.3.3 查找节点

5.3.4 删除节点

5.4 索引查找

5.4.1 索引的概念

5.4.2 索引查找算法

5.5 散列表

5.5.1 散列表概述

5.5.2 构造散列函数

5.5.3 处理冲突

5.5.4 创建和查找散列表

5.6 上机实践

下篇 用算法与数据结构解决实际问题

第6章 数学问题

6.1 有趣的整数

6.1.1 完数

6.1.2 亲密数

6.1.3 水仙花数

6.1.4 自守数

6.1.5 最大公约数和最小公倍数

6.2 素数

6.2.1 求素数

6.2.2 回文数

6.2.3 哥德巴赫猜想

6.3 阶乘

6.3.1 用递归计算阶乘

6.3.2 大数阶乘

6.4 求π的近似值

6.4.1 概率法

6.4.2 割圆法

6.4.3 公式法

6.4.4 计算任意位数的π

6.5 方程求解

6.5.1 高斯消元法解线性方程组

6.5.2 二分法解非线性方程

6.5.3 牛顿迭代法解非线性方程

6.6 矩阵的运算

6.6.1 矩阵的加法和乘法运算

6.6.2 多维矩阵转一维矩阵

6.6.3 逆矩阵

6.6.4 稀疏矩阵

6.7 一元多项式的运算

6.7.1 多项式加法

6.7.2 多项式减法

6.8 上机实践

第7章 数据结构问题

7.1 约瑟夫环

7.2 大整数四则运算

7.2.1 使用数组进行大整数运算

7.2.2 使用链表进行大整数运算

7.3 进制转换

7.3.1 进制转换的分析

7.3.2 进制转换实现代码

7.4 括号匹配

7.5 中序式转后序式

7.5.1 后序表达式

7.5.2 算法实现

7.5.3 后序表达式求值

7.6 停车场管理

7.6.1 问题分析

7.6.2 算法实现

7.7 迷宫求解

7.7.1 迷宫问题

7.7.2 算法实现

7.7.3 求迷宫的所有路径

7.8 LZW压缩

7.8.1 LZW的相关概念

7.8.2 LZW压缩过程

7.8.3 LZW压缩的实现

7.8.4 LZW解压缩过程

7.8.5 解压缩函数

7.8.6 集成压缩和解压缩功能

7.9 上机实践

第8章 经典算法问题

8.1 不定方程问题

8.1.1 百钱买百鸡

8.1.2 存钱利息最大化

8.1.3 求阶梯数

8.1.4 五家共井

8.1.5 鸡兔同笼

8.2 推算问题

8.2.1 猴子吃桃

8.2.2 舍罕王的赏赐

8.3 魔术方阵

8.3.1 简捷连续填数法

8.3.2 双向翻转法

8.3.3 井字调整法

8.4 智力趣题

8.4.1 汉诺塔

8.4.2 背包问题

8.4.3 马踏棋盘

8.4.4 八皇后问题

8.4.5 青蛙过河

8.4.6 三色旗

8.5 趣味游戏

8.5.1 取石子游戏

8.5.2 生命游戏

8.5.3 洗扑克牌

8.5.4 黑白棋

8.5.5 凑24点游戏

8.5.6 10点半游戏

8.6 上机实践

第9章 信息学奥赛试题精解

9.1 NOIP普及组试题精解

9.1.1 求级数之和

9.1.2 求素数组合

9.1.3 计算卒的路线

9.1.4 检查校验码

9.1.5 排座位

9.1.6 击鼓传花

9.1.7 绘制模拟立体图

9.1.8 公路上的树

9.1.9 采药

9.1.10 求等价表达式

9.1.11 不开心的龙龙

9.1.12 孙悟空摘桃

9.1.13 FBI树

9.1.14 外星人的语言

9.2 NOIP提高组试题精解

9.2.1 砝码称重

9.2.2 阿明的零花钱

9.2.3 购买年货

9.2.4 调整队形

9.2.5 均分纸牌

9.2.6 最小矩形面积

9.2.7 低价买股票

9.2.8 数字金字塔

9.2.9 方格取数

9.2.10 导弹防御系统

9.3 上机实践

第10章 常见面试题及解答

10.1 数据结构类面试题

10.1.1 选择题

10.1.2 编程题

10.2 经典算法类面试题

附录 Dev-C++开发环境的使用

零基础学C语言(第4版)

目录

前言

第一篇 C语言基础

第1章 踏上征程前的思想动员

1.1 为什么选择C语言

1.2 如何学好C语言

1.3 语言概述

1.3.1 什么是语言

1.3.2 什么是机器语言

1.3.3 什么是汇编语言

1.3.4 面向过程的语言

1.3.5 什么是C语言

1.4 程序的开发周期

1.4.1 编辑C源代码

1.4.2 编译C源代码

1.4.3 连接目标文件

1.4.4 编译连接过程示例

1.4.5 运行程序

1.5 C、C++、VC++的区别和开发环境

1.6 小结

1.7 习题

第2章 跟我写Hello World

2.1 了解需求才能创建程序

2.2 认识Code::Blocks开发环境

2.2.1 为什么选择Code::Blocks

2.2.2 启动Code::Blocks

2.2.3 新建Hello World项目

2.2.4 定义新项目

2.2.5 添加源代码到项目

2.2.6 调试器设置

2.2.7 开始编辑代码

2.3 编译运行

2.4 调试排错(debug)

2.4.1 debug的由来

2.4.2 设置断点

2.4.3 调试运行

2.5 第一个程序容易出现的错误

2.5.1 包含命令include

2.5.2 关键字main

2.5.3 表示代码行结束的分号

2.6 小结

2.7 习题

第3章 分解Hello World——最简单C程序的组成

3.1 C程序的构成

3.2 C程序的注释

3.3 C程序必须有的main函数

3.4 调用函数在屏幕上显示文字

3.5 #include预处理器指示符

3.5.1 函数声明及其作用

3.5.2 试验寻找#include的作用

3.5.3 #include的作用

3.6 计算1+1的程序实例

3.7 数据从哪里来,又到哪里去——变量

3.7.1 变量在内存中的表现形式

3.7.2 编译器使用变量符号表

3.7.3 变量及其使用

3.8 自己设计C函数

3.8.1 在main函数中计算3个整数的平均数

3.8.2 在main函数中分3次计算3个整数的平均数

3.8.3 自编函数实现计算3个整数的平均数

3.8.4 如何自编写函数

3.8.5 观察总结函数声明和函数定义的意义

3.9 语句构成程序

3.10 优秀程序员的代码风格

3.11 小结

3.12 习题

第4章 常量、变量及数据类型

4.1 计算机是如何表示数据的

4.1.1 二进制、八进制、十六进制

4.1.2 表示数据的字节和位

4.1.3 内存是存储数据的房间

4.2 数据类型

4.2.1 整数类型

4.2.2 整数的有符号和无符号

4.2.3 实数类型

4.2.4 字符类型

4.2.5 数据类型总结

4.3 常量

4.3.1 直接常量和符号常量

4.3.2 符号常量的优点

4.3.3 直接常量的书写格式

4.3.4 转义字符

4.3.5 字符串

4.4 变量

4.4.1 变量的声明

4.4.2 变量声明的意义

4.4.3 标识符和关键字

4.4.4 变量在内存中占据的空间和变量的值

4.4.5 为变量赋初值

4.4.6 变量使用时常见的错误

4.5 几个与变量相关的经典算法

4.5.1 累加和累乘

4.5.2 交换两个变量的值

4.6 小结

4.7 习题

第5章 用屏幕和键盘交互——简单的输出和输入

5.1 输入—处理—输出:这就是程序

5.2 向屏幕输出——printf()函数详解

5.2.1 printf()函数的一般形式

5.2.2 printf()函数的输出原理

5.2.3 格式控制字符串的一般形式

5.2.4 输出带符号的整数%d

5.2.5 设置最小宽度的输出

5.2.6 长整型输出%ld

5.2.7 输出八进制形式

5.2.8 输出十六进制的形式

5.2.9 输出十进制的unsigned型数据

5.2.10 输出字符

5.2.11 输出字符串%s

5.2.12 输出实型数据%f

5.2.13 输出指数形式的实数

5.2.14 自动选择%f或者%e形式输出%g

5.2.15 printf()函数的几点说明

5.3 字符输出putchar()和字符串输出puts()

5.3.1 字符输出函数

5.3.2 字符串输出函数

5.4 接收键盘输入——scanf()函数详解

5.4.1 scanf()函数的一般形式

5.4.2 scanf()函数的输入原理

5.4.3 多数据输入分隔规则

5.4.4 控制输入的格式字符

5.4.5 scanf()函数的使用说明

5.4.6 使用scanf()函数的注意事项

5.5 字符输入函数getchar()

5.6 输入和输出程序举例

5.7 小结

5.8 习题

第6章 程序的基本构成——运算符和表达式

6.1 认识C中的运算符和表达式

6.1.1 运算符和表达式

6.1.2 操作数、运算符和表达式

6.1.3 C运算符简介

6.2 算术运算符和算术表达式

6.2.1 基本的算术运算符

6.2.2 ++自增、--自减运算符

6.2.3 算术表达式和运算符的优先级及结合性

6.3 逗号运算符和逗号表达式

6.3.1 逗号表达式的一般形式

6.3.2 逗号表达式的优先级和结合性

6.4 关系运算符和关系表达式

6.4.1 关系运算符的种类

6.4.2 关系表达式的一般形式

6.5 逻辑运算符和逻辑表达式

6.5.1 逻辑运算符

6.5.2 逻辑真值表

6.6 赋值运算符和赋值表达式

6.6.1 赋值表达式

6.6.2 复合运算符

6.7 强制类型转换和自动类型转换

6.7.1 强制类型转换

6.7.2 自动类型转换

6.8 运算符的优先级

6.8.1 优先级、结合性汇总

6.8.2 sizeof运算

6.9 取地址运算符

6.10 小结

6.11 习题

第7章 程序的最小独立单元——语句

7.1 5种语句类型

7.1.1 表达式语句

7.1.2 函数调用语句

7.1.3 空语句

7.1.4 复合语句(块语句)

7.1.5 流程控制语句

7.2 结构化程序设计

7.2.1 什么是算法

7.2.2 算法的表示

7.2.3 算法的伪代码表示

7.2.4 算法的流程图表示

7.2.5 3种控制结构

7.2.6 算法示例

7.3 小结

7.4 习题

第8章 条件判断——分支结构

8.1 if语句

8.1.1 判断表达式

8.1.2 花括号和if结构体

8.2 if...else结构

8.2.1 关键在else

8.2.2 if...else结构体

8.3 多分支语句和分支语句嵌套

8.3.1 多分支

8.3.2 多分支if结构

8.3.3 分支语句嵌套

8.4 switch结构

8.4.1 一般形式

8.4.2 为什么叫开关语句

8.4.3 default语句

8.4.4 if结构和switch结构之比较

8.4.5 switch结构的常见错误与解决方法

8.5 小结

8.6 习题

第9章 一遍又一遍——循环结构

9.1 构造循环

9.1.1 循环的条件

9.1.2 当型循环和直到型循环

9.2 while和do...while循环结构

9.2.1 语法规则

9.2.2 代码块

9.2.3 while语句的常见错误

9.2.4 do...while语句的常见错误

9.3 for循环结构

9.3.1 基本形式

9.3.2 表达式省略

9.3.3 循环终止和步长

9.3.4 for语句的常见错误

9.4 循环嵌套

9.4.1 嵌套示例

9.4.2 嵌套的效率

9.4.3 循环嵌套程序的常见错误

9.5 与循环密切相关的流程转向控制语句

9.5.1 用break跳出循环

9.5.2 用continue重来一次

9.5.3 用goto实现跳转

9.6 小结

9.7 习题

第二篇 一窥C语言门径

第10章 同一类型多个元素的集合——简单数组

10.1 什么是数组

10.1.1 数组是一大片连续内存空间

10.1.2 数组元素的访问

10.2 一维数组

10.2.1 一维数组的声明

10.2.2 一维数组元素的访问

10.2.3 一维数组的初始化

10.2.4 不合法的数组操作

10.3 二维数组

10.3.1 二维数组的声明

10.3.2 二维数组的初始化

10.3.3 二维数组应用举例

10.4 更高维的数组

10.4.1 高维数组的声明和元素访问

10.4.2 初始化

10.4.3 多维数组在内存中是如何排列元素的

10.5 小结

10.6 习题

第11章 写程序就是写函数——函数入门

11.1 什么是函数

11.1.1 函数的由来

11.1.2 C语言中的函数

11.2 自定义函数

11.2.1 函数定义语法

11.2.2 函数定义范例

11.2.3 不要重复定义

11.3 函数调用与返回

11.3.1 形参和实参

11.3.2 传址调用

11.3.3 函数返回

11.4 告诉编译器有这么一个函数

11.4.1 函数声明的语法

11.4.2 声明不同于定义

11.4.3 标准库函数的声明

11.5 函数的调用过程

11.6 小结

11.7 习题

第12章 C语言难点——指针初探

12.1 计算机中的内存

12.1.1 内存地址

12.1.2 内存中保存的内容

12.1.3 地址就是指针

12.2 指针的定义

12.2.1 指针变量的声明

12.2.2 指针变量的初始化

12.2.3 指针变量的值

12.2.4 取地址操作符&

12.2.5 指针变量占据一定的内存空间

12.2.6 指向指针的指针

12.2.7 指针变量常见的错误分析与解决

12.3 使用指针

12.3.1 运算符*

12.3.2 指针的类型和指针所指向的类型

12.3.3 同类型指针的赋值

12.3.4 void指针

12.3.5 指针的类型和指针所指向的类型不同

12.4 指针的运算

12.4.1 算术运算之“指针+整数”或“指针-整数”

12.4.2 指针-指针

12.4.3 指针的大小比较

12.5 指针表达式与左值

12.5.1 指针与整型

12.5.2 指针与左值

12.5.3 指针与const

12.6 动态内存分配

12.6.1 动态分配的好处

12.6.2 malloc与free函数

12.6.3 calloc与free

12.6.4 free函数与指针

12.6.5 内存泄漏

12.6.6 释放已经释放了的内存会出问题

12.7 小结

12.8 习题

第13章 字符串及字符串操作

13.1 C风格字符串

13.1.1 C风格字符串的声明

13.1.2 C风格字符串在内存中的表示

13.2 字符数组的输入输出

13.2.1 字符数组的声明

13.2.2 字符数组可以进行整体输入输出

13.2.3 使用gets()函数读取整行

13.2.4 访问字符数组中某个元素

13.2.5 使用puts()函数实现字符串的输出

13.2.6 使用字符数组的常见问题

13.3 字符串处理函数

13.3.1 理解:数组名是常指针

13.3.2 strlen()函数与size_t

13.3.3 字符串复制函数strcpy()

13.3.4 字符串比较函数strcmp()

13.3.5 字符串连接函数strcat()

13.3.6 全转换为大写形式

13.3.7 链式操作

13.4 小结

13.5 习题

第14章 结构体、共用体、枚举和typedef

14.1 结构体

14.1.1 结构体的定义

14.1.2 声明结构体变量

14.1.3 初始化结构变量

14.1.4 访问结构体成员

14.1.5 结构体定义的位置

14.1.6 结构体变量赋值

14.2 特殊结构体

14.2.1 结构体嵌套

14.2.2 匿名结构体

14.3 共用体

14.3.1 什么是共用体

14.3.2 共用体的定义

14.3.3 声明共用体变量

14.3.4 共用体变量的初始化

14.3.5 共用体成员访问

14.3.6 共用体赋值

14.4 结构体和共用体的内存差异

14.4.1 结构体变量和共用体变量内存形式的不同

14.4.2 结构体变量的内存大小

14.4.3 字节对齐

14.4.4 最宽基本类型

14.4.5 共用体的大小

14.5 枚举类型

14.5.1 什么是枚举类型

14.5.2 枚举类型的定义

14.5.3 声明枚举变量

14.5.4 枚举常量是什么

14.5.5 使用枚举时常见的错误

14.6 给类型取个别名——typedef

14.6.1 typedef基本用法

14.6.2 #define用法

14.7 小结

14.8 习题

第15章 如何节省内存——位运算

15.1 什么是位运算

15.1.1 开灯关灯

15.1.2 改变状态

15.1.3 计算机中的数据存储形式

15.2 位逻辑运算符

15.2.1 位取反操作

15.2.2 位与运算

15.2.3 位或运算

15.2.4 位异或

15.2.5 实例分析

15.3 移位运算

15.3.1 基本形式

15.3.2 移位举例

15.3.3 移位和乘以2

15.4 小结

15.5 习题

第三篇 C语言进阶主题

第16章 存储不仅仅局限于内存——文件

16.1 什么是文件

16.1.1 文件

16.1.2 流

16.1.3 重定向

16.1.4 文件的处理形式——缓冲区和非缓冲区

16.1.5 文件的存储形式——文本形式和二进制形式

16.2 C语言如何使用文件

16.2.1 文件型指针

16.2.2 文件操作的步骤

16.3 文件的打开与关闭

16.3.1 用于打开文件的fopen()函数

16.3.2 打开是否成功

16.3.3 用于关闭文件的fclose()函数

16.4 文件的读写

16.4.1 读写的相对参照

16.4.2 如何判断文件已经结束

16.4.3 字符读写函数fgetc()和fputc()

16.4.4 字符串读写函数fgets()和fputs()

16.4.5 块读写函数fread()和fwrite()

16.4.6 格式化文件输入输出fprintf()与fscanf()

16.5 文件的定位

16.5.1 移动指针到文件开头rewind()

16.5.2 移动指针到当前位置ftell()

16.5.3 移动指针fseek()

16.6 小结

16.7 习题

第17章 灵活却难以理解——指针进阶

17.1 指针与数组

17.1.1 数组名指针

17.1.2 使用数组名常指针表示数组元素

17.1.3 指向数组元素的指针变量

17.1.4 指向数组的指针变量

17.1.5 指针数组

17.1.6 指针与数组的常见问题

17.2 指针、结构体和结构体数组

17.2.1 两种访问形式

17.2.2 声明创建一个结构体数组

17.2.3 结构体数组的初始化

17.2.4 结构体数组的使用

17.2.5 指向结构体数组的指针

17.3 函数指针

17.3.1 函数名指针

17.3.2 指向函数的指针

17.3.3 函数指针类型

17.3.4 函数指针作函数参数

17.3.5 函数指针数组

17.3.6 指向函数指针的指针

17.4 小结

17.5 习题

第18章 更深入的理解——函数进阶

18.1 参数传递的副本机制

18.1.1 传值调用的副本

18.1.2 传址调用的副本机制

18.2 函数返回值的副本机制

18.2.1 return局部变量为什么合法

18.2.2 返回指针申请动态内存

18.2.3 不要返回指向栈内存的指针

18.2.4 返回指向只读存储区的指针

18.3 函数与结构体

18.3.1 结构体变量的传值和传址调用

18.3.2 结构体变量的成员作为函数参数

18.3.3 返回结构体的函数

18.3.4 返回结构体指针的函数

18.4 函数与数组

18.4.1 数组元素作为函数参数

18.4.2 数组名作为函数参数

18.4.3 多维数组名作为函数参数

18.4.4 数组名作函数参数时的退化

18.5 递归

18.5.1 递归流程

18.5.2 递归两要素

18.5.3 效率VS可读性

18.6 带参数的主函数

18.7 小结

18.8 习题

第19章 生存期、作用域与可见域

19.1 内存分配

19.1.1 内存分区

19.1.2 变量的存储类别

19.1.3 生存期

19.1.4 作用域与可见域

19.2 auto变量

19.2.1 定义格式

19.2.2 作用域和生存期

19.2.3 auto变量的屏蔽准则

19.2.4 重复定义

19.2.5 auto变量的初始化和特点

19.3 register变量

19.3.1 定义格式

19.3.2 使用举例

19.4 extern变量

19.4.1 全局变量定义

19.4.2 全局变量声明

19.4.3 可见域

19.4.4 全局变量的屏蔽准则

19.4.5 全局变量的利与弊

19.5 static变量

19.5.1 定义格式

19.5.2 静态局部变量

19.5.3 静态全局变量

19.5.4 静态局部变量和静态全局变量的区别

19.5.5 extern变量和static变量的初始化

19.6 函数的作用域与可见域

19.6.1 内部函数

19.6.2 外部函数

19.7 结构体定义的作用域与可见域

19.7.1 定义位置与可见域

19.7.2 允许重复定义

19.8 常见的有关变量存储的错误

19.9 小结

19.10 习题

第20章 编译及预处理

20.1 编译流程

20.1.1 编辑

20.1.2 预处理

20.1.3 编译

20.1.4 连接

20.2 程序错误

20.2.1 错误分类

20.2.2 编译错误

20.2.3 连接错误

20.2.4 逻辑错误

20.2.5 排错

20.3 预处理命令之宏定义

20.3.1 宏定义

20.3.2 不带参数的宏定义

20.3.3 带参数的宏定义

20.3.4 #define定义常量与const常量

20.3.5 文件包含

20.3.6 条件编译

20.3.7 宏函数

20.4 小结

20.5 习题

第21章 数据结构

21.1 链表

21.1.1 链表的结构

21.1.2 创建链表并遍历输出

21.1.3 链表的插入

21.1.4 链表结点的删除

21.1.5 链表的逆置

21.1.6 链表的销毁

21.1.7 链表的综合实例

21.1.8 循环链表

21.1.9 双链表

21.2 栈和队列

21.2.1 栈的定义

21.2.2 栈的分类

21.2.3 栈的操作

21.2.4 函数与栈

21.2.5 队列

21.3 自定义类型

21.4 小结

21.5 习题

第四篇 C语言程序设计实例与面试题解析

第22章 面试题解析

22.1 基础知识

22.1.1 指针自增自减有什么不同

22.1.2 什么是递归

22.1.3 宏定义与操作符的区别

22.1.4 引用与值传递的区别

22.1.5 指针和引用有什么区别

22.1.6 什么是栈

22.1.7 main函数执行前还会执行什么代码

22.1.8 static有什么用途

22.1.9 定义int **a[3][4],则变量占用的内存空间为多少

22.1.10 什么是预编译

22.1.11 int(*s[10])(int)表示什么意义

22.1.12 结构体与共同体有何区别

22.2 算法和思维逻辑知识

22.2.1 100美元哪里去了

22.2.2 将16升水平均分给四个人

22.2.3 算出小王买了几瓶啤酒、几瓶饮料

22.2.4 找出不同的苹果

22.2.5 找出不同的球

22.2.6 猜自己的帽子颜色

22.2.7 3筐水果各是什么

22.2.8 最后剩下的是谁

22.2.9 聪明的商人

22.2.10 红球和白球

22.2.11 乌龟赛跑

22.2.12 投硬币

附录 ASCII编码表

零基础学Java(第5版)

目录

前言

第一篇 Java语言语法基础——面向过程知识

第1章 Java技术概览

1.1 Java技术

1.1.1 认识Java语言

1.1.2 认识Java平台

1.1.3 Java语言的功能

1.1.4 Java语言的优点

1.1.5 Java分布式应用和多线程的特点

1.1.6 Java程序的可靠性、安全性

1.2 Windows下的“HelloWorld”应用程序

1.2.1 创建应用程序的软件环境

1.2.2 创建“HelloWorld”应用程序的步骤

1.3 深入探讨“HelloWorld”应用程序

1.3.1 注释源代码

1.3.2 实现类定义

1.3.3 详解main()方法

1.4 常见疑难解答

1.4.1 环境变量设置错误

1.4.2 语法错误

1.4.3 语义错误

1.4.4 运行时错误

1.4.5 初学者如何选择Java参考书

1.5 小结

1.6 习题

第2章 Java开发工具及环境设置

2.1 Java开发工具简介

2.1.1 下载并安装JDK

2.1.2 设定环境变量

2.1.3 验证JDK环境是否配置成功

2.2 JDK内置工具

2.2.1 JDK常用工具

2.2.2 JDK常用工具的使用实例

2.2.3 Java应用程序的发布工具

2.3 一个简单的Java应用程序

2.4 Java程序员的编码规则

2.5 常见疑难解答

2.5.1 Java文件扩展名是否区分大小写

2.5.2 Javac xxx.java顺利通过,但Java xxx显示“NoClassDefFoundError”

2.5.3 导致错误“Exception in thread main java.lang.NoSuchMethodError:main”的原因

2.6 小结

2.7 习题

第3章 Java语言中的数据类型与运算符

3.1 数制

3.1.1 基本概念

3.1.2 Java语言中的数制表现形式

3.2 数据类型

3.2.1 整型

3.2.2 字符型

3.2.3 浮点型

3.2.4 布尔型

3.3 变量

3.3.1 变量的声明

3.3.2 变量的含义

3.3.3 变量的分类

3.4 变量如何初始化

3.5 常量

3.6 运算符

3.6.1 算术运算符

3.6.2 关系运算符

3.6.3 逻辑运算符

3.6.4 位运算符

3.6.5 移位运算符

3.6.6 赋值运算符

3.6.7 三元运算符

3.6.8 逗号运算符

3.6.9 转型运算符

3.6.10 运算符的优先级别

3.7 常见疑难解答

3.7.1 如何将十进制转换成二进制

3.7.2 转型运算符会引起精度问题,为什么还要使用它

3.8 小结

3.9 习题

第4章 程序设计中的流程控制

4.1 编程风格

4.2 条件语句

4.2.1 简单条件语句

4.2.2 最简单的条件语句

4.2.3 适应多条件的条件语句

4.2.4 嵌套条件语句

4.2.5 如何使用条件语句

4.3 循环语句

4.3.1 for循环语句

4.3.2 while循环

4.3.3 do…while语句

4.4 中断与继续语句

4.4.1 中断控制语句

4.4.2 继续语句

4.5 分支语句

4.6 返回语句

4.7 常见疑难解答

4.7.1 普通循环是使用for语句还是while语句

4.7.2 一般的程序可否用分支语句来代替条件语句

4.8 小结

4.9 习题

第二篇 Java语言语法进阶——面向对象知识

第5章 数组

5.1 数组概念的引入

5.1.1 实例的引入

5.1.2 数组的概念

5.1.3 用实例说明数组的用处

5.2 基本数据类型的数组

5.2.1 基本类型数组的声明

5.2.2 基本类型数组的初始化

5.3 由实例引出不同数组种类及其使用

5.3.1 认识一维数组

5.3.2 由实例引出一维数组及其使用

5.3.3 由实例引出二维数组及其使用

5.4 多维数组

5.4.1 多维数组的声明

5.4.2 初始化多维数组

5.4.3 使用多维数组

5.5 数组的综合实例

5.6 常见疑难解答

5.6.1 声明数组需要注意什么

5.6.2 数组在平时的程序代码中使用是否频繁

5.7 小结

5.8 习题

第6章 字符串的处理

6.1 认识字符串

6.1.1 代码中的字符串

6.1.2 String类和StringBuffer类的比较

6.2 字符串处理的类库种类

6.2.1 字符串的赋值

6.2.2 字符串处理类——String

6.2.3 字符串处理的方法

6.2.4 缓冲字符串处理类——StringBuffer

6.2.5 缓冲字符串StringBuffer类的构造器

6.2.6 缓冲字符串的处理

6.2.7 缓冲字符串类的特点

6.3 用实例演示如何处理字符串

6.4 如何格式化输出字符串

6.5 常见疑难解答

6.5.1 equals和“==”的区别

6.5.2 String类为何被定义成final约束

6.5.3 char类型如何转换成int类型,int类型如何转换成字符串

6.6 小结

6.7 习题

第7章 类和对象

7.1 面向对象开发中的类

7.1.1 在Java中类的定义

7.1.2 Java中的类与现实世界的类

7.2 万事万物皆对象

7.2.1 什么是对象

7.2.2 操作对象

7.2.3 初始化对象

7.2.4 对象的成员方法

7.2.5 对象的成员变量

7.3 对象中访问控制符的重要性

7.3.1 什么是访问控制符

7.3.2 如何使用访问控制符及其重要性

7.4 Java中的基础类

7.4.1 Java的数学运算处理类Math

7.4.2 测试时间和日期的类Date

7.4.3 测试日历的类GregorianCalendar

7.4.4 日历处理的实例解析

7.5 用实例分析设计一个类的流程

7.5.1 如何在现实程序设计中提取一个类

7.5.2 设置器和访问器

7.5.3 总结

7.6 常见疑难解答

7.6.1 类在程序语言中起到了什么作用

7.6.2 设置器和访问器的作用

7.7 小结

7.8 习题

第8章 重载和包

8.1 重载

8.1.1 什么是重载

8.1.2 用实例来说明重载的意义

8.2 包

8.2.1 什么是Java中的包

8.2.2 如何实现包

8.2.3 什么是类路径和默认包

8.2.4 包的作用域

8.2.5 静态导入

8.3 包的注释及嵌入文档

8.3.1 如何添加注释

8.3.2 类、方法、字段等注释的方法

8.4 常见疑难解答

8.4.1 包在实际编程中究竟有什么作用

8.4.2 一个文件中定义了两个class类是否生成一个.class文件

8.5 小结

8.6 习题

第9章 继承和多态

9.1 什么是继承

9.1.1 继承的引出

9.1.2 继承的概念

9.1.3 如何实现继承

9.1.4 如何设计继承

9.2 构造函数的使用

9.2.1 什么是构造函数

9.2.2 继承中构造函数的初始化

9.2.3 替代父类和本身的方式

9.2.4 Java中的单继承性

9.3 继承中的覆盖现象

9.4 类之间的关系

9.4.1 依赖

9.4.2 聚合

9.4.3 继承

9.5 继承层次图

9.6 多态

9.6.1 多态的产生

9.6.2 多态的概念

9.6.3 使用多态编写程序

9.6.4 覆盖的应用

9.6.5 重载与覆盖的实例对比

9.6.6 覆盖的多态性

9.6.7 传值引用和传址引用

9.7 通过实例熟悉多态用法

9.8 绑定

9.8.1 静态绑定

9.8.2 动态绑定

9.9 超类

9.9.1 什么是超类

9.9.2 equals方法的使用

9.9.3 通用编程

9.10 常见疑难解答

9.10.1 Java不支持多继承,如何处理一个类继承多个父类的情况

9.10.2 如果出现了带参数的构造函数,可否不在代码中写出来

9.10.3 动态和静态编译是什么

9.10.4 绑定与多态的联系是什么

9.10.5 多态与重载的区别是什么

9.11 小结

9.12 习题

第10章 接口与内部类

10.1 接口

10.1.1 接口概念的引入

10.1.2 接口的声明

10.1.3 接口的实现

10.1.4 接口的多重实现

10.1.5 接口的属性

10.1.6 接口的继承

10.2 内部类

10.2.1 使用内部类来访问对象

10.2.2 局部内部类

10.2.3 静态内部类

10.2.4 匿名内部类

10.3 常见疑难解答

10.3.1 匿名类如何在程序中使用

10.3.2 接口与继承有什么区别

10.4 小结

10.5 习题

第11章 抽象和封装

11.1 抽象的概念

11.1.1 什么是抽象

11.1.2 抽象的综合实例

11.2 抽象类

11.2.1 什么是抽象类

11.2.2 抽象类的实例

11.3 抽象与接口的区别

11.4 枚举

11.4.1 关于枚举的实现原理

11.4.2 枚举的简单应用

11.4.3 关于枚举的高级特性

11.5 反射

11.5.1 关于反射的基石——Class类

11.5.2 关于反射的基本应用

11.5.3 关于反射的高级应用

11.6 标注

11.6.1 标注的简单使用

11.6.2 关于JDK的内置标注

11.7 泛型

11.7.1 为什么要使用泛型

11.7.2 关于泛型的一些特性

11.7.3 关于泛型的通配符

11.8 类加载器

11.8.1 什么是类加载器

11.8.2 什么是类加载器的委派模型

11.9 动态代理

11.9.1 什么是代理

11.9.2 关于动态代理基础类

11.9.3 关于InvocationHandler接口

11.9.4 动态代理类的设计模式

11.10 封装的概念

11.10.1 一个封装的例子

11.10.2 在程序设计中为什么要使用封装

11.10.3 在程序设计中设计封装的注意点

11.11 结合实例讲述如何设计封装

11.12 常见疑难解答

11.12.1 抽象类和接口在概念上有什么区别

11.12.2 如何从设计理念上看待抽象类和接口

11.12.3 封装在现实开发中给程序员带来什么启发

11.12.4 封装在实际开发中的应用有哪些

11.13 小结

11.14 习题

第三篇 Java语言编程主题

第12章 线程

12.1 线程的基本概念

12.1.1 进程及其使用环境

12.1.2 线程及其使用环境

12.2 线程的创建

12.2.1 如何创建线程

12.2.2 通过实例熟悉如何创建线程

12.2.3 线程的状态

12.3 线程的使用

12.3.1 线程的优先级

12.3.2 线程的休眠与唤醒

12.3.3 线程让步

12.3.4 线程同步

12.3.5 同步块

12.3.6 同步化方法

12.4 实例分析

12.4.1 生产者与消费者的程序设计及分析

12.4.2 多消费者的程序设计及分析

12.4.3 多生产者的程序设计及分析

12.5 常见疑难解答

12.5.1 Java中线程与线程之间怎么通信

12.5.2 什么是进程的死锁和饥饿

12.5.3 什么时候会涉及线程程序

12.5.4 多线程的死锁问题

12.5.5 多线程的缺点

12.6 小结

12.7 习题

第13章 异常的处理与内存的管理

13.1 异常的概念

13.1.1 异常的分类

13.1.2 异常的声明

13.1.3 异常的抛出throw

13.2 异常的捕获

13.2.1 捕获多个异常

13.2.2 自定义异常

13.2.3 运行期异常

13.2.4 执行finally子句

13.2.5 finally子句的必要性

13.3 内存的管理和回收

13.4 常见疑难解答

13.4.1 为什么要声明方法抛出异常

13.4.2 为什么抛出的异常一定是检查异常

13.5 小结

13.6 习题

第14章 Java输入与输出

14.1 输入与输出的重要性

14.2 Java重要的输入输出类

14.3 文件或目录信息的处理

14.3.1 File类常用的操作方法

14.3.2 文件处理方法的应用

14.3.3 文件和目录的操作

14.4 读取数据的媒介之一——流

14.4.1 什么是流

14.4.2 什么是输入流和输出流

14.4.3 字节输入流及输出流

14.4.4 使用文件字节输入流读取文件

14.4.5 使用文件字节输出流输出文件

14.5 多字节数据读取类——Filter类

14.5.1 Filter流的概念

14.5.2 处理字节类型以外的文件输入

14.5.3 处理字节类型以外的文件输出

14.5.4 增强的多字节输出流DataOutput

14.5.5 增强的多字节输入流DataInput

14.6 读取数据的媒介之二——字符流

14.6.1 字符流的概念

14.6.2 抽象字符输入流Reader类的使用

14.6.3 抽象字符输出流Writer类的使用

14.6.4 读取带缓存的BufferedReader字符流

14.6.5 带缓存的字符输出流BufferedWriter类

14.6.6 字符输入流FileReader类和FileWriter类的使用

14.6.7 如何用标准输入流System.in来获取数据

14.6.8 打印输入流PrintWriter类与PrintStream类的区别

14.6.9 随机文件访问RandomAccessFile类

14.7 利用对象序列化控制输入输出

14.7.1 什么是对象序列化

14.7.2 基本数据和对象数据读写ObjectInput接口与ObjectOutput接口

14.7.3 对象序列化处理ObjectOutputStream类

14.7.4 对象序列化处理ObjectInputStream类

14.8 常见疑难解答

14.8.1 字节流与字符流的主要区别

14.8.2 输入流与输出流如何区分,各有什么作用

14.8.3 什么是管道流

14.9 小结

14.10 习题

第15章 Java中对数据的处理

15.1 如何将基本数据类型转换为对象

15.1.1 为什么要将基本数据转换为对象

15.1.2 Wrapper类的构造函数

15.1.3 包装类的常用函数

15.1.4 基本数据的拆装箱操作

15.2 如何处理随机性的数据

15.2.1 Random类的基础知识

15.2.2 通过实例熟悉Random类的常用方法

15.3 如何对数据进行排列、整理

15.3.1 Arrays类的常用方法

15.3.2 实例分析

15.4 常见疑难解答

15.4.1 Random类函数在现实生活中有什么用处

15.4.2 数组的排列和整理数据在实际应用中有什么用处

15.5 小结

15.6 习题

第16章 数据结构接口

16.1 数据结构接口及实现

16.1.1 数据结构接口的实质

16.1.2 用实例来熟悉数据结构接口的实现

16.2 Collection集合接口与Iterator迭代器接口

16.2.1 熟悉Collection集合接口

16.2.2 List接口和Set接口

16.2.3 Map映射接口

16.2.4 Iterator迭代器接口

16.2.5 通过实例来认识迭代器的实现

16.3 常见疑难解答

16.3.1 Collection集合接口和Collections集合类的区别

16.3.2 ArrayList数组列表类和Vector存储类的区别

16.3.3 HashMap散列映射和Hashtable散列表的区别

16.3.4 数据结构的种类有哪些

16.3.5 List接口和Set接口的区别

16.4 小结

16.5 习题

第17章 Java中的数据结构

17.1 链表

17.1.1 什么是Java中的链表

17.1.2 用程序代码段实现对链表的添加

17.1.3 用程序代码段实现对链表的删除

17.2 数组列表类

17.2.1 什么是数组列表类

17.2.2 通过实例熟悉数组列表如何存储数据

17.3 散列表

17.3.1 什么是散列表

17.3.2 通过实例熟悉散列表如何存储数据

17.4 散列集

17.4.1 什么是散列集

17.4.2 通过实例熟悉散列集如何存储数据

17.5 树集

17.5.1 什么是树集

17.5.2 通过实例熟悉树集如何存储数据

17.6 映像

17.6.1 什么是映像

17.6.2 通过实例熟悉映像如何存储数据

17.7 常见疑难解答

17.7.1 哪些是线程安全的数据结构

17.7.2 Vector是什么样的数据结构

17.8 小结

17.9 习题

第18章 XML基础

18.1 XML和HTML

18.1.1 XML的产生

18.1.2 XML与HTML的比较

18.2 XML的编辑工具

18.3 创建XML文档

18.3.1 XML的声明

18.3.2 文档类型的声明

18.3.3 元素

18.3.4 注释

18.3.5 处理指令

18.3.6 空白处理

18.3.7 行尾处理

18.3.8 语言标识

18.3.9 一个简单的有关XML的实例

18.4 关于XML的高级知识

18.4.1 什么才是格式良好的XML文档

18.4.2 DTD文档的作用

18.4.3 DTD的结构

18.4.4 几个有关DTD的简单实例

18.5 关于XML文档的操作

18.5.1 下载Dom4J组件

18.5.2 配置Dom4J组件

18.5.3 Dom4J组件的简单使用——解析XML文件

18.5.4 Dom4J组件的简单使用——创建XML文件

18.6 关于XML文档的高级操作

18.6.1 下载Sax类库

18.6.2 配置Sax组件

18.6.3 Sax组件的简单使用——解析XML文件

18.7 常见疑难解答

18.7.1 XML与HTML的区别

18.7.2 XML有哪些显示数据的方式

18.8 小结

18.9 习题

第19章 开发工具的使用

19.1 Eclipse简介

19.1.1 下载并安装Eclipse

19.1.2 Eclipse界面介绍

19.2 如何使用Eclipse进行开发

19.2.1 如何新建一个Java工程

19.2.2 如何新建一个Java类

19.2.3 编写代码

19.3 如何使用MyEclipse进行开发

19.3.1 下载并安装MyEclipse

19.3.2 关于MyEclipse的一些常用操作

19.4 常见疑难解答

19.4.1 Eclipse和UltraEdit两个开发工具的优缺点

19.4.2 什么是IDE环境

19.4.3 有关Eclipse的编译报错的原因

19.5 小结

19.6 习题

第20章 Swing组件与布局管理器

20.1 什么是Swing编程

20.2 MVC设计模式基础

20.3 简单框架设计及实例

20.3.1 创建一个空白的框架

20.3.2 创建框架的其他工作

20.4 简单图形按钮控件的设计及实例

20.4.1 Swing中的按钮控件

20.4.2 按钮的模型

20.4.3 添加普通按钮

20.4.4 添加单选按钮

20.4.5 添加复选框

20.4.6 ToggleButton按钮

20.5 简单文本输入组件的设计及实例

20.5.1 文本域

20.5.2 密码域

20.5.3 文本区域

20.6 展示类组件的设计及实例

20.6.1 标签组件

20.6.2 选择组件

20.6.3 菜单组件

20.6.4 对话框的种类及用法

20.7 复杂布局管理器的种类及用法

20.7.1 箱式布局的设计

20.7.2 网格组布局的设计

20.7.3 流布局的设计

20.7.4 边界布局的设计

20.8 通过实例熟悉Swing编程

20.9 常见疑难解答

20.9.1 如何处理菜单的启用和禁用功能

20.9.2 如何编写快捷键的程序

20.10 小结

20.11 习题

第21章 JDBC及其应用

21.1 数据库基础知识

21.1.1 什么是数据库

21.1.2 数据库的分类及功能

21.1.3 关系数据库的设计

21.1.4 数据库设计技巧

21.2 JDBC的基础概念

21.2.1 JDBC驱动程序的分类

21.2.2 利用Java到数据库协议方式连接Oracle数据库

21.2.3 利用Java到本地API方式连接Oracle数据库

21.3 关于SQL Server数据库基础操作

21.3.1 什么是支持SQL语言的数据库

21.3.2 通过SQL语言如何操作数据库

21.3.3 安装SQL Server

21.3.4 高级SQL类型

21.3.5 使用SQL创建数据库

21.4 关于JDBC的高级操作

21.4.1 什么是事务处理

21.4.2 事务处理的过程演练

21.4.3 预查询

21.4.4 使用JDBC的注意事项

21.5 常见疑难解答

21.5.1 操作数据库的具体步骤是什么

21.5.2 数据库中的视图、图表、缺省值、规则、触发器、存储过程的意义

21.6 小结

21.7 习题

第22章 网络编程基础

22.1 网络基础知识

22.2 TCP/IP协议和UDP协议

22.2.1 IP协议和IP地址

22.2.2 TCP协议和端口

22.2.3 客户端/服务器通信模型

22.2.4 UDP协议

22.3 端口与套接字

22.4 TCP程序设计基础

22.4.1 如何设计TCP程序

22.4.2 一个简单的例子

22.5 UDP程序设计基础

22.5.1 如何设计UDP程序

22.5.2 一个简单的例子

22.6 如何设计网络程序

22.6.1 单向通信综合实例

22.6.2 双向通信综合实例

22.7 常见疑难解答

22.7.1 TCP和UDP的区别

22.7.2 什么是TCP/IP协议,分为几层,什么功能

22.8 小结

22.9 习题

第四篇 Java语言程序设计实例与面试题剖析

第23章 学校管理系统

23.1 开发背景

23.2 需求分析

23.3 登录界面的设计

23.3.1 登录界面的分析

23.3.2 登录界面的代码实现

23.3.3 登录界面的运行

23.4 主菜单界面的设计

23.4.1 主菜单界面的分析

23.4.2 主菜单界面的代码实现

23.4.3 主菜单界面的运行

23.5 数据库系统的设计

23.5.1 数据库中表的创建

23.5.2 数据库中的代码段

23.6 学生信息系统界面的设计

23.6.1 学生类的设计

23.6.2 存储类的设计

23.6.3 学生信息系统界面的代码实现

23.7 教师信息系统界面的设计

23.7.1 教师类的设计

23.7.2 存储类的设计

23.7.3 教师信息系统界面的代码实现

23.8 领导信息系统界面的设计

23.8.1 领导类的设计

23.8.2 存储类的设计

23.8.3 领导信息系统界面的代码实现

23.9 小结

第24章 面试题

面试题1 Java的引用和C++的指针有什么区别

面试题2 类和对象有什么区别

面试题3 说明private、protected、public和default的区别

面试题4 Java可以用非0来代表true吗

面试题5 StringBuffer和StringBuilder存在的作用是什么

面试题6 二维数组的长度是否固定

面试题7 符合什么条件的数据集合可以使用foreach循环

面试题8 如何序列化和反序列化一个Java对象

面试题9 如何使用Java的线程池

面试题10 如何利用反射实例化一个类

面试题11 TCP协议的通信特点是什么

面试题12 请简述JDBC操作数据库的编程步骤

面试题13 如何使用连接池技术

面试题14 简述接口和抽象类的区别

面试题15 如何理解Java中的装箱和拆箱

面试题16 根据代码判断创建的对象个数

面试题17 分析循环程序的运行结果

面试题18 可以返回最大值的方法

面试题19 关于垃圾回收的疑问

面试题20 线程问题:找出代码中的错误

面试题21 关于ArrayList、Vector、LinkedList的问答题

面试题22 Java中的异常处理机制的简单原理和应用

面试题23 列举一些常用的类、包、接口,请各列举5个

面试题24 Java中,DOM和SAX解析器有什么不同

面试题25 线程的sleep()方法和yield()方法有什么区别

零基础学Python(第2版)

目录

前言

第一篇 Python语言基础

第1章 进入Python的世界

1.1 Python的由来

1.2 Python的特性

1.3 第一个Python程序

1.4 搭建开发环境

1.4.1 Python的下载和安装

1.4.2 交互式命令行的使用

1.5 Python的开发工具

1.5.1 PyCharm的使用

1.5.2 Eclipse IDE的介绍

1.5.3 EditPlus编辑器环境的配置

1.6 不同平台下的Python

1.7 小结

1.8 习题

第2章 必须知道的Python基础语法

2.1 Python的文件类型

2.1.1 源代码

2.1.2 字节代码

2.1.3 优化代码

2.2 Python的编码规范

2.2.1 命名规则

2.2.2 代码缩进与冒号

2.2.3 模块导入的规范

2.2.4 使用空行分隔代码

2.2.5 正确的注释

2.2.6 语句的分隔

2.3 变量和常量

2.3.1 变量的命名

2.3.2 变量的赋值

2.3.3 局部变量

2.3.4 全局变量

2.3.5 常量

2.4 数据类型

2.4.1 数字

2.4.2 字符串

2.5 运算符与表达式

2.5.1 算术运算符和算术表达式

2.5.2 关系运算符和关系表达式

2.5.3 逻辑运算符和逻辑表达式

2.6 小结

2.7 习题

第3章 Python的控制语句

3.1 结构化程序设计

3.2 条件判断语句

3.2.1 if条件语句

3.2.2 if…elif…else判断语句

3.2.3 if语句也可以嵌套

3.2.4 switch语句的替代方案

3.3 循环语句

3.3.1 while循环

3.3.2 for循环

3.3.3 break和continue语句

3.4 结构化程序示例

3.5 小结

3.6 习题

第4章 Python数据结构

4.1 元组结构

4.1.1 元组的创建

4.1.2 元组的访问

4.1.3 元组的遍历

4.2 列表结构

4.2.1 列表的创建

4.2.2 列表的使用

4.2.3 列表的查找、排序、反转

4.2.4 列表实现堆栈和队列

4.3 字典结构

4.3.1 字典的创建

4.3.2 字典的访问

4.3.3 字典的方法

4.3.4 字典的排序、复制

4.3.5 全局字典——sys.modules模块

4.4 序列

4.5 小结

4.6 习题

第5章 模块与函数

5.1 Python程序的结构

5.2 模块

5.2.1 模块的创建

5.2.2 模块的导入

5.2.3 模块的属性

5.2.4 模块的内置函数

5.2.5 自定义包

5.3 函数

5.3.1 函数的定义

5.3.2 函数的参数

5.3.3 函数的返回值

5.3.4 函数的嵌套

5.3.5 递归函数

5.3.6 lambda函数

5.3.7 Generator函数

5.4 小结

5.5 习题

第6章 字符串与正则表达式

6.1 常见的字符串操作

6.1.1 字符串的格式化

6.1.2 字符串的转义符

6.1.3 字符串的合并

6.1.4 字符串的截取

6.1.5 字符串的比较

6.1.6 字符串的反转

6.1.7 字符串的查找和替换

6.1.8 字符串与日期的转换

6.2 正则表达式应用

6.2.1 正则表达式简介

6.2.2 使用re模块处理正则表达式

6.3 小结

6.4 习题

第7章 使用Python处理文件

7.1 文件的常见操作

7.1.1 文件的创建

7.1.2 文件的读取

7.1.3 文件的写入

7.1.4 文件的删除

7.1.5 文件的复制

7.1.6 文件的重命名

7.1.7 文件内容的搜索和替换

7.1.8 文件的比较

7.1.9 配置文件的访问

7.2 目录的常见操作

7.2.1 创建和删除目录

7.2.2 目录的遍历

7.3 文件处理示例——文件属性浏览程序

7.4 小结

7.5 习题

第8章 面向对象编程

8.1 面向对象的概述

8.2 类和对象

8.2.1 类和对象的区别

8.2.2 类的定义

8.2.3 对象的创建

8.3 属性和方法

8.3.1 类的属性

8.3.2 类的方法

8.3.3 内部类的使用

8.3.4 __init__方法

8.3.5 __del__方法

8.3.6 垃圾回收机制

8.3.7 类的内置方法

8.3.8 方法的动态特性

8.4 继承

8.4.1 使用继承

8.4.2 抽象基类

8.4.3 多态性

8.4.4 多重继承

8.4.5 Mixin机制

8.5 运算符的重载

8.6 Python与设计模式

8.6.1 设计模式简介

8.6.2 设计模式示例——Python实现工厂方法

8.7 小结

8.8 习题

第9章 异常处理与程序调试

9.1 异常的处理

9.1.1 Python中的异常

9.1.2 try…except的使用

9.1.3 try…finally的使用

9.1.4 使用raise抛出异常

9.1.5 自定义异常

9.1.6 assert语句的使用

9.1.7 异常信息

9.2 使用自带IDLE调试程序

9.3 使用Eclipse IDE调试程序

9.3.1 新建工程

9.3.2 配置调试

9.3.3 设置断点

9.4 小结

9.5 习题

第10章 Python数据库编程

10.1 数据库简介

10.2 Python DATABASE API简介

10.3 Python连接数据库的专用模块

10.3.1 数据库专用模块的下载与安装

10.3.2 Python连接Oracle数据库

10.3.3 Python连接MySQL数据库

10.3.4 Python连接SQL Server数据库

10.3.5 Python连接SQLite数据库

10.4 使用Python的持久化模块读写数据

10.5 小结

10.6 习题

第二篇 Python的GUI程序设计

第11章 Python的GUI开发

11.1 Python的GUI开发选择

11.1.1 认识Python内置的GUI库Tkinter

11.1.2 使用Tkinter进行开发

11.1.3 认识PyQT GUI库

11.1.4 使用PyQT GUI库进行开发

11.2 小结

11.3 习题

第12章 GUI编程与Tkinter相关组件介绍

12.1 GUI程序开发简介

12.2 Tkinter及其主要组件

12.2.1 在程序中使用Tkinter

12.2.2 顶层窗口

12.2.3 标签

12.2.4 框架

12.2.5 按钮

12.2.6 输入框

12.2.7 单选按钮

12.2.8 复选按钮

12.2.9 消息

12.2.10 滚动条

12.2.11 列表框

12.3 Tkinter所有组件简介

12.4 小结

12.5 习题

第三篇 Python的Web开发

第13章 Python的HTML应用

13.1 HTML介绍

13.1.1 HTML的历史

13.1.2 SGML、HTML、XHTML、HTML5的关系

13.1.3 HTML的标签

13.1.4 HTML的框架组成

13.2 URL的处理

13.2.1 统一资源定位符

13.2.2 URL的解析

13.2.3 URL的拼合

13.2.4 URL的分解

13.2.5 URL的编解码

13.2.6 中文的编解码

13.2.7 查询参数的编码

13.3 CGI的使用

13.3.1 CGI介绍

13.3.2 获取CGI环境信息

13.3.3 解析用户的输入

13.4 获取HTML资源

13.4.1 使用urlopen和urlretrieve获取HTTP资源

13.4.2 分析返回资源的相关信息

13.4.3 使用http.client模块获取资源

13.5 HTML文档的解析

13.6 小结

13.7 习题

第14章 Python和XML

14.1 XML介绍

14.1.1 XML的演进历史

14.1.2 XML的优点和限制

14.1.3 XML技术的Python支持

14.2 XML文档概览和验证

14.2.1 XML文档的基础概念

14.2.2 XML文档的结构良好性验证

14.2.3 XML文档的有效性验证

14.3 分析XML文档结构

14.3.1 XML的元素和标签

14.3.2 元素的属性

14.3.3 XML的名字

14.3.4 字符实体

14.3.5 CDATA段

14.3.6 注释

14.3.7 处理指令

14.3.8 XML定义

14.4 使用SAX处理XML文档

14.4.1 SAX介绍

14.4.2 SAX处理的组成部分

14.5 使用DOM处理XML文档

14.5.1 DOM介绍

14.5.2 xml.dom模块中的接口操作

14.5.3 对XML文档的操作

14.6 小结

14.7 习题

第15章 Python的Web开发——Django框架的应用

15.1 常见的Web开发框架

15.2 MVC模式

15.2.1 MVC模式介绍

15.2.2 MVC模式的优缺点

15.2.3 Django框架中的MVT

15.3 Django开发环境的搭建

15.3.1 Django框架的安装

15.3.2 数据库的配置

15.4 Django框架的基本应用

15.4.1 Web应用的创建

15.4.2 Django中的开发服务器

15.4.3 创建数据库

15.4.4 生成Django应用

15.4.5 创建数据模型

15.4.6 URL设计

15.4.7 创建视图

15.4.8 模板系统

15.5 Django框架的高级应用

15.5.1 管理界面

15.5.2 生成数据库数据

15.5.3 Session功能

15.6 小结

15.7 习题

第四篇 Python的其他应用

16.1 测试驱动开发

16.1.1 测试驱动开发模式

16.1.2 TDD的优势

16.1.3 TDD的使用步骤

16.2 unittest框架

16.2.1 unittest模块介绍

16.2.2 构建测试用例

16.2.3 构建测试固件

16.2.4 组织多个测试用例

16.2.5 构建测试套件

16.2.6 重构代码

16.2.7 执行测试

16.3 使用doctest进行测试

16.3.1 doctest模块介绍

16.3.2 构建可执行文档

16.3.3 执行doctest测试

16.4 小结

16.5 习题

第17章 Python中的进程和线程

17.1 进程和线程

17.1.1 进程和线程的概念

17.1.2 Python中对于进程和线程处理的支持

17.2 Python下的进程编程

17.2.1 进程运行环境

17.2.2 创建进程

17.2.3 终止进程

17.3 使用subprocess模块管理进程

17.3.1 使用Popen类管理进程

17.3.2 调用外部系统命令

17.3.3 替代其他进程创建函数

17.4 进程间的信号机制

17.4.1 信号的处理

17.4.2 信号使用的规则

17.5 多线程概述

17.5.1 什么是多线程

17.5.2 线程的状态

17.5.3 Python中的线程支持

17.6 生成和终止线程

17.6.1 使用_thread模块

17.6.2 使用threading.Thread类

17.7 管理线程

17.7.1 线程状态转移

17.7.2 主线程对子线程的控制

17.7.3 线程中的局部变量

17.8 线程之间的同步

17.8.1 临界资源和临界区

17.8.2 锁机制

17.8.3 条件变量

17.8.4 信号量

17.8.5 同步队列

17.8.6 线程同步小结

17.9 小结

17.10 习题

第18章 基于Python的系统管理

18.1 增强的交互式环境IPython

18.1.1 IPython介绍

18.1.2 IPython的安装

18.1.3 IPython的启动

18.1.4 IPython的环境配置

18.2 和IPython的简单交互

18.2.1 IPython中的输入和输出

18.2.2 输出提示符的区别

18.2.3 输出提示符有区别的原因

18.3 IPython中的magic函数

18.3.1 magic函数的使用和构造

18.3.2 目录管理

18.3.3 对象信息的收集

18.3.4 magic函数小结

18.4 IPython适合于系统管理的特点

18.4.1 Tab补全

18.4.2 历史记录功能

18.4.3 执行外部系统命令和运行文件

18.4.4 对象查看和自省

18.4.5 直接编辑代码

18.4.6 设置别名和宏

18.5 使用Python进行文件管理

18.5.1 文件的比较

18.5.2 文件的归档

18.5.3 文件的压缩

18.6 使用Python定时执行任务

18.6.1 使用休眠功能

18.6.2 使用sched模块来定时执行任务

18.7 小结

18.8 习题

第19章 Python和网络编程

19.1 网络模型介绍

19.1.1 OSI简介

19.1.2 TCP/IP简介

19.2 Socket应用

19.2.1 Socket基础

19.2.2 Socket的工作方式

19.3 服务器端和客户端通信

19.3.1 服务器端的构建

19.3.2 客户端的构建

19.4 异步通信方式

19.4.1 使用Fork方式

19.4.2 使用线程方式

19.4.3 使用异步IO方式

19.4.4 使用asyncore模块

19.5 Twisted网络框架

19.5.1 Twisted框架介绍

19.5.2 Twisted框架下服务器端的实现

19.5.3 Twisted框架下服务器端的其他处理

19.6 小结

19.7 习题

第20章 常见的Python网络应用

20.1 使用FTP传输文件

20.1.1 FTP的工作原理和Python库支持

20.1.2 FTP的登录和退出

20.1.3 FTP的数据传输

20.2 使用POP3获取邮件

20.2.1 POP3协议介绍

20.2.2 poplib模块的使用

20.3 使用SMTP发送邮件

20.3.1 SMTP协议介绍

20.3.2 smtplib模块的使用

20.4 使用Telnet远程登录

20.4.1 Telnet协议介绍和Python库支持

20.4.2 telnetlib模块的使用

20.5 小结

20.6 习题

第21章 图像处理

21.1 图像处理相关概念

21.1.1 Python下的图像处理包

21.1.2 Pillow支持的图像文件格式

21.1.3 图像处理中的其他概念

21.2 基本的图像处理

21.2.1 图像的读写操作

21.2.2 获取图像信息

21.2.3 图像文件格式的转换

21.2.4 图像的裁剪和合成

21.2.5 图像的变换

21.3 图像处理的高级应用

21.3.1 图像的通道操作

21.3.2 对图像的增强

21.3.3 Pillow中的内置滤镜

21.4 小结

21.5 习题

第22章 Windows下的Python开发

22.1 组件对象模型

22.1.1 组件对象模型介绍

22.1.2 COM结构

22.1.3 COM对象的交互

22.2 Python对COM技术的支持

22.2.1 Python中的Windows扩展:PyWin32

22.2.2 客户端COM组件

22.2.3 实现COM组件

22.3 Windows下的常见Python应用

22.3.1 对Word的自动访问

22.3.2 对Excel的自动访问

22.3.3 对PowerPoint的自动访问

22.3.4 对Outlook的自动访问

22.4 小结

22.5 习题

零基础学:微信小程序开发

目录

前言

第一篇 基础知识

第1章 认识微信小程序

1.1 微信小程序介绍

1.1.1 什么是微信小程序

1.1.2 微信小程序的发展历史

1.1.3 微信小程序的功能和应用场景

1.2 微信小程序开发准备

1.2.1 基础准备

1.2.2 开发准备

1.3 微信小程序开发工具介绍

1.3.1 项目创建

1.3.2 项目删除

1.3.3 开发工具界面介绍

1.3.4 项目调试介绍

1.4 项目实战:“Hello World”项目

1.5 本章小结

第2章 微信小程序项目结构配置

2.1 文件介绍

2.1.1 .wxml后缀的结构文件

2.1.2 .wxss后缀的样式文件

2.1.3 .js后缀的逻辑文件

2.1.4 .json后缀的配置文件

2.1.5 项目结构推荐配置

2.2 微信小程序配置

2.2.1 样式配置

2.2.2 其他配置

2.2.3 页面配置

2.3 生命周期函数

2.3.1 小程序的生命周期函数

2.3.2 各页面的生命周期函数

2.4 数据渲染

2.4.1 数据绑定

2.4.2 条件渲染

2.4.3 列表渲染

2.5 事件

2.6 模板使用

2.7 引用

2.8 项目实战:通信录

2.9 本章小结

第3章 微信小程序UI组件

3.1 基础视图组件

3.1.1 view视图容器

3.1.2 scroll-view滚动视图容器

3.1.3 image图片容器

3.1.4 text文本组件

3.1.5 cover-view覆盖视图容器

3.1.6 cover-image覆盖图片容器

3.1.7 icon图标组件

3.2 高级视图组件

3.2.1 swiper轮播容器

3.2.2 progress进度条组件

3.2.3 slider滑动选择器组件

3.2.4 switch开关组件

3.2.5 map地图组件

3.3 表单组件

3.3.1 form表单组件

3.3.2 button按钮组件

3.3.3 checkbox多选项组件

3.3.4 radio单选项组件

3.3.5 label扩展组件

3.3.6 input输入框组件

3.3.7 textarea多行输入框组件

3.3.8 picker滚动选择器组件

3.3.9 picker-view嵌入式滚动选择器组件

3.4 媒体组件

3.4.1 camera相机组件

3.4.2 audio音频组件

3.4.3 video视频组件

3.5 画布组件canvas

3.6 项目实战:计算器

3.7 本章小结

第4章 微信小程序API

4.1 页面导航

4.1.1 wx.navigateTo

4.1.2 wx.navigateBack

4.1.3 wx.switchTab

4.1.4 wx.redirectTo

4.1.5 wx.reLaunch

4.2 网络请求

4.2.1 发送网络请求

4.2.2 文件的上传、下载

4.3 文件的操作

4.3.1 文件保存与打开

4.3.2 文件信息获取

4.3.3 文件管理者

4.4 图片的操作

4.4.1 图片选择

4.4.2 图片预览

4.4.3 图片信息获取

4.4.4 图片保存

4.5 交互反馈

4.5.1 消息提示框

4.5.2 加载提示框

4.5.3 模态弹窗

4.5.4 下弹操作菜单

4.6 获取用户信息

4.6.1 用户登录

4.6.2 用户信息

4.6.3 用户位置

4.6.4 用户授权

4.7 设备信息API

4.7.1 获取设备信息

4.7.2 屏幕亮度

4.7.3 获取设备电量

4.7.4 设备剪切板

4.7.5 设备方向

4.7.6 设备网络

4.7.7 拨打电话

4.7.8 扫描二维码

4.8 其他常用的API

4.8.1 微信支付

4.8.2 转发

4.8.3 下拉刷新

4.9 数据缓存

4.10 项目实战:九宫格选图

4.11 本章小结

第二篇 实战案例

第5章 新闻阅读

5.1 需求描述

5.2 设计思路

5.2.1 首页描述

5.2.2 视频页描述

5.2.3 我的描述

5.3 准备工作

5.4 页面搭建

5.4.1 首页页面搭建

5.4.2 视频页面搭建

5.4.3 我的页面搭建

5.5 逻辑搭建

5.5.1 首页逻辑

5.5.2 视频逻辑

5.5.3 我的逻辑

5.6 项目小结

第6章 单车共享

6.1 需求描述

6.2 设计思路

6.2.1 首页描述

6.2.2 故障申报描述

6.2.3 我的描述

6.3 准备工作

6.4 页面搭建

6.4.1 首页页面搭建

6.4.2 我的页面搭建

6.4.3 报修页面搭建

6.5 逻辑搭建

6.5.1 页面跳转逻辑

6.5.2 首页逻辑

6.5.3 车辆故障逻辑

6.6 数据获取

6.7 项目小结

第7章 视频快讯

7.1 需求描述

7.2 设计思路

7.2.1 首页描述

7.2.2 短视频描述

7.2.3 频道描述

7.2.4 我的描述

7.3 准备工作

7.4 页面搭建

7.4.1 首页页面搭建

7.4.2 短视频页面搭建

7.4.3 频道页面搭建

7.4.4 我的页面搭建

7.5 逻辑搭建

7.5.1 首页逻辑

7.5.2 短视频逻辑

7.5.3 频道逻辑

7.5.4 我的逻辑

7.6 项目优化

7.7 项目小结

第8章 云音乐

8.1 需求描述

8.2 设计思路

8.2.1 发现描述

8.2.2 我的描述

8.2.3 私人FM描述

8.2.4 每日推荐描述

8.2.5 歌单描述

8.2.6 排行榜描述

8.2.7 歌单列表描述

8.2.8 音频播放描述

8.3 准备工作

8.4 页面搭建

8.4.1 发现页面搭建

8.4.2 我的页面搭建

8.4.3 私人FM页面搭建

8.4.4 每日推荐页面搭建

8.4.5 歌单页面搭建

8.4.6 排行榜页面搭建

8.4.7 歌单列表页面搭建

8.4.8 音频播放页面搭建

8.5 逻辑搭建

8.5.1 发现逻辑

8.5.2 每日推荐逻辑

8.5.3 歌单逻辑

8.5.4 排行榜逻辑

8.5.5 歌单列表逻辑

8.5.6 音频播放逻辑

8.6 项目小结

第9章 商城购物

9.1 需求描述

9.2 设计思路

9.2.1 首页描述

9.2.2 分类描述

9.2.3 购物车描述

9.2.4 我的未登录描述

9.3 准备工作

9.4 页面搭建

9.4.1 首页页面搭建

9.4.2 分类页面搭建

9.4.3 购物车页面搭建

9.4.4 我的未登录页面搭建

9.5 逻辑搭建

9.5.1 首页逻辑

9.5.2 分类逻辑

9.5.3 我的未登录逻辑

9.5.4 购物车逻辑

9.6 项目小结

第10章 外卖配送

10.1 需求描述

10.2 设计思路

10.2.1 首页描述

10.2.2 大类型描述

10.2.3 为你优选描述

10.2.4 商铺详情描述

10.3 准备工作

10.4 页面搭建

10.4.1 首页页面搭建

10.4.2 大类型页面搭建

10.4.3 为你优选页面搭建

10.4.4 商铺详情页面搭建

10.5 逻辑搭建

10.5.1 首页逻辑

10.5.2 大类型逻辑

10.5.3 为你优选逻辑

10.5.4 商铺详情逻辑

10.6 项目小结

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部