百战程序员_ Java1573题

下面是相对普通的毕业学员，一行三人来北京学习，毕业后分布在北上广深一线大城市， 平均月薪16k，年薪为：16*12=19.2万，未加五险一金、补助和年终奖。加入的话，妥妥突破20万。

百战程序员培养时长和方式：

腾讯等大型企业对技术人员定级和相应的薪酬标准(2015年，后续年份自我脑补)：

入学方式：
进入官方网址：itbaizhan.com
联系报名
自学内容（共100集，约40小时课程。不需要学习第二季和第三季）
北京大学计算机系教授都推荐的课程，你怎么能不自学，可以自行看视频学习，也可以加入自学辅导班（收费：480元，时长4年有效）

参加入学考试（技术笔试、面试）
通过考试者，可以入学
大学毕业的报名者，请携带毕业证和身份证
大学在校生，请携带学生证和身份证

免费实训4天，双向选择
免费特训4天，能不能撑下来。能撑下来就跟，不能淘汰。
正式签订合同，开始学习

收费方式：
可0学费入学！可参与合作单位、百度金融等大型机构和银行的学习贷款，让你零学费入学，赚钱后再还学费（通过学习每个月多赚3000就相当于免费学了。很多学员学完后是每个月多赚1万）！
每年付一次，双向选择，客户决定是否续费第二年服务

开班计划（2017年，共计：6期）

JavaSE编程基础
第一章 初识Java
你学习编程的目的是什么？学习编程最快的办法是什么？
程序员的职业规划是什么？我怎么能拿到10万年薪，30万年薪，50万年薪？
一个技术点，怎么样才能算学会？需要能默写出来吗？
北京尚学堂旗下“百战程序员”的理念和定位是什么？
如何考取百战程序员，进入正式班级学习？
哪个网站会公布最新的“百战程序员”视频和资料？
说出计算机语言为什么按照第一代、第二代、第三代发展?
降低计算机语言开发难度，减少对计算机硬件的直接编程

Java有什么核心优势让其流行?
跨平台性
互联网上的电脑硬件不同，软件环境差异较大。需要一个跨平台的语言。

Java的三个版本是什么?
JavaSE: 定位在客户端，主要用于桌面应用软件的编程
JavaEE:定义在服务器端的企业版，主要用于分布式网络程序的开发
JavaME:主要应用于嵌入式系统开发，如手机和PDA的编程

Java是哪个公司发明的? 现在这家公司处境如何? 为什么?
Java是Sun公司发明的
Sun公司在2009被Oracle公司收购
因为Sun是一家极具创新能力的公司，但是没能利用Java构建一个强有力、可变现的生态系统，没打好Java这张牌

Java的跨平台是通过什么实现的?
通过在不同平台上安装相应的Java虚拟机实现的；虚拟机可以将字节码文件（class）解释成相应平台的机器语言并执行

Java语言释型还是编译型?还是两者都是?
先编译再解释

JDK、JRE、JVM的全称是?
JDK: Java Development Kit 针对Java开发员的产品
JRE: Java Runtime Environment是运行Java程序所必须的环境集合
JVM：Java Virtual Machine解释运行Java字节码文件，跨平台的核心

JDK包含JRE，这句话对吗?
对；JDK包含JRE；同时JRE包含JVM

【上机】熟悉DOS命令行方式的常用命令：dir、cd等.
DOS下，自动补齐命令的键是哪个?DOS下，想查找以前执行的命令用哪个键?
DOS下，自动补齐命令的键是哪个Tab键
DOS下，想查找以前执行的命令用上下箭头, ↑或↓键

DOS下，dir命令表示什么含义? cd 表示什么含义?
dir:查看某个目录下的子目录和文件
cd:改变当前目录

【上机】安装JDK、配置环境变量、并写出自己的第一个HelloWorld程序
需要配置Java_HOME ，path，classpath三个环境变量
public class Test{
public static void main(String args []){
System.out.println("Hello World");
}
}

为什么采用Java_HOME的方式配置环境变量较好?
便于Java_HOME路径的重用，避免由于JDK安装路径变化而修改多个环境变量；

public class 的类名必须跟文件名保持一致吗?
public class 的类名必须跟文件名保持一致

编程风格一定要：成对编程和缩进。用文字或代码说明如何实现成对编程和缩进。
public class Test{
public static void main(String args []){
System.out.println("Hello Java");
System.out.println("尚学堂");
}
}

system.out.println("hi"); —-这句代码能否顺利执行?
不能顺利执行；Java区分大小写，需要将system修改为System

一个Java源文件可以写多个class吗?编译后，会不会生成多个class文件?
一个Java源文件可以写多个class?编译后会生成多个class文件

编程时，为什么需要注释?注释的类型？
注释就是程序员为读者作的说明，是提高程序可读性的一种手段；注释同时也是调试代码时的一种手段，可以对某些不要执行的代码进行注释；
注释分为单行注释，多行注释和文档注释三种类型；

多行注释能不能嵌套使用?
多行注释不能嵌套使用

【上机】使用snagit/ FastStone Capture软件截图
【上机】使用pdf阅读器做笔记，阅读相关电子书文档
【上机】使用录屏软件Camtasia录制和转换视频
【上机】使用onenote记笔记和画图
【上机】使用亿图软件画出相关图形

阶段项目课程1
【项目】台球游戏小项目
练习目标：

1. 找到敲代码的感觉
2. 收获敲代码的兴趣
3. 作出效果，找到自信
4. 从一开始就学会调试错误
5. 掌握Java代码基本结构
   注意：不要求学生理解代码的语法功能，只要按照代码结构输入代码，能够经过调试实现代码的正常运行即可；
   全部讲解和练习时间控制在2小时以内
   项目需求：
   桌球在球桌中按照一定线路和角度移动；遇到边框会自动弹回

要求：
即使看不太懂，也要照着敲如下游戏代码，至少5遍。要求所有字符和源文件一致。如果报异常，请细心看所在行和老师代码有何区别：

第二章 数据类型和运算符
常用的进制有哪些？
十进制、二进制、八进制、十六进制

如何将10进制转换为2进制数据
除2取余,逆序排列
举例:

位、字节、字符的概念及其计数范围？
位：计算机存储信息的基本单位，代表一个二进制数位，
计数范围:0或1
字节：8个连续的二进制位为一个字节，可以存放1个西文字符的编码
计数范围:-128~127
字符：单引号用来表示字符常量，例如 ‘A’，‘张’
计算范围:0-65535之间的编码

标识符的作用是什么?
用作给变量、类和方法命名
这个标识符合法吗? int aaa@bbb = 33;
不合法

标识符能不能使用汉字开头?为什么?
可以，字母的含义包括：英文、汉字等（不建议大家使用汉字来定义标识符）

Java中有没有goto语句?有没有goto关键字?
java中没有goto语句，有goto关键字

byte,short,int,long类型，分别占用几个字节?表数范围多大?
byte:1个字节 -128~127
short:2个字节 -215～215-1
int:4个字节 -231~231-1
long:8个字节 -263~263-1

整型常数默认是什么类型?
int类型

float,double分别占用几个字节?
float:4个字节
double:8个字节

如何用科学计数法表示3.14?
314E-2

浮点常量默认是什么类型?
double类型

如下写法哪些是不对的：
a. byte b = 30;
b. byte c = 500;
c. long d = 2343223;
d. float f = 3.14;
b:不对，超出了byte的范围
d:不对，缺少f,应该写为3.14f或3.14F

浮点数能用于比较吗?下面可能打印什么结果:

打印结果为: d1 == d2
float类型的数据在内存中的存储形式为科学计数法, 且有效位数为7位, 则d1为4.2343242E7, d2用科学计数法表示同样为4.2343242E7, 因此d1 == d2

字符型变量几个字节? 这种写法对不? char c = "d";
字符型变量占2个字节
写法不对，应该为char c=‘d’;

布尔型变量占用空间是一位还是一个字节?
布尔型变量占一位

这种写法好不好? if(b==true)
不好,应写为if(b)

常量的声明使用哪个关键字?
常量的声明使用的关键字是final

常量的命名规范是?
全部由大写字母组成，单词间通过下划线来界定

解释一下，驼峰原则?
当变量或函数名称需要多个英文单词组成时，首字母以小写开头，每个单词首字母大写（第一个单词除外）

这两个表达式分别返回什么结果? ((1<3)?"a":"b")+3+4， x=-2; x > 0 ? 1 : (x == 0 ? 0 : -1)
((1<3)?"a":"b")+3+4 返回结果为a34
x=-2; x > 0 ? 1 : (x == 0 ? 0 : -1) 返回结果为-1

什么情况下，加号会变成字符串连接符?
“+”号左右一个为String类型时，则变成字符连接符

4&5，4|5的结果分别是多少? 4&&5这个操作可行吗?为什么?
4&5的结果为4
4｜5的结果为5
4&&5这个操作不可行，因为&&左右要求为boolean类型表达式

int能否自动转换成byte,short,char? 是否有一定条件才能转换?
不能
需要强制类型转换

long能自动转换成int吗？long能自动转换成float吗?
long可以自动转成int
long可以自动转成float

自动类型转换中，容量小和容量大指的是什么意思?
容量大小指的是不同数据类型的存储数据的范围

强制类型转换中，是否可能发生数据丢失?
可能发生数据丢失

布尔类型能否自动转换为int? 如果不能，简述理由。
不能
因为类型不匹配

下面两种写法，哪个较好：
a. 70L60243657020
b. 7060243657020L
第一种写法好;
第二种表达式的前半部分70602436570的乘积有可能会超过int的取值范围, 导致精度损失

第三章 控制语句
三种控制结构是什么?
顺序结构，选择结构，循环结构

如果if语句后面不写{},if的控制范围是否只限于第一句?
正确

Math.random()是什么意思?如果想获得15-20之间的随机数，怎么办?
产生一个0-1之间的随机数，包含0但不包含1
(int)(Math.random()*6)+15;

switch语句的功能是否完全可以使用if else if else多选择结构来代替?如果是，为什么还需要switch结构?
可以
switch一般用来做多值的判断，如果判断条件为区间，则最好使用多重if来做，如果是等值情况最好使用switch来做

switch中的表达式的结果需要是什么类型?
byte,char,short,int
jdk1.5 加入了枚举
jdk1.7加入了String

switch语句中，一个case开始执行后，什么时候结束执行这个case的语句?
遇到break结束执行这个case语句

switch语句中，default是否必须写?
不是必须写

下面代码有什么错误?

case后的表达式后面应该是“：”冒号

循环结构模拟了现实世界中的什么逻辑?
循环结构模拟了现实世界中的“重复问题“的逻辑

循环结构的四种内部结构是什么?
while(布尔表达式){
循环体;
}
do{
循环体;
}while(布尔表达式);
for(初始表达式;布尔表达式;迭代因子){
循环体;
}
foreach(数组或集合中元素的类型 迭代变量:数组或集合名){
循环体;
}
while和dowhile有什么区别?
当条件不成立时，do-while至少执行一次

什么情况下，会出现死循环?并写出一个例子来
循环条件始终成立时，则会出现死循环
while(true){
System.out.println(“helloworld”);
}
for循环相比while循环有什么优势?
语法结构比while简便，
通常用于解决循环次数固定的问题

下面代码都有什么问题：

a没有初始化

下面代码有错误吗?如果有，指出错误：

i超出了作用域的范围

循环中，break的作用是？continue的作用是?
break用于强行退出循环，不执行循环中剩余的语句
continue用于跳过本次循环, 不执行continue后的语句, 继续下一次循环

语句块能否使用外部的变量?语句块中定义的变量，外部能否使用？
语句块能使用外部的变量, 但是语句块中定义的变量外部不能使用

方法的定义中，是否必须要有返回值类型?如果确实不需返回值，使用哪个关键字声明?
返回值类型不是必须的
不需要返回值使用关键字void

方法的定义中，return是否必须?它有什么作用?
不是必须
return语句终止方法的运行并指定要返回的数据

Java中，参数的传递使用值传递还是引用传递?
值传递

方法定义中，形式参数和实际参数有什么区别?用自己的话描述。
方法定义时的参数称为形式参数，需要数据类型
方法调用时的参数称为实际参数，不需要类型，只需要值

方法定义时，使用实参还是形参?
方法定义时，使用的是形参

定义形参时，必须要写变量类型吗?
必须要写变量类型

实参类型是否必须和形参类型匹配?
必须匹配

什么是方法的重载，有什么作用？
方法重载:
[1]在同一个类中
[2]方法的名称相同
[3]参数列表不同
[4]与访问修饰符和返回值类型无关
[5]与异常无关
作用:
传递不同的参数实现相同的效果

两同三不同指的是?返回值不同构成重载吗?形参名称不同构成重载吗?
两同：同一个类中，方法名称相同
三不同：参数列表的参数的类型，个数，顺序不同
返回值不同构不能方法得载
形参名称不同构不成方法重载

递归算法中，递归头和递归体分别指什么?
递归头：什么时候不调用自己方法，即递归的结束条件
递归体：什么时候需要调用自己方法，即自己调用自己

递归算法的优点是什么?缺点是什么?
递归的优点：将问题逐渐简单化
递归的缺点：会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度 比循环慢的多。

【上机】使用递归算法完成阶乘算法
public static int jiCheng(int number){
if (number==1) {
return 1;
}else{
return numberjiCheng(number-1);
}
}
【上机】根据随机生成的的月份，打出该月份的天数.（不考虑闰年、闰月）
public class Test{
public static void main(String [] args){
int day=0;
int ran=(int)(Math.random()12)+1;
switch(ran){
case 2:
day=28;
break;
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day=31;
break;
default:
day=30;
break;
}
System.out.println(ran+”月，共”+day+”天”);
}
}
【上机】用while和for循环分别计算100以内奇数和偶数的和，并输出。
（1）求1-100以内奇数的和；
用while循环：
int i=1;
int sum=0;
while(i<=100){
sum=sum+i;
i+=2;
}
System.out.println("1-100之间所有奇数的和是"+sum);
用for循环：
int i=1;
int sum=0;
for(i=1;i<=100;i+=2){
sum=sum+i;
}
System.out.println("1-100之间所有奇数的和是"+sum);
（2）求1-100以内偶数的和（略）

【上机】用while和for循环输出1-1000之间能被5整除的数，且每行输出3个。
用while:
int i=1;
int count=0;
while(i<=1000){
if(i%5==0) {
System.out.print(i+"\t");
count++;
if(count%3==0){
System.out.println();
}
}
i++;
}
用for循环：
int i=1;
int count=0;
for(i=1;i<=1000;i++){
if(i%5==0) {
System.out.print(i+"\t");
count++;
if(count%3==0){
System.out.println();
}
}
}

【上机】打印出九九乘法表
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+”” +i+”=”+(ij)+””);
}
System.out.println();
}

【上机】编程求：∑1+∑2+……+∑100
public static int getSum(int number){
if(number==1){
return 1;
}else{
return number+getSum(number-1);
}
}
public static void main(String [] args){
int sum=0;
for(int i=1;i<=100;i++){
sum+=getSum(i);
}
System.out.println(“和为:”+sum);
}

【上机】生成0-100随机数，直到生成88为止，停止循环！
public static void main(String[] args) {
//生成1-100随机数；
int r=(int)(Math.random()100)+1;
while(r!=88){
r=(int)(Math.random()100)+1;
}
}

【上机】把100~150之间不能被3整除的数输出
for(int i=100;i<=150;i++){
if(i%3!=0){
System.out.println(i);
}
}

【上机】打印出实心1010正方形、空心1010正方形
for(int i=1;i<=10;i++){
for(int j=1;j<=10;i++){
System.out.print(“*”);
}
System.out.println();
}

【上机】打印出实心1010菱形， 空心1010菱形
//1-6行正三角
for(int i = 0; i < 6; i++){
//前空格
for(int j = 0; j < 5 - i; j++){
System.out.print("");
}
//
for(int j = 0; j < 2 * i + 1; j++){
System.out.print("");
}
//后空格
for(int j = 0; j < 5 - i; j++){
System.out.print("");
}
System.out.println();
}
//7-11行倒三角
for(int i = 0; i < 5; i++){
//前空格
for(int j = 0; j < i + 1; j++){
System.out.print("");
}
//
for(int j = 0; j < 9 - 2 * i; j++){
System.out.print("");
}
//后空格
for(int j = 0; j < i + 1; j++){
System.out.print("");
}
System.out.println();
}

【上机】将如上所有上机相关算法的作业，封装成方法，便于重用。

第四章 数组
数组的类型可以为任意类型吗?
可以是任意类型

数组中的元素的类型必须是相同的吗? 数组中的元素是有序的吗？
数组中元素的类型必须是相同的
数组中元素是有序的, 索引的顺序

数组的长度可变不? 数组的长度使用哪个属性?
数组一旦声明其长度不能更改
数组的长度属性是length

数组元素下标(或索引)的范围是?
范围是0-数组名.length-1

数组也是引用类型吗？ 数组也是对象，这句话对吗?
数组是引用数据类型
数组也是对象这句话正确

数组中的元素就像对象中的成员变量一样，初始化方式也一样。这句话对吗?
正确

【上机】数组的三种初始化方式是什么? 并测试练习相关代码
静态初始化
int [] a={1,2,3};

动态初始化
int [] a=new int[2];
a[0]=1;
a[1]=2;

默认初始化
int [] a=new int[2];//0,0

数组的静态初始化代码，下面代码有没有不合理的地方：

    有,new Dog(“小强”,2)后的逗号应去掉

完成如下代码：

下面的数组定义哪些是正确的？

    CDE是正确的

请在下面语句中找出一个正确的。
A. int arr1[2][3];
B. int[][] a2 = new int[2][];
C. int[][] arr2=new int [][4];
D. int arr3[][4]= new int [3][4];
B正确

【上机】定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个 单词就打印出“Yes”，不包含就打印出“No” 。
public class Test{
public static boolean isFind(String [] arr,String word){
boolean isFlag=false;
for(int i=0;i if(word.equals(arr[i])){
isFlag=true;
break;
}
}
return isFlag;
}
public static void main(String [] args){
String[] arr={“hello”,”world”,”java”,”html”,”oracle”,
”apple”,”orange”,”banana”,”red”,”green”};
System.out.println(isFind(arr,args[0])?”Yes”:”No”);
}
}

冒泡排序的基本思路
1.整个数列分成两部分：前面是无序数列，后面是有序数列
2.初始状态下，整个数列都是无序的，有序数列是空
3.如果一个数列有n个元素，则至多需要n-1趟循环才能保证数列有序
4.每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1）
5.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）
6.如果前一个大于后一个，交换
7.根据是否发生交换判断数组是否已经有序

使用冒泡排序完成数组元素的排序
int [] array={34,23,4,55,34,53};
for(int i=0;i boolean flag = true;
for(int j=0;j if(array[j]>array[j+1]){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
Flag = false;
}
}
if(flag){
break;
}
}

可变参数的作用及其用法
作用：适用于参数个数不确定、类型确定的情况，java把可变参数当做数组处理
用法:
只能出现在参数列表的最后
…位于变量类型和变量名之间，前后有无空格都可以
调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数

如何给main方法传递实参
通过命令行参数给main方法传递实参

【上机】用二重循环求出二维数组b所有元素的和：
int[][] b={{11},{21,22},{31,32,33}}
int sum=0;
for(int i=0;i for(int j=0;j sum+=b[i][j];
}
}
System.out.println(“和为:”+sum);

eclipse可以开发Java，可以开发c++吗？
可以

eclilpse中的debug模式有什么好处?
修正语法错误和逻辑错误的过程，保证程序的正确性

eclipse中运行一个Java程序，如何操作?
单击右键选择run As ,再选择java Application

eclipse需要安装吗? 使用eclispe需要安装JDK吗？
不需要

【上机】熟悉eclipse开发环境，建立一个Java项目，并运行一个类
【上机】熟悉eclipse的调试环境(debug)，建立一个Java项目，并使用debug 进行调试，测试程序每步执行情况。
假如我找不到package explore视图了，怎么样才能让他出现?
菜单栏WindowShow Viewpackage explore

阶段项目课程2
【项目】福彩双色球项目
练习目标

1. 掌握数据类型和运算符
2. 掌握流程控制
3. 掌握数组
4. 掌握方法的定义和调用
5. 提高代码调试能力
   全部讲解和练习时间控制在4小时以内
   项目需求
   双色球投注区分为红色球号码区和蓝色球号码区，
   红色球号码区由1-33共33个号码组成，蓝色球号码区由1-16共16个号码组成。
   投注时选择6个红球号码和1个蓝球号码组成一注进行单式投注，每注金额2元。
   中奖规则同福彩双色球规则；
   显示中奖结果的同时显示您一共下注人民币？？元，累计中奖人民币？？元

扩展：
按照自己的思路和老师的代码模板，设计一个小的作业项目。
将上一个作业作业录制成自己的教学视频
第五章 面向对象
简述面向对象和面向过程的区别和联系?
两者都是软件开发思想，先有面向过程，后有面向对象。在大型项目中，针对面向过程的不足推出了面向对象开发思想。
比喻
蒋介石和毛泽东分别是面向过程和面向对象的杰出代表，这样充分说明，在解决复制问题时，面向对象有更大的优越性。
面向过程是蛋炒饭，面向对象是盖浇饭。盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是“可维护性”比较好，“饭” 和“菜”的耦合度比较低。
区别
编程思路不同： 面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。
封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。
面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显。

对象和类的关系是?
类是抽象的
对象是具体的，是类抽象概念的实物表达

栈的特点是?存放什么内容?
栈的特点：先进后出
在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

堆得特点是?存放什么内容?
堆内存的特点：
堆内存有内存地址，都是将内存的地址赋值给引用变量
堆内存变量无用后由垃圾回收机制不定时回收
堆内存会自动初始化

堆内存存放引用数据类，及new出来的都在堆内存里面

【上机】画出如下程序的内存结构（课堂上的代码）：

局部变量、成员变量、静态变量分别怎么声明?
局部变量：在方法或代码块中声明的变量称为局部变量
成员变量：在类中声明的变量称为成员变量
静态变量：使用static修饰的成员变量称为静态变量

局部变量使用之前，必须要手动初始化吗?
局部变量在使用之前，必须要手动初始化

如果不手动指定成员变量的值，系统将会自动初始化。那么初始化的规则是?
整型初始化为0
浮点型初始化为 0.0
引用数据类型初始化为null
boolean类型初始化为false
char类型的初始化为\u0000

成员变量从属于谁? 静态变量又叫什么以及从属于谁? 局部变量从属于谁?
成员变量从属于对象
静态变量又叫类变量从属于类
局部变量从属于方法或代码块

构造方法的作用是两个：一个构造类的对象，另一个作用是初始化对象的属性。这 种说法对不?
对

构造方法的名称必须保持跟类名一致吗?
必须与类名一致

构造方法有没有返回值?详细用文字描述返回值问题。
构造方法没有返顺值，也不可以写void

构造方法如何被调用?
构造方法在创建对象时被调用，使用关键字new

构造方法中能不能有return语句?
构造方法中不能使用return语句

系统一定会给我们添加无参数的构造方法吗? 请详细解释。
如果手动编写了构造方法之后，系统就不会添加无参构造方法了

下面的代码有什么问题:

    当局部变量名称与成员变量名称相同时，使用this代表成员变量，代码应改为

computer(int price, int type, String brand){
this.price=price;
this.type=type;
this.brand=brand;
}

【上机】设计一个类代表二维空间的一个点
public class Point{
private int x;
private int y;
public void setX(int x){
this.x=x;
}
public int getX(){
return x;
}
public void setY(int y){
this.y=y;
}
public int getY(){
return y;
}
public Point(){
}
public Point(int x,int y){
this.x=x;
this.y=y;
}
}
【上机】设计一个类代表二维空间的一个圆。要求两个成员变量。一个是圆心，一 个是半径提供计算面积的方法。
public class Cricle{
private int r;
private Point point;
public void setR(int r){
this.r=r;
}
public int getR(){
return r;
}
public void setPoint(Point point){
this.point=point;
}
pubic Point getPoint(){
return point;
}
public Cricle(){

}
public Cricle(int r,Point point){
this.r=r;
this.point=point;
}
public double area(){
return Math.PI*Math.pow(r,2);
}
}
【上机】为上述Cricle类添加一个方法，计算一个点（Point对象）是否在圆（Cricle 对象）内，并写程序验证

//在Cricle类中加入方法
public class Cricle{
…..
public boolean isFlag(Point p){
if(Math.pow(x-p.getX())+Math.pow(y-getY())<=Math.pow(r,2)){
return true;
}
}
return false;
}
public class Test{
public static void main(String [] args){
Point p=new Point(3,3);//圆心
Cricle c=new Cricle(5,p);
System.out.println(c.isFlag(new Point(5,5))?”在圆内”:”不在圆内”);
}
}
构造方法能不能重载?
构造方法可以重载

this在普通方法中，指的是哪个对象?在构造方法中，指的是?
this在普通方法中总是指向调用该方法的对象
this在构造方法中总是指向正要初始化的对象

static变量在内存中放置在哪个区? static变量和方法为什么被称为类变量和类方 法?可以被该类所有对象共享吗?
static变量存在数据区
static变量和方法归类所有，使用类名去调用
可以被该类的所有对象所共享

静态初始化块和main方法哪个先被执行?
静态初始化块先执行

一个构造方法调用另一个构造方法怎么调用? this()，这样的调用方式必须位于第 一句吗?
this()调用本类的无参构造方法
this(实参列表)调用本类的带参构造方法
super()调用直接父类的无参构造方法
super(实参列表)调用直接父类的带参构造方法
this()调用必须位于构造方法的第一句

package的两个作用是什么?
解决类之间的重名问题
为了便于管理类：合适的类位于合适的包

增加package以后，我们在DOS下编译怎么做?
javac -d . Test.java

import是用于导入包还是导入类?
import是用于导入其它包中的类

Java项目的API文档如何生成?请将步骤写出。
javadoc 源文件名.java;

面向对象中的封装，追求的是“高内聚，低耦合”。解释一下，内聚什么？什么叫 耦合?
内聚:程序内的各个模块之间的关系紧密程度
耦合:外部程序（子程序）之间的关系紧密程度

封装的几个关键字：private,default,protected,public的含义。
代表的是访问权限
private:私有的，只能本类访问
default:默认的，本类，子类，本包中的其它类都可以访问
protected:受保护的，本类，本包及其它包中的子类可以访问
public:公共的，本类，子类，本包及其它中的类都可以访问

一般属性是否要设置为private?
是, 属性就不能被赋值上任何非法的值了

如果属性设置为private，如何让外部访问该属性?
编写公有的取值的get方法

提供getter、setter方法的操作，eclipse中如何实现?
菜单栏SourceGenerate getters and setters

对于boolean类型的属性，提供的getter方法是：getXXX或是isXXX?
isXXX;

Javabean就是只包含属性和相关getter、setter方法，不包含业务逻辑处理的 类，这种说法对吗?
不对
Javabean既可以封装数据同时也可以封装业务逻辑

继承的好处是什么?
好处一：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象
好处二：为了提高代码的复用性

Java中有多继承吗?C++中有多继承吗? 单继承相比多继承优势在什么地方?
java中只有单继承
C++中有多继承
使用单继承有利于系统的维护，使得类与类之间的关系简单

【上机】模仿课堂上动物世界的例子，我们自己写个例子。
class Person{

}
class Teacher extends Person{

}

Java的继承使用哪个关键字实现?
extends

定义某个类时，如果没有使用extends，那么继承了哪个类?
如果没有使用extends，那么继承了Object类

Java中，有没有多继承? 请说明，Java为什么取消了多继承?
java中没有多继承
使用单继承有利于系统的维护，使得类与类之间的关系简单

重写(override)指的是什么?
指的是子类对父类中方法的重写

假如父类有main方法，子类能不能继承?
不能

Object是所有类的根类吗?是所有类的直接父类吗?
Object是所有类的根类
不是所有类的直接父类

在哪里查看Object类的源代码?
jdk安装目录中的src压缩包中可以查看源码

Object类中的toString方法能否被子类重写?请做测试。
能

【上机】完成继承、Object相关的测试代码

super指的是什么?
super指的是直接父类

构造方法中，第一个话总是super吗?
也可以是this()

叙述一下，有继承结构时，构造方法的调用顺序?
继承条件下构造方法的调用规则如下：
如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。
如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。
如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。
特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

重写中，子类的返回值类型可不可以跟父类不完全一致?说出你的理由。
可以
子类的返回值可以与父类相同，也可以是父类方法返回值的子类

如何判断两个对象内容是否相同？重写equals()有什么要求？
判断两个对象的内容是否相同，需要重写Object类的equals方法

举一个现实的例子，说明多态。
我第一次去见丈母娘。还没见的时候，我女朋友已经把我的情况介绍给丈母娘了，说我“长得像港台明星”。见面以后丈母娘一看，哇，原来是像曾志伟。当场晕倒。

多态的三个必要条件是什么?
继承
方法重写
父类引用指向子类对象

什么是向上转型？什么是向下转型？
向上转型：父类引用指向子类对象
向下转型：将父类引用转成真实的子类对象

多态的常用使用场合有哪些？
使用父类做方法的形参，实参可以是该父类的任意子类类型
使用父类做方法的返回值类型，返回值可以改父类的任意子类对象

Java的方法绑定采用动态绑定还是静态绑定?
静态方法，构造器，private方法，用关键字super调用的方法是静态绑定
通过对象调用的方法，采用动态绑定

final修饰变量、方法、类分别表示什么含义?
final修饰的变量不可改变，一旦赋了初值，就不能被重新赋值，称为常量
final 修饰的方法不能被子类重写
final修饰的类不能有子类

final修饰的方法能不能被重载?能不能被重写?
final修饰的方法可以重载
final修饰的方法不能重写

String类能不能被继承?为什么?
String类不能被继承
因为String类是使用final修饰的类

包含抽象方法的类是抽象类吗? 抽象类一定包含抽象方法吗?
包含抽象方法的类是抽象类
抽象类中不一定含有抽象方法

抽象类中能不能有普通方法？能不能定义构造方法?
抽象类中可以有普通方法
抽象类中可以定义构造方法

抽象类能不能被new出来?即抽象类的构造方法能不能被调用？
抽象类不能被new出来
抽象类的构造方法被子类调用

接口中只能定义常量和抽象方法吗?
JDK1.7之前,接口中只能定义静态常量和公共的抽象方法
JDK1.8中,接口中可以定义静态方法

接口描述了现实世界中什么逻辑?
接口描述了现实世界是“如果你是…则必须能..”的思想
如果你是天使，则必须能飞;如果你是汽车，则必须能跑

接口中的常量一定是public static final吗？抽象方法一定是public abstract 吗?
是的

接口中能不能定义普通变量，普通方法？从设计接口的角度说明为什么这么做?
接口中不能定义普通变量，也不能定义普通方法
因为接口就是一种规范，定义一种规则

接口能不能被new?
接口不能被new

接口中有没有多继承?
接口中有多继承

一个类能不能实现多个接口?
一个类能够实现多个接口

【上机】完成抽象类、接口的语法测试代码
public interface TakePhoto {

}
abstract class Phone{

}
class MoblePhone extends Phone implements TakePhoto{

}
class Test{
public static void main(String[] args) {
MobilePhone mp=new MobilePhone();
}
}

【上机】使用接口，定义电子产品系统(智能手机、MP3、智能手表)。
public interface Electronic {

}
class MobilePhone implements Electronic{

}
class Mp3 implements Electronic{

}
class Watch implements Electronic{

}

如何对一个数组的多个对象按照不同的依据进行排序；
对象实现Comparable接口
或者定义比较规则的类实现Comparator接口

模拟实现Comparable和Comparator接口；
实现Comparable接口
public class Student implements Comparable{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Student o) {
return this.age-o.getAge();
}
}
实现Comparator接口
class AgeComparator implements Comparator{
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
}

GC指的是什么?写出英文全称。垃圾回收机制中，程序员能不能调用垃圾回收器?
GC:是指垃圾回收
英文:garbage collection
程序员无权调用垃圾回收器

System.gc()指的是什么意思?
运行垃圾回收器

finalize方法可以用来做什么?
在垃圾收集器将对象从内存中清除出去前，做必要的清理工作

通过两个事例描述C++,Java不同的内存回收机制。
很久很久以前，每家每户“自扫门前雪”，自己收垃圾。
现在，环保局的垃圾车自动收垃圾。
通过，这些例子类比Java和C++不同的回收机制及特点。
C++需要程序员手动编写垃圾回收的代码，如果程序员忘了那么就容易造成内存 溢出等问题
java无需手动编写，jvm的垃圾回收机制会自动进行垃圾回收，减轻了程序员的 工作，也避免由于程序员忘记而造成的各种内存溢出等问题

第六章 异常机制
Java中，处理异常的两大步是?
捕获异常
声明异常

如果catch两个异常，一个是父类，一个是子类。这两个异常的catch顺序如何 确定?
子类异常在前父类异常在后

finally里面一般放置什么代码?
无论是否发生异常，都必须要执行的语句放到finally中, 比如数据库连接的关闭、IO流的关闭、socket连接的关闭等物理连接的关闭

Error和Exception的区别和联系
联系：Error与Exception都继承自Throwable类
区别:
Exception:
[1]可以是可被控制（checked）或不可控制的(unchecked)
[2]表示一个由程序员导致的错误
[3]应该在应用程序级被处理
Error:
[1]总是不可控制的(unchecked)
[2]经常用来用于表示系统错误或低层资源的错误
[3]如果可能的话，应该在系统级被捕捉

Throwable是一个类还是接口?
Throwwable是一个类

如果碰到NullPointerException，我们一般应该如何查错?如何做处理?
如果碰能NullPointerException异常，我们应该使用debug进行调试
使用try-catch-finally进行异常捕获处理

【上机】完成课堂测试异常的代码
【上机】eclipse中，增加try-catch块的操作是怎么做的?
Alt+Shift+Z

【上机】自定义一个自己的异常类
public class SexException extends Exception {
public SexException() {
super();
}
public SexException(String message) {
super(message);
}
}
方法重写时，子类声明异常能否超出父类的范围?
子类声明异常不能超出父类的范围
[1]父类没有声明异常，子类也不能
[2]不可抛出原有方法抛出异常类的父类或上层类
[3]抛出的异常类型的数目不可以比原有的方法抛出的还多(不是指个数)

【上机】下面的代码，有什么问题? 解释原因

    子类重写时，不可抛出原有方法抛出异常的父类或上层类<br />

说出你现在接触的几个异常?尽量多写。
ArithmeticException
NullPointerException
ClassCaseException
ArrayIndexOutOfBoundsException
NumberFormatException

阶段项目课程3
【项目】太阳系项目
练习目标：

1. 类和对象
2. final常量
3. 构造方法及其重载
4. this和super关键字的使用
5. 方法重写
6. 类的三大特征：封装、继承、多态
7. 作出效果，找到自信
   注意：不要求学生对AWT编程的内容有详细认识，重点是关于太阳系星球的面向 对象设计和开发；全部讲解和练习时间控制在4小时以内 。
   要求：
   太阳系中八大行星围绕太阳按照不同的速度转动；月亮围绕地球转动。
   根据老师课程讲解，完成太阳系项目小游戏。

扩展：
按照自己的思路和老师的代码模板，设计一个小的作业项目。
将上一个作业作业录制成自己的教学视频

第七章 常用类
为什么需要包装类?包装类的作用是?
因为java语言是面向对象的语言，但是java中的基本数据类型却不是面向对象的，而在实际的使用中经常需要将基本数据转化成对象，便于操作。比如说在集合中存储数据时，只能存储对象
作用：
[1]作为和基本数据类型对应的类类型存在，方便涉及到对象的操作
[2]包含每种基本数据类型相关的属性以及相关的操作方法

将字符串"123"转化成基本类型数字的方式有哪些？
通过Integer类的静态方法来转换
Integer.parseInt(“123”);

自动装箱和自动拆箱指的是?举例说明。
自动装箱和自动拆箱指的是将基本数据类型和包装类进行自动的互相转换

【上机】完成老师课堂上Integer的测试，并自己写Double类的测试代码
public class TestDouble {
public static void main(String[] args) {
Double int1 = new Double(10);
Double int2 = Double.valueOf(20);
double a = int1.doubleValue();
Double int3 = Double.parseDouble("334");
Double int4 = new Double("999");
String str1 = int3.toString();
}
}

为什么String类被称为不可变字符序列?从String类的源代码分析，给出解释。
字符串是常量，它们的值在创建之后不能更改，String对象是不可变的，所以可以共享
String类的底层结构是char类型的数组value,而这个数组使用final进行修饰

【上机】String类的equals方法跟Object的equals方法什么关系? 并详细阅 读String类的equals方法源代码，分析它的内部流程。
String类的equals方法重写了Object类的equals方法，用于比较两个String对象的内容是否相同

String类的equals方法的源码分析:
如果两个String对象的内存地址（引用）相同，那么return true
如果两个String对象的内存地址（引用）不相同，那么进行类型判断,如果不是String类型，那么直接返回false,如果是String类型则进行向下类型转换，转换成String类型，然后变改char类型数组，比较两个数组对应位置上的内容是否相同，如果相同返回true,如果不同返回false

String类的trim()方法是什么作用?
返回字符串的副本，去掉字符串前后的空格

"hamburger".substring(4, 8) 返回的结果是?
urge

【上机】分析下面代码的结果，并画出内存结构图，针对每个打印的结果给出文字 解释。

    System.out.println(s==ss);结果为true
    System.out.println(s3==s4);结果为true
    System.out.println(s4==s5);结果为false
    System.out.println(s4.equals(s5));结果为true

【上机】练习String类的常用方法
字符串的长度:
System.out.println(“hello”.length());
去掉字符串前后的空格:
System.out.println(“ hello world ”.trim());
截取子字符串:
System.out.println(“helloworld”.substring(0,4));

StringBuffer和StringBuilder的联系是？区别是？
联系：
StringBuffer和StringBuilder都是可变字符序列，底层数组结构都是char类型的数组
区别：
StringBuffer：jdk1.0版,线程安全，但是效率低
StringBuilder:jdk1.5版，线程不安全，但是效率高
如下的代码会造成什么后果?运行期间会产生多少个对象? 使用StringBuilder 修改这段代码。

    会导致大量副本字符串对象存留在内存中，降低效率
    运行期间会产生10001个对象
StringBuffer sb=new StringBuffer();

for(int i=0;i<10000;i++){
sb.append(i);
}

计算机中的时间是如何表示的？
获取从1970-1-1 0:0:0到当前时间所经历的毫秒数，然后转换为日期或者时间

System.currentTimeMillis()表示什么意思?
返回以毫秒为单位的当前时间

Date d = new Date()表示的是当前时间吗?
是，精确到毫秒

【上机】我们使用SimpleDateFormat类来实现时间跟字符串的转化。常用那两 个方法?并写出代码，举例说明
//字符串转日期
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
sdf.parse("1990-3-3");
//日期转字符串
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
sdf.format(new Date());

将1990年3月3日通过Calendar来表示，并得出这天是该年的第几天?将该日 期增加35天，是哪一天?使用代码来说明。
public static void main(String[] args) throws ParseException {
Calendar c=new GregorianCalendar();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
c.setTime(sdf.parse("1990-3-3"));
System.out.println( c.get(Calendar.DAY_OF_YEAR));
c.add(Calendar.DATE, 35);
System.out.println(c.get(Calendar.YEAR)+"年"
+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DATE));
}

【上机】写代码测试Date/SimpleDateFormat/Calendar的用法。
//Date的用法
public static void main(String[] args) {
Date date1 = new Date();
System.out.println(date1.toString());
}
//SimpleDateFormat的用法
SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String daytime = s1.format(new Date());
//Calendar的用法
GregorianCalendar calendar2 = new GregorianCalendar();
calendar2.set(Calendar.YEAR, 2009);

     /</em>

代码1：
Set treeSet=new TreeSet();
/

/
代码2：
ScoreComp scoreComp=new ScoreComp();//定义一个外部比较器的对象；
Set treeSet=new TreeSet(scoreComp);//把外部比较器对象作为TreeSet构造方法的参数；
*/
Student p1=new Student(1,78);
Student p2=new Student(2,67);
Student p3=new Student(3,96);
Student p4=new Student(4,87);

    treeSet.add(p3);
    treeSet.add(p4);
    treeSet.add(p1);
    treeSet.add(p2);</p>

<pre><code>Iterator it=treeSet.iterator();

while(it.hasNext()){
    System.out.println(it.next());
}

}

}

//定义外部比较器；
class ScoreComp implementsComparator{

publicint compare(Object obj1,Object obj2){</p>

<pre><code>Student p1=(Student)obj1;
Student p2=(Student)obj2;
int result=p1.getScore()-p2.getScore();//用学生分数排序；
return result;

}

}
【上机】说明Comparable接口作用。并定义一个学生类，使用分数来比较大小。
自定义类如Student，Product，Person等虽然不是同一类事物，但是都有比较的权利，都可以实现比较的功能。既然是同一功能（比较），就定义一个接口吧，把方法定义在接口里，由各个类去具体实现。
实现Comparable接口的类需要实现compareTo方法，根据该方法可以根据具体的排序规则对容器中的对象进行排序。
publicclass Student implementsComparable{
privateintid;
private String sex;
private String name;
privateint score;
privateintage;

public Student() {
}
public Student(int id, String sex, String name, int score, int age) {
    this.id = id;
    this.sex = sex;
    this.name = name;
    this.score = score;
    this.age = age;
}
publicint compareTo(Object o) {
    Student s = (Student)o;
    returnthis.score-s.score;
}

}

Map中，key能否重复?如果重复，会有什么现象?
key:无序，唯一；
添加重复的key不报错，会把之前重复的key覆盖了。
Set和Map的集合类名称相似，有没有内在的联系？
HashMap和HashSet这些集合类采用的是哈希表结构，需要用到hashCode哈希码和equals方法。
【上机】综合使用List、Map容器存放如下数据, 并从map中取出“李四”。
姓名：张三 年龄：18 体重：90 地址：北京
姓名：李四 年龄：28 体重：50 地址：上海
注：不能使用Javabean封装！

先创建Person类；
publicclass Person {
//私有属性；
private String name;
privateint age;
privatedouble weight;
private String address;

//getter和setter方法（略）；
//构造方法；
public Person(String name, int age, double weight, String address) {
    super();
    this.name = name;
    this.age = age;
    this.weight = weight;
    this.address = address;
}</p>

<p>@Override
public String toString() {
    return"Person [name=" + name + ", age=" + age + ", weight=" + weight + ", address=" + address + "]";
}

}
用List存放数据：
List personList=new ArrayList();

    Person p1=new Person("张三",18,90,"北京");
    Person p2=new Person("李四",28,60,"上海");</p>

<pre><code> //把Person对象添加到personList里；
personList.add(p1);
personList.add(p2);

用Map存放数据：
Map map=new HashMap();
//把Person对象添加到map里，用name作为key，Person对象作为value;
map.put(p1.getName(), p1);
map.put(p2.getName(), p2);
//提取名为“李四”的人的信息，用map.get(key)方法，返回的是此key对应的value值；
System.out.println(map.get("李四"));

【上机】使用JavaBean封装，完成上个题目的练习。
【上机】写出List、Set、Map中使用泛型的例子。
ArrayList aList=new ArrayList();//只能接收String类型的对象；
Set set=new HashSet();//只能接收Integer类型的对象；
Map map=new Map();//只能接收key类型为Integer，value类型为String。
使用泛型有什么好处?
泛型是JavaSE1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Java语言引入泛型的好处是安全简单。
【上机】用代码写出遍历List的三种方式
finalintSIZE = list.size();
for (int i = 0; i String s = list.get(i);
System.out.print(s+"");
}
System.out.println();
for (String string : list) {
System.out.print(string+"");
}
System.out.println();
Iterator it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.print(s+"");
}
}

【上机】用代码写出遍历Set的两种方式
1）增强for循环遍历
for (Integer integer : set) {
System.out.print(integer.intValue() + "");
}
2）Iterator 遍历
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next().intValue() + "");
}

【上机】用代码写出遍历map的方式
1：得到所有的key
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
String key = iterator.next();
System.out.println(key + "—>"+map.get(key));
}
2：得到所有的value
Collection collection = map.values();
for (String string : collection) {
System.out.println("value—>"+string);
}
3：得到所有的key和value
Set> entries = map.entrySet();
Iterator>iterator2 = entries.iterator();
while (iterator2.hasNext()) {
Entry entry = iterator2.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "—>"+value);
}

采用增强for循环遍历List或者Set，如果List或者Set没有加泛型，能遍历吗?
能。
如果我想在遍历时删除元素，采用哪种遍历方式最好?
Iterator接口。Iterator有remove方法可以移除元素。

Iterator是一个接口还是类?
Iterator接口。
Collection和Collections有什么区别?
Collection是Java提供的集合接口，存储一组不唯一，无序的对象。它有两个子接口List和Set。
Java中还有一个Collections类，专门用来操作集合类 ，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

资源文件有什么作用?
资源文件是用来配置信息的，如数据库信息，键值对信息等。程序里需要有个方法来读取资源文件中的配置信息。如果没有资源文件，配置信息就得写在代码里；需要修改信息时就不得不修改代码。有了资源文件之后，一旦信息需要改变，修改资源文件就可以，不用修改代码，更好的保证了代码的封装性。

【上机】在src下建立一个资源文件(不包含中文)，尝试使用Property类读取里 面的属性。
创建资源文件,我的是fruit.properties; “fruit”可以自定义，后缀名是“properties”。我写的文件内容如下（水果名对应的水果信息：名称，产地，价钱）：
apple=name:apple,place:ShanDong,price:7.00RMB/500g
orange=name:orange,place:GuangDong,price:3.99RMB/500g
banana=name:banana,place:HaiNan,price:2.99RMB/500g
carrot=name:carrot,place:Beijing,price:2.98RMB/500g
代码部分：
publicclass TestProperties {

publicstaticvoid main(String[] args) throws IOException {</p>

<pre><code>File file=new File(&#34;fruit.properties&#34;);//参数是文件路径；
InputStream is=new FileInputStream(file);//建立此文件的输入流；
Properties p=new Properties();//创建资源文件对象；
p.load(is);//加载资源文件

String fruitInfo=p.getProperty(&#34;orange&#34;);//getProperty()的参数是资源文件中的key值，可以输入“apple”，“orange”,“banana”,”carrot”.
System.out.println(fruitInfo);//fruitInfo是通过输入的key值获得的水果信息。

}

}

【上机】使用entrySet方法遍历Map。
Set> entries = map.entrySet();
Iterator>iterator2 = entries.iterator();
while (iterator2.hasNext()) {
Entry entry = iterator2.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "—>"+value);
}
Vector和ArrayList的区别联系
Vector和ArrayList的区别和联系
实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用
两者的主要区别如下
Vector是早期JDK接口，ArrayList是替代Vector的新接口
Vector线程安全，ArrayList重速度轻安全，线程非安全
长度需增长时，Vector默认增长一倍，ArrayList增长50%

Hashtable和HashMap的区别联系
实现原理相同，功能相同，底层都是哈希表结构，查询速度快，在很多情况下可以互用
两者的主要区别如下
Hashtable是早期JDK提供的接口，HashMap是新版JDK提供的接口
Hashtable继承Dictionary类，HashMap实现Map接口
Hashtable线程安全，HashMap线程非安全
Hashtable不允许null值，HashMap允许null值

Java主要容器的选择依据和应用场合
（1） HashTable,Vector类是同步的，而HashMap,ArrayList不是同步的。 因此当在多线程的情况下,应使用 HashTable和 Vector,相反则应使用HashMap,ArrayList.
（2） 除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。
（3） ArrayList 由数组构建, LinkList由双向链表构建,因此在程序要经常添加,删除元素时速度要快些,最好使用LinkList,而其他情况下最好使用ArrayList.因 为他提供了更快的随机访问元素的方法。
阶段项目课程4
【项目】我的京东商城
练习目标：
选择合适的容器类型
使用容器存储商品和购物车条目
基本分层思想训练
购物车和购物车条目的设计
要求：
完成商品的添加和查询功能
完成购物车条目的添加和删除操作
根据老师课程讲解，完成项目

扩展：
按照自己的思路和老师的代码模板，设计一个小的作业项目。
将上一个作业作业录制成自己的教学视频。
第九章 IO流技术
IO是什么意思? data source是什么意思?
IO:Input Output;
data source:数据源。
字节流和字符流有什么区别？输入流和输出流有什么区别？
字符流和字节流是流的一种划分，按照处理流的数据单位进行的划分。两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使用的是InputStream，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。这四个都是抽象类。字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。字节流是最基本的，所有的InputStrem和OutputStream的子类都是字节流,主要用在处理二进制数据，它是按字节来处理的。但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的编码来处理，也就是要进行字符集的转化，这两个之间通过 InputStreamReader,OutputStreamWriter（转换流）来关联，实际上是通过byte[]和String来关联的。

流就像管道一样，在程序和文件之间，输入输出的方向是针对程序而言，向程序中读入东西，就是输入流，从程序中向外读东西，就是输出流。输入流是得到数据，输出流是输出数据。

节点流和处理流有什么区别?
节点流和处理流是流的另一种划分，按照功能不同进行的划分。节点流，可以从或向一个特定的地方(节点)读写数据。处理流是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

word文档能使用字符流操作吗?为什么?
不能。因为word文档不是纯文本文件，除了文字还包含很多格式信息。不能用字符流操作。可以用字节流操作。
【上机】完成老师课堂上读入文件数据的代码：

解释下面代码的含义：
通过上例得知fis是字节输入流对象，fis.read()是每次从指定文件读取一个字节，返回值是这个字节所代表的int类型的整数。如果读到文件结尾（没有内容可读了），那么返回-1。

    下面的代码是依次读取文件，每次一个字节，循环读取；每次读完后将返回的整数值（m）转成char类型的数据（强转）（从而知道每次读取的是什么字符），输出这个字符。直到读完为止。

流对象使用完后，一般要调用close方法关闭，释放资源。 这种做法对吗?
对。
【上机】完成老师写文件的操作：

InputStream和OutputStream基本特点是?
二者都是【字节】输入输出流的抽象父类。以字节为单位处理数据，每次读取/写入一个字节。适合处理二进制文件，如音频、视频、图片等。实现类有FileInputStream和FileOutputStream等。
Reader和Writer的基本特点是?
二者都是【字符】输入输出流的抽象父类。以字符为单位处理数据，每次读取/写入一个字符。适合处理文本文件。实现类有FileReader和FileWriter等。

FileInputStream和FileOutputStream的基本作用是?
二者都是【字节】输入输出流的实现类，其抽象父类是InputStream和OutputStream。以字节为单位处理数据，每次向/从指定文件读取/写入一个字节。适合处理二进制文件，如音频、视频、图片等。
FileReader和FileWriter的作用是?
二者都是【字符】输入输出流的实现类，其抽象父类是Reader和Writer。以字符为单位处理数据，每次向/从指定文件读取/写入一个字符。适合处理文本文件。
【上机】完成文件的copy代码
思路：先把源文件读到程序里，在从程序写到目标文件。
代码示例：
//1.创建数据源文件；
File file=new File("e:\picture1.jpg");
//2.搭建输入流管道；
InputStream is=new FileInputStream(file);
//3.创建目的地文件；
File file1=new File("e:\picture2.jpg");
//4.搭建输出流管道；
OutputStream os=new FileOutputStream(file1);
int b=0;
//每次从源文件读出一个字节（b=is.read()），就向目标文件写入一个字节
//（os.write(b)）；
while((b=is.read())!=-1){
os.write(b);
}
//读写全部完成后关闭资源；
os.close();
is.close();
}

BufferInputStream和BufferedOutputStream的特点是？
BufferInputStream和BufferedOutputStream分别是【缓冲】字节输入输出流，还有【缓冲】字符输入输出流（BufferReader和BufferedWriter）。
缓冲流是处理流，它不直接连接数据源/目的地，而是以一个节点流为参数，在节点流的基础上，提供一些简单操作。

先说不带缓冲的流的工作原理吧：它读取到一个字节/字符，就向用户指定的路径写出去，读一个写一个，所以就慢了。带缓冲的流的工作原理：读取到一个字节/字符，先不输出，等凑足了缓冲的最大容量后一次性写出去，从而提高了工作效率
优点：减少对硬盘的读取次数，降低对硬盘的损耗。

【上机】使用BufferedReader和BufferedWriter实现文本文件的拷贝。
//第一部分：准备从文件读数据到程序；
Reader reader=new FileReader(new File("e:\a.txt"));//创建读取对象reader；
BufferedReader br=new BufferedReader(reader); //创建缓冲流包装reader；
//第二部分：准备从程序写到文件；
Writer writer=new FileWriter(new File("e:\a3.txt"));//创建写入对象writer;

    BufferedWriter bw=new BufferedWriter(writer);//创建缓冲流包装writer；
    String str=null;
    //用循环边读（str=br.readLine()）边写（bw.write(str)）；
    while((str=br.readLine())!=null){
        bw.write(str);
        bw.newLine();
    }

bw.flush();//清空缓冲区；
//copy完成后关闭资源；
bw.close();
br.close();
}
InputStreamReader和OutputStreamWriter的作用是?
二者都是转换流，从字节流转换为字符流，是包装流，以一个节点流为参数;提供一些方便读写【字符】的方法。

    代码示例（InputStreamReader）：

publicstaticvoid main(String[] args) throws IOException {
//1.节点流；
InputStream is=new FileInputStream(new File("e:\a1.txt"));
//2.处理流：把字节流转换成了字符流；
InputStreamReader isr=new InputStreamReader(is,"utf-8");
int temp=0;

       //用转换流对象isr进行读取操作，以字符（而不是字节）为单位读取文本文件，方便操//作。

while((temp=isr.read())!=-1){
System.out.print((char)temp);
}
isr.close();
}

OutputStreamWriter(略).
PrintStream打印流经常用于什么情况? System.out 是不是打印流?
PrintStream：字节打印流，是OutputStream的实现类。提供了多个重载的print,println等方法，可以方便地向文本文件中写入数据。
System.out是字节打印流（PrintStream的对象），它被称作标准的输出流,输出的目的地是标准的输出设备，即显示器。所以，当我们使用System.out.print或System.out.println时会向屏幕（显示器）输出数据。

PrintStream的继承关系：

【上机】实现字节数组和任何基本类型和引用类型执行的相互转换。
提示：使用ByteArrayInutStream和ByteArrayOutputStream。
字节数组和基本数据类型之间的转换，以boolean类型为例：
输出一个boolean类型的数据：

boolean flag=true;//先定义一个boolean类型的变量；

ByteArrayOutputStream baos=new ByteArrayOutputStream();
DataOutputStream dos=new DataOututStream(baos);
dos.writeBoolean(flag);

byte[] b=baos.toByteArray();
//接下来可以把byte数组构建成一个数据包(DatagramPacket)发送出去；
读取一个boolean类型的数据：
byte[] b=new byte[1024];
//我们已接收到包含一个boolean类型数据的数据包（代码略）；数据信息已经包含在byte数组b里，接下来就把boolean类型的数据读出来并保持原类型；

ByteArrayInputStream bais=new ByteArrayInputStream(b);
DataInputStream dis=new DataInputStream(bais);
boolean flag=dis.readBoolean()；//这样数据就读出来了并保持着原来的数据类型。
字节数组和引用类型之间的转换：
输出一个引用类型信息：
//先建一个类，如User(代码略);

User user=new User();
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(user);

byte[] b=baos.toByteArray();
//接下来可以把byte数组构建成一个数据包(DatagramPacket)发送出去；

读取一个引用类型信息：
byte[] b=new byte[1024];
//我们已接收到包含一个User类型数据的数据包（代码略）；
//数据信息已经包含在byte数组b里，接下来就把User类型的数据读出来并保持原类型；

ByteArrayInputStream bais=new ByteArrayInputStream(b);
ObjectInputStream ois=new ObjectInputStream(bais);
User user=(User)ois.readObject();//这样数据就读出来了并保持着原来的数据类型。

DataInputStream和DataOutputStream的特点是?
二者都是处理流，要以一个节点流为参数；二者被称为数据流，是用来操作基本数据类型的。用DataInputStream写入一个类型的数据，用DataOutputStream读出数据时可以保持类型不变。如用DataInputStream写入一个int类型的数据，用DataOutputStream读出来的还是一个int数据，即可以直接当作int类型的数据来进行操作，不用做任何转换。

代码示例：
publicclass TestDataInputStream {
publicstaticvoid main(String[] args) throws IOException {
//1.写数据；
OutputStream os=new FileOutputStream(new File("e:\f.data"));//构建节点流；
DataOutputStream dos=new DataOutputStream(os);//用数据流包装节点流；
int n=123456;
String str="尚学堂教育";
dos.writeInt(n);//用数据流写入一个int类型的数值（n是int类型的）；
dos.writeUTF(str); //用数据流写入一个String类型的数据；
dos.writeDouble(3.15); //用数据流写入一个double类型的数据；
dos.writeChar('我'); //用数据流写入一个char类型的数据；
dos.writeBoolean(true); //用数据流写入一个布尔类型的数据；
//2.读数据；
InputStream is=new FileInputStream(new File("e:\f.data"));
DataInputStream dis=new DataInputStream(is);
int n1=dis.readInt();//用数据流读出刚才写入的int类型数据，赋给int类型变量；
String str1=dis.readUTF();//用数据流读出String类型的数据；
double d=dis.readDouble();//用数据流读出double类型的数据；
char c=dis.readChar();//用数据流读出char类型的数据；
boolean flag=dis.readBoolean();//用数据流读出布尔类型的数据；

    //打印输出用数据流读出来的数据；

System.out.println(n1);
System.out.println(str1);
System.out.println(d);
System.out.println©;
System.out.println(flag);
//关闭资源；
dis.close();
dos.close();
}
}

结果：
123456
尚学堂教育
3.15
我
true

数据流特点：
写入是什么类型的数据，读出是相应类型的数据；
要先写后读；用DataOutputStream流写，用DataInputStream流读；
读写顺序要一致，否则会报EOF异常；EOF:end of file;
数据流可以跨平台写入和读出，适合网路应用。

【上机】使用ObjectInputstream和ObjectOutputStream实现将某个对象存 储到硬盘上，然后再读到程序中。
见课堂实例。
中文乱码是怎么造成的?
字符流的读写根据需要设置编码方式,编码方式设置不当会出现中文乱码。

unicode字符集是几个字节表示一个字符?为什么需要utf-8?
Unicode字符集中2个字节表示一个字符。
序列化和反序列化指的是什么?
（1） 序列化：
将对象以byte流的形式写入到文件中->序列化；
将要被序列化的对象的类要实现Serializable接口：
publicclassUserimplements Serializable {
//略；
}
User实现了这个接口，代表User这个类的对象具有了将对象以byte流的形式写进文件的功能。

（2） 反序列化：
将文件中的数据以byte流的形式读到程序中来，依然是一个对象反序列化。

想序列化某个类的对象，该类必须实现sierializable接口吗?
要序化的对象必须实现Serializable接口，以启动序列化的功能。
说说sierializable接口的特点。

1. 需要被序列化的对象的类必须实现Serializable接口。
2. 给类加个序列化编号，即给类定义一个标记，如：
   public static final long serialVersionUID=1L;
   新的修改后的类还可以操作曾经序列化的对象。
   3、静态是不能被序列化的，
   序列化只能对堆中的对象进行序列化 ，不能对”方法区”中的对象进行序列化。
   4、不需要序列化的字段前加 transient,如：
   private transient String password;

transient的作用是？
不希望序列化的属性，可以添加transient关键字;
密码字段是非常敏感的字段，所在在序列化时，不允许写到文件:
private transient String password;
【上机】完成目录的copy代码(结合递归算法)
import java.io.;
/

• CopyDocJob定义了实际执行的任务，即

• 从源目录拷贝文件到目标目录
  /
  public class CopyDir2 {
  public static void main(String[] args) {
  try {
  copyDirectiory("d:/301sxt","d:/301sxt2");
  } catch (IOException e) {
  e.printStackTrace();
  }
  }
  /

  • 复制单个文件
  • @param sourceFile 源文件
  • @param targetFile 目标文件
  • @throws IOException
    /
    private static void copyFile(File sourceFile, File targetFile) throws IOException {
    BufferedInputStream inBuff = null;
    BufferedOutputStream outBuff = null;
    try {
    // 新建文件输入流
    inBuff = new BufferedInputStream(new FileInputStream(sourceFile));
    // 新建文件输出流
    outBuff=new BufferedOutputStream(new FileOutputStream(targetFile));
    // 缓冲数组
    byte[] b = new byte[1024 * 5];
    int len;
    while ((len = inBuff.read(b)) != -1) {
    outBuff.write(b, 0, len);
    }
    // 刷新此缓冲的输出流
    outBuff.flush();
    } finally {
    // 关闭流
    if (inBuff != null)
    inBuff.close();
    if (outBuff != null)
    outBuff.close();
    }
    }

  /

  • 复制目录
  • @param sourceDir 源目录
  • @param targetDir 目标目录
  • @throws IOException
    */
    private static void copyDirectiory(String sourceDir, String targetDir) throws IOException {
    // 检查源目录
    File fSourceDir = new File(sourceDir);
    if(!fSourceDir.exists() || !fSourceDir.isDirectory()){
    return;
    }
    //检查目标目录，如不存在则创建
    File fTargetDir = new File(targetDir);
    if(!fTargetDir.exists()){
    fTargetDir.mkdirs();
    }
    // 遍历源目录下的文件或目录
    File[] file = fSourceDir.listFiles();
    for (int i = 0; i < file.length; i++) {
    if (file[i].isFile()) {
    // 源文件
    File sourceFile = file[i];
    // 目标文件
    File targetFile = new File(fTargetDir, file[i].getName());
    copyFile(sourceFile, targetFile);
    }
    //递归复制子目录
    if (file[i].isDirectory()) {
    // 准备复制的源文件夹
    String subSourceDir = sourceDir + File.separator + file[i].getName();
    // 准备复制的目标文件夹
    String subTargetDir = targetDir + File.separator + file[i].getName();
    // 复制子目录
    copyDirectiory(subSourceDir, subTargetDir);
    }
    }
    }
    }

【上机】假设从入学开始所有书写的Java代码都在d:/sxtjava文件夹下，包括多
级子文件夹。使用IO流获取从入学开始，到目前为止已经写了多少行Java代码。
提示：获取d:/sxtjava文件夹及其子文件夹下的所有.java文件，使用readLine()读取其中每一行，每读取一行，行数加1。
public class TestCountDir {
private int count;
/
* 统计一个java文件的行数
/
private void countLine(File sourceFile) throws IOException {
BufferedReader br = null;
try {
// 新建文件输入流
br = new BufferedReader(new FileReader(sourceFile));
while(br.readLine()!=null){
count++;
//System.out.println(count);
}
} finally {
br.close();
}
}
/
* 统计一个目录下所有Java文件的行数
*/
private void countDir(String sourceDir) throws IOException {
// 检查源目录
File fSourceDir = new File(sourceDir);
if(!fSourceDir.exists() || !fSourceDir.isDirectory()){
System.out.println("源目录不存在");
return;
}
// 遍历目录下的文件或目录
File[] file = fSourceDir.listFiles();
for (int i = 0; i < file.length; i++) {
if (file[i].isFile()) {
if(file[i].getName().toLowerCase().endsWith(".java")){
// System.out.println(file[i].getName());
countLine(file[i]);
}
}
//递归统计代码行数
if (file[i].isDirectory()) {
// 准备统计的文件夹
String subSourceDir = sourceDir + File.separator + file[i].getName();
// 统计子目录
countDir(subSourceDir);
}
}
}
public static void main(String[] args) throws IOException {

    TestCountDir tcd = new TestCountDir();
    tcd.countDir("d:/sxtjava");
    System.out.println(tcd.count);
}

}

【上机】下载并自学apache commons中的IO工具包。
第十章 多线程
程序、进程、线程的区别是什么? 举个现实的例子说明。(网上查资料，跟老师的不一样)
程序（Program）：是一个指令的集合。程序不能独立执行，只有被加载到内存中，系统为它分配资源后才能执行。
进程（Process）：如上所述，一个执行中的程序称为进程。
进程是系统分配资源的独立单位，每个进程占有特定的地址空间。
程序是进程的静态文本描述，进程是程序在系统内顺序执行的动态活动。
线程（Thread）：是进程的“单一的连续控制流程“。
线程是CPU调度和分配的基本单位，是比进程更小的能独立运行的基本单位，也被称为轻量级的进程。
线程不能独立存在，必须依附于某个进程。一个进程可以包括多个并行的线程，一个线程肯定属于一个进程。Java虚拟机允许应用程序并发地执行多个线程。

    举例：如一个车间是一个程序，一个正在进行生产任务的车间是一个进程，车间内每个从事不同工作的工人是一个线程。

【上机】Java中通过哪些方式创建多线程类? 分别使用代码说明。并调用之。
自定义线程类继承Thread：
public class MyDefinedThread extends Thread{
//重写run()方法；
public void run(){
//把线程需要执行的任务写在run()方法里；
}

public static void main(String[] args){
MyDefinedThread mdt=new MyDefinedThread();
mdt.start(); //启动线程。
}
}
(2) 自定义类实现Runnable接口；
public class MyRunnable implements Runnable{
//实现run()方法；
public void run(){
//把线程需要执行的任务写在run()方法里；
}

public static void main(String[] args){
MyRunnable mr=new MyRunnable();
Thread th=new Thread(mr);//”mr”并不是一个线程对象，而是要作为参数传递到Thread的构造方法中；“th“才是一个线程对象。
th.start;//启动线程。
}
}
Thread类有没有实现Runnable接口?
有实现。
当调用一个线程对象的start方法后，线程马上进入运行状态吗?
不是，只是进入就绪（可运行）状态，等待分配CPU时间片。一旦得到CPU时间片，即进入运行状态。
下面的代码，实际上有几个线程在运行：
两个：线程t和main()方法（主线程）。

说说：sleep、yield、join方法的区别。
sleep():在指定时间内让线程暂停执行，进入阻塞状态。
在指定时间到达后进入就绪状态。线程调用sleep()方法时，释放CPU当不释放对象锁（如果持有某个对象的锁的话）。
join(): 当前线程等待调用此方法的线程执行结束再继续执行。如：在main方法中调用t.join(),那main方法在此时进入阻塞状态，一直等t线程执行完，main方法再恢复到就绪状态，准备继续执行。
yield(): 调用该方法的线程暂停一下，回到就绪状态。所以调用该方法的线程很可能进入就绪状态后马上又被执行。
为什么不推荐使用stop和destroy方法来结束线程的运行?
stop():此方法可以强行中止一个正在运行或挂起的线程。但stop方法不安全，就像强行切断计算机电源，而不是按正常程序关机。可能会产生不可预料的结果。举例来说：
当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，并抛出特殊的ThreadDeath()异常。这里的“立即”因为太“立即”了，假如一个线程正在执行：
synchronized void {
x = 3;
y = 4;
}
由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记 线程的stop方法，以后我们再也不要说“停止线程”了。

    destroy():该方法最初用于破坏该线程，但不作任何资源释放。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以 suspend() 方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。

【上机】写个代码说明，终止线程的典型方式。
当run()方法执行完后，线程就自动终止了。
但有些时候run()方法不会结束（如服务器端监听程序），或者其它需要用循环来处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）{……}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。下面通过例子来说明：

public class ThreadFlag extends Thread { public volatile boolean exit = false; public void run() { while (!exit); } public static void main(String[] args) throws Exception { ThreadFlag thread = new ThreadFlag(); thread.start(); sleep(5000); // 主线程延迟5秒 thread.exit = true; // 终止线程thread thread.join(); System.out.println("线程退出!"); } }

在上面代码中定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值。
A线程的优先级是10，B线程的优先级是1，那么当进行调度时一定会调用A吗?
不一定。线程优先级对于不同的线程调度器可能有不同的含义，可能并不是用户直观的推测。
【上机】模仿老师课堂例子，完成账户取钱的模拟操作代码。
synchronize修饰在方法前是什么意思?
一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
synchronize修饰的语句块，如下面的代码。是表示该代码块运行时必须获得 account对象的锁。如果没有获得，会有什么情况发生?
如果没有获得account对象的锁，就不能执行synchronize修饰的语句块，包括此语句块，还有其他需要获得此account对象锁才能执行的同步代码块和同步方法。

【上机】死锁是怎么造成的？用文字表达。再写一个代码示例。
过多的线程同步会引起死锁。如两个线程都在等待对方释放锁才能继续执行，有时会出现僵持局面：两个线程都持有对方需要的锁，而两个线程都需要对方释放锁了才能继续运行。举例来说：

我们先看看这样一个生活中的例子：在一条河上有一座桥，桥面较窄，只能容纳一辆汽车通过，无法让两辆汽车并行。如果有两辆汽车A和B分别由桥的两端驶上该桥，则对于A车来说，它走过桥面左面的一段路（即占有了桥的一部分资源），要想过桥还须等待B车让出右边的桥面，此时A车不能前进；对于B车来说，它走过桥面右边的一段路（即占有了桥的一部分资源），要想过桥还须等待A车让出左边的桥面，此时B车也不能前进。两边的车都不倒车，结果造成互相等待对方让出桥面，但是谁也不让路，就会无休止地等下去。这种现象就是死锁。死锁是程序运行时出现的一种问题，是需要避免的。

代码示例：

publicclass DeadLock{
Object A=new Object();
Object B=new Object();

publicvoid toEast(){
    synchronized(A){
        synchronized(B){
            System.out.println("向东行驶。");
        }
    }
}
    publicvoid toWest(){
    synchronized(B){
        synchronized(A){
            System.out.println("向西行驶。");
        }
    }
}

}
publicclass ToEastThread extends Thread {
DeadLock d=new DeadLock();
public ToEastThread(DeadLock d) {
super();
this.d = d;
}
publicvoid run(){
d.toEast();
}
}
publicclass ToWestThread extends Thread {
DeadLock d=new DeadLock();
public ToWestThread(DeadLock d) {
super();
this.d = d;
}
publicvoid run(){
d.toWest();
}
}
publicclass Test1 {
publicstaticvoid main(String[] args) {
DeadLock d=new DeadLock();
ToEastThread et=new ToEastThread(d);
ToWestThread wt=new ToWestThread(d);
et.start();
wt.start();
}
}
使用Timer和TimerTask实现定时执行，定时在每天下午17：00执行。

知识点简介：
Timer：定时器，实际上是个线程，定时调度所拥有的TimerTasks。
TimerTask：一个拥有run方法的类，需要定时执行的代码放到run方法体内。 TimerTask一般是以匿名类的方式创建。
语法简介：
java.util.Timer timer = new java.util.Timer(true);
// true 说明这个timer以daemon方式运行（优先级低，
// 程序结束timer也自动结束），注意，javax.swing
// 包中也有一个Timer类，如果import中用到swing包，
// 要注意名字的冲突。
TimerTask task = new TimerTask() {
public void run() {
… //每次需要执行的代码放到这里面。
}
};
用法简介：
//以下是几种调度task的方法：
timer.schedule(task, time);
// time为Date类型：在指定时间执行一次。
timer.schedule(task, firstTime, period);
// firstTime为Date类型,period为long
// 从firstTime时刻开始，每隔period毫秒执行一次。
timer.schedule(task, delay)
// delay 为long类型：从现在起过delay毫秒执行一次
timer.schedule(task, delay, period)
// delay为long,period为long：从现在起过delay毫秒以后，每隔period
// 毫秒执行一次。
举例：
import java.util.TimerTask;
publicclass TimePrintTask extends TimerTask {
int i=1;
publicvoid run(){
System.out.println(i);
i++;
}
}
publicclass Test {
publicstaticvoid main(String[] args) {
Timer timer=new Timer();
//timer.schedule(new TimePrintTask(), 1000, 500);
DateFormat df=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SS");
Date firstDate=null;
try {
firstDate=df.parse("²⁰¹⁶⁄₁₂/09 17:00:00 00");
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
timer.schedule(new TimePrintTask(),firstDate , 1000)；
}
}

wait方法被调用时，所在线程是否会释放所持有的锁资源? sleep方法呢?
wait:释放CPU，释放锁；
sleep：释放CPU，不释放锁。
wait、notify、notifyAll是在Object类中定义的方法吗？作用分别是什么？wait(),notify(),notifyAll()不属于Thread类,而是属于Object类,也就是说每个对象都有wait(),notify(),notifyAll()的功能。因为每个对像都有锁,锁是每个对像的基础,而wait(),notify(),notifyAll()都是跟锁有关的方法。

三个方法的作用分别是：
wait：导致当前线程等待，进入阻塞状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。当前线程必须拥有此对象监视器（对象锁）。该线程释放对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行.
notify：唤醒在此对象监视器（对象锁）上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。此方法只应由作为此对象监视器的所有者的线程来调用.
"当前线程必须拥有此对象监视器"与"此方法只应由作为此对象监视器的所有者的线程来调用"说明wait方法与notify方法必须在同步块内执行,即synchronized(obj之内).
notifyAll: 唤醒在此对象监视器（对象锁）上等待的所有线程。
notify是唤醒所在对象wait pool中的第一个线程吗？
不是。调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择。
【上机】使用线程通信实现生产者-消费者问题。
详见课堂实例。

第十一章 网络编程
什么是计算机网络？网络的主要类型有哪些；
计算机网络是将不同地理位置的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

    网络的主要类型：

按计算机网络的地理覆盖范围分：
局域网（Local Area Network，LAN）：
地理范围一般在10km以内，属于一个组织，一个单位或一个部门所有。如：一个企业，一所学校，一座大楼，一间实验室等。
这种网络一般不对外提供公共服务，管理方便，安全保密性好。
组建方便，投资少，见效快，使用灵活，是计算机网络中发展最快，应用最普遍的计算机网络。
与广域网相比，传输速率快，通常100Mbps以上；误码率低。
城域网（Metropolitan Area Network，MAN）：
介于局域网和广域网之间，地理范围覆盖几十km到几百km不等，可能是一个地区或一个城市。
广域网（Wide Area Network，WAN）：
地理范围一般从几十km到几万km不等，小到一个地区，一个城市，大到一个国家，几个国家乃至全世界。
提供大范围的公共服务。因特网就是典型的广域网。
与局域网相比，广域网投资大，安全保密性差，传输速率慢,通常为64kbps,2Mbps,10Mbps;误码率高。
按计算机网络的拓扑结构分：拓扑结构是数学上的一个名词，从英文Topology音译过来的。在这里，指的是网络传输介质和节点的连接形式，即线路构成的几何形状。
总线型：
该结构采用一条公共总线作为传输介质，每台计算机通过相应的硬件接口入网。信号沿总线进行广播式传送。
是典型的共享传输介质的网络。从信源所发的信息会传送到介质长度所及之处，被其他所有站点看到。如果有两个以上的节点同时发送数据，可能会造成冲突，就像公路上的两车相撞一样。
优点：布线容易；增删容易；节约电缆；
缺点：
任何两个站点传送信息都要经过总线，总线称为传输瓶颈；当计算机站点多时，容易造成信息阻塞，传递不畅。
一台计算机接入总线的接口发生故障，会造成整个网络瘫痪。
当网络发生故障时，故障诊断和隔离困难。

星型：由一台中央节点和周围的从节点组成。中央节点和从节点可以直接通信，而从节点必须经过中央节点转接才能通信。
优点：
I 可靠性高。每台计算机及其接口的故障不会影响其他计算机，不会影响整个网络，也不会造成网络瘫痪。
II 故障诊断和隔离容易，网络容易管理和维护。
III 可扩性好，配置灵活。增删改一个站点容易实现，和其他计算机没有关系。
IV 传输速率高。每个节点独占一条线路，消除了信息阻塞的情况。而总线和环形网络的瓶颈都在线路上。

缺点：
I 线缆使用量大。
II 布线、安装工作量大。
III 网络可靠性依赖于中央节点。如交换机或集线器选择不当，发生故障会造成全网瘫痪。
环型：
计算机通过硬件接口入网，这些接口收尾相连成一条链路。信息传送也是广播式的，沿着一个方向（如逆时针方向）单向逐点传送。
优点：
I 点到点且沿一个方向单向传输，非常适合用光纤作为传输介质。
II 传输距离远，适合做主干网。
III 故障诊断容易定位。
IV 初始安装容易，线缆用量少。环形线路也是一条总线，只是首尾封闭。

按传输介质分：
有线网络：
同轴电缆：成本低，安装方便，但传输率低，抗干扰能力一般，传输距离短；
双绞线：组建局域网时常用，优缺点类似于同轴电缆。
光纤：主要用于网络的主干部分，其特点是成本高，安装技术要求高，传输距离长，传输率高，抗干扰能力强，且不会受到电子监听设备的监听等，是组建高安全性网络的理想选择。

无线网络：
红外线；
微波；
无线电；

常见的网络分层模型有哪两个？哪个更流行？为什么？
OSI/ISO 参考模型:
OSI:(Open System Interconnection),开放式网络互连；
ISO:(International Standard Organization)，国际标准化组织；
此模型是由国际标准化组织提出的一种网络互连模型。
OSI参考模型把网络模型分成7层，每一层为上一层提供服务，并为其上一层提供一个访问接口或界面。
TCP/IP协议栈：4层网络模型。OSI参考模型设计得过于庞大、复杂，不易被付诸应用。相比之下，由技术人员自己开发的TCP/IP协议栈获得了更为广泛的应用。

TCP的全称是?
Transfer Control Protocol。
UDP的全称是?
User Datagram Protocol。
请说出TCP和UDP的区别?
TCP：一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议 。

特点：
面向连接；
点到点的通信；
高可靠性；
占用系统资源多、效率低；

UDP：一种无连接的、提供面向事务的简单不可靠信息传送服务的传输层通信协议。

特点:
非面向连接
传输不可靠，可能丢失
发送不管对方是否准备好，接收方收到也不确认
可以广播发送
非常简单的协议，开销小

通过类比打电话，详细描述TCP三次握手机制。
第一次握手：客户端发送连接请求给服务器端，等候服务器端确认；
第二次握手：服务器端收到客户端发来的请求，向客户端发送确认连接信息；
第三次握手：客户端接到服务器端发送来的确认连接信息，也要向服务器端再发送一次确认连接信息。至此三次握手完成。客户端和服务器端进入准备传送数据状态。

     以打电话为例：
     A拨电话给B：
     B 接起电话：喂？能听到我吗？
     A 回答：可以听到。
     然后A和B开始正式通话。

IP的全称是? IP的作用是?
IP：Internet Protocol address，互联网协议地址。IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址。
IP的作用：用来标志网络中的一个通信实体的地址。通信实体可以是计算机，路由器等。

IPV4为什么会发生资源枯竭的问题?
IPV4规定IP地址长度为32位, 即有2^32-1个地址(大约40亿多一点)；而随着互联网的迅速发展，这个数量很可能满足不了未来的需求。
解决：IPv6。IP地址的长度为128，即有2^128-1个地址。
为什么需要端口?端口是真实存在的还是虚拟的概念?
IP地址用来标志一台计算机，但是一台计算机上可能提供多种网络应用程序，使用端口来区分这些应用程序。
端口是虚拟的概念，并不是说在主机上真的有若干个端口。通过端口，可以在一个主机上运行多个网络应用程序。
端口范围0—65535,16位整数。

Java中，端口使用两个字节表示，可以表示多少个端口? UDP和TCP端口是各自独立的吗?
端口范围0—65535,16位整数。
由于TCP/IP传输层的两个协议TCP和UDP是完全独立的两个软件模块，因此各自的端口号也相互独立，如TCP有一个255号端口，UDP也可以有一个255号端口，二者并不冲突。

InetAddress和InetSocketAddress都封装了哪些信息? 他们两的区别是?
InetAddress：封装计算机的IP地址 ,没有端口。
InetSocketAddress：包含IP地址和端口信息，用于Socket通信的。

URL类有什么作用?
URL：Uniform Resource Locator，统一资源定位器；俗称“网址”，如：
"http://www.baidu.com:80/index.html#aa?cansu=bjsxt“
由4部分组成：
协议： http;
存放资源的主机域名：www.baidu.com;
端口号:80;
资源文件名: index.html#aa?cansu=bjsxt;

URL是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。

【上机】将网络上一张图片或一个mp3或一个视频的信息保存到本地。
查资料了解，SNS是什么？
如何理解Socket的含义?
所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

我们开发的网络应用程序位于应用层，TCP和UDP属于传输层协议，在应用层如何使用传输层的服务呢？在应用层和传输层之间，则是使用套接字来进行分离。

套接字就像是传输层为应用层开的一个小口，应用程序通过这个小口向远程发送数据，或者接收远程发来的数据；而这个小口以内，也就是数据进入这个口之后，或者数据从这个口出来之前，是不知道也不需要知道的，也不会关心它如何传输，这属于网络其它层次的工作。

Socket实际是传输层供给应用层的编程接口。传输层则在网络层的基础上提供进程到进程问的逻辑通道，而应用层的进程则利用传输层向另一台主机的某一进程通信。Socket就是应用层与传输层之间的桥梁。

使用Socket编程可以开发客户机和服务器应用程序，可以在本地网络上进行通信，也可通过Internet在全球范围内通信。

生活案例1如果你想写封邮件发给远方的朋友，如何写信、将信打包，属于应用层。信怎么写，怎么打包完全由我们做主；而当我们将信投入邮筒时，邮筒的那个口就是套接字，在进入套接字之后，就是传输层、网络层等（邮局、公路交管或者航线等）其它层次的工作了。我们从来不会去关心信是如何从西安发往北京的，我们只知道写好了投入邮筒就OK了。
生活案例2：可以把Socket比作是一个港口码头，应用程序只要将数据交给Socket，就算完成了数据的发送，具体细节由Socket来完成，细节不必了解。同理，对于接收方，应用程序也要创建一个码头，等待数据的到达，并获取数据。

基于TCP的Socket网络编程的主要步骤是什么？
Java分别为TCP和UDP 两种通信协议提供了相应的Socket编程类，这些类存放在java.net包中。与TCP对应的是服务器的ServerSocket和客户端的Socket，与UDP对应的是DatagramSocket。
基于TCP创建的套接字可以叫做流套接字，服务器端相当于一个监听器，用来监听端口。 服务器与客服端之间的通讯都是输入输出流来实现的。基于UDP的套接字就是数据报套接字，• 两个都要先构造好相应的数据包。

基于TCP协议的Socket编程的主要步骤
服务器端（server）：

1. 构建一个ServerSocket实例，指定本地的端口。这个socket就是用来监听指定端口的连接请求的。
   2.重复如下几个步骤：
   a. 调用socket的accept()方法来获得下面客户端的连接请求。通过accept()方法返回的socket实例，建立了一个和客户端的新连接。
   b.通过这个返回的socket实例获取InputStream和OutputStream,可以通过这两个stream来分别读和写数据。
   c.结束的时候调用socket实例的close()方法关闭socket连接。

客户端（client）：
1.构建Socket实例，通过指定的远程服务器地址和端口来建立连接。
2.通过Socket实例包含的InputStream和OutputStream来进行数据的读写。
3.操作结束后调用socket实例的close方法，关闭。

【上机】写出建立TCP服务器ServerSocket的代码。并说明accept方法有什么特点?
//服务器监听请求；
ServerSocket ss=new ServerSocket(9999);
//接受请求：创建了socket;
Socket socket=ss.accept();

    详见课上示例。

【上机】写出建立TCP客户端Socket的代码。并说明建立Socket后，通过什么方法Socket获得流对象?
//客户端向服务器端发送请求；
Socket socket=new Socket("127.0.0.1",9999);
//建好连接后，开始传输数据；
OutputStream os=socket.getOutputStream();

    详见课上示例。

【上机】完成老师课堂上的代码(最简单的服务器客户端代码。可双向交流的服务 器客户端代码。本作业可课后完成)
详见课上示例。
基于UDP的Socket网络编程的主要步骤是什么？
基于UDP协议的Socket编程的主要步骤
服务器端（server）：

1. 构造DatagramSocket实例，指定本地端口。
2. 通过DatagramSocket实例的receive方法接收DatagramPacket.DatagramPacket中间就包含了通信的内容。
3. 通过DatagramSocket的send和receive方法来收和发DatagramPacket.
   客户端（client）：
4. 构造DatagramSocket实例。
   2.通过DatagramSocket实例的send和receive方法发送DatagramPacket报文。
   3.结束后，调用DatagramSocket的close方法关闭。

【上机】使用UDP的方式，完成对象的传递。
(1)客户端向服务器端传送对象信息；
DatagramSocket ds=new DatagramSocket(9999);
//构建数据包；
Scanner input=new Scanner(System.in);
System.out.println("请输入用户名：");
String username=input.nextLine();
System.out.println("请输入密码：");
String password=input.nextLine();
//事先要创建好User类；
User user=new User(username,password);
//字节流；在内存开辟缓冲区；
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(user);

    byte buf[]=baos.toByteArray();
    DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("127.0.0.1"), 8888);//DatagramPacket只用byte[]数组;
         //发送数据；
    ds.send(dp);

(2)服务器端从客户端接收对象信息；
//服务器定义DatagramSocket以接收数据；
DatagramSocket ds=new DatagramSocket(8888);

    //定义一个数据包来接收数据；
    //数据包里是byte数组，所以还得定义一个byte数组；
    byte buf[]=new byte[1024];
    DatagramPacket dp=new DatagramPacket(buf, buf.length);
     //接收客户端发过来的数据；
    ds.receive(dp);</p>

<pre><code>//用字节流和对象流读取对象信息；
ByteArrayInputStream bais=new ByteArrayInputStream(buf);
ObjectInputStream ois=new ObjectInputStream(bais);

User user=(User)ois.readObject();
System.out.println(user);

详见课上示例。
项目阶段课程5
【项目】自定义聊天室/自定义web服务器Tomcat
练习目标：
按照面向对象的思维方式写出相关项目
熟练使用容器、数组、IO、多线程、网络通信相关技术
要求：
结合容器(将Socket对象放到容器中)，写出较完整的聊天室程序
扩展作业(自由思考、自由查找资料。不讲解)：
每三人组成临时小组，选定课题。（飞鸽传书、视频广播、迅雷、聊天室系统等，或自己向老师提出课题）
录制讲解自己完成的项目
附：内部类专题(自学)
方法内部能不能定义类?
可以，是方法内部类。
请说明定义内部类的方式，并说明适用于什么情况？
成员内部类：定义在另一个类(外部类)的内部，而且与成员方法和属性平级，属于类的一个成员，可以用private,默认，protected,public四个访问修饰符修饰。
外部类无法直接访问成员内部类的方法和属性，需要通过内部类的一个实例来访问。
调用方式：外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数)。
静态内部类：被static修饰的成员内部类叫静态内部类。
调用方式：外部类名.内部类名 实例名 = new 外部类名.内部类名(参数)。
局部内部类：定义在代码块或方法体内的类叫局部内部类。
局部内部类只能在代码块和方法体内使用（如创建对象和使用类对象等）。
匿名内部类：特殊的局部内部类。
必须继承一个类（抽象的、非抽象的都可以）或者实现一个接口。如果父类（或者父接口）是抽象类，则匿名内部类必须实现其所有抽象方法。
只能使用一次，创建实例之后，类定义会立即消失。创建：父类（接口） 实例名 = new 父类（）{
//匿名内部类需要实现的功能。
}
匿名内部类不能再是抽象类，因为匿名内部类在定义之后，会立即创建一个实例。
匿名内部类不能定义构造方法，匿名内部类没有类名，无法定义构造方法，但是，匿名内部类拥有与父类相同的所有构造方法。
可以定义代码块，用于实例的初始化。

普通成员内部类能不能直接访问外部类的普通成员?
普通成员内部类可以直接访问外部类的成员,如上例：内部类中的innerMethod()方法：
public void innerMethod(){
int num = 40;
System.out.println(OuterClass.this.num);//外部类的成员变量；
System.out.println(this.num);//30
System.out.println(num);//40
System.out.println(name);
}

【上机】写出：调用普通成员内部类的典型方式。
创建成员内部类的实例使用：外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数)。

创建包含内部类的外部类：
public class OuterClass {
//成员变量
private int num=20;
private String name;
//构造方法
public OuterClass() {
super();
}
public OuterClass(String name) {
super();
this.name = name;
}
//成员方法
public void execInnerClass(){
this.name = "abc";
InnerClass ic = new InnerClass();
//ic.num=30;
ic.innerMethod();
}
//内部类
public class InnerClass{
private int num=30;
public InnerClass() {
super();
}
public InnerClass(int num) {
super();
this.num = num;
}
public void innerMethod(){
int num = 40;
System.out.println(OuterClass.this.num);//20
System.out.println(this.num);//30
System.out.println(num);//40
System.out.println(name);
}
}
}

调用成员内部类：两种常用方法；
先创建外部类对象，由外部类对象创建内部类对象
格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
OuterClass oc2 = new OuterClass();
OuterClass.InnerClass ic = oc2.new InnerClass();

创建外部类对象，外部类的方法操作内部类
OuterClass oc = new OuterClass();
oc.execInnerClass();

静态成员内部类能不能直接访问外部类普通成员?能不能访问外部类静态成员?
静态内部类
1.不能访问外部类的非静态成员（变量或者方法）。
2.可以访问外部类的静态成员。
【上机】写出：调用静态内部类的典型方式。
创建包含静态内部类的外部类：
public class OuterClass{
//成员变量
private static int num=20;
private static String name;
//构造方法
public OuterClass() {
super();
}
public OuterClass(String name) {
super();
this.name = name;
}
//成员方法
public void execInnerClass(){
this.name = "abc";
InnerClass ic = new InnerClass();
//ic.num=30;
ic.innerMethod();
}
//内部类
public static class InnerClass{
private int num=30;
public InnerClass() {
super();
}
public InnerClass(int num) {
super();
this.num = num;
}
public void innerMethod(){
int num = 40;
//System.out.println(OuterClass.this.num);//20
System.out.println(OuterClass.num);
System.out.println(this.num);//30
System.out.println(num);//40
System.out.println(name);
}
}
}
（2）静态内部类对象可以直接创建实例，不必依附于外部类实例：
OuterClass.InnerClass ic = new OuterClass.InnerClass();
格式：外部类名.内部类名对象名 = new 外部类名.内部类名();

什么时候会使用匿名内部类?
有些情况下，某些类创建对象一次后再也不使用了。这种情况下就可以不提供有名字的类，而是使用匿名内部类。
线程池专题(自学)
什么是线程池?
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单 元的闲置时间，增加处理器单元的吞吐能力。假设一个服务器完成一项任务所需时间为：T1—创建线程时间，T2—在线程中执行任务的时间，T3—销毁线程时间。如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。一个线程池包括以下四个基本组成部分：1. 线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池， 销毁线程池，添加新任务；2. 工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可 以循环的执行任务；3. 任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行， 它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；4. 任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。 线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性 能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的 时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一 个例子：假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完 成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程 的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般 线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000 而在处理请求时浪费时间，从而提高效率。
线程池的好处有哪些？
减少在创建和销毁线程上所花的时间以及系统资源的开销；
如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。
如何创建一个线程池，常用输入参数的含义？

1. Executors.newCachedThreadPool()
   Executors.newCachedThreadPool(ThreadFactory threadFactory)
   newCachedThreadPool创建一个可缓存的线程池。
   这种类型的线程池特点是：
   1)工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAXVALUE), 这样可灵活的往线程池中添加线程。
   2)如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
   3)参数threadFactory - 表示用来创建线程的线程工厂，在需要时使用提供的 ThreadFactory 创建新线程。

2.newFixedThreadPool(int nThreads)
newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
newFixedThreadPool创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
参数nThreads - 表示池中的线程数。
参数threadFactory - 表示用来创建线程的线程工厂，在需要时使用提供的 ThreadFactory 创建新线程。
3.newSingleThreadExecutor()
newSingleThreadExecutor(ThreadFactory threadFactory)
newSingleThreadExecutor创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。
参数threadFactory - 表示用来创建线程的线程工厂，在需要时使用提供的 ThreadFactory 创建新线程。
4.newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
newScheduleThreadPool创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。
参数corePoolSize - 核心池的大小
参数threadFactory - 表示用来创建线程的线程工厂，在需要时使用提供的 ThreadFactory 创建新线程。
分析线程池的主要工作流程。
如何监控线程池？
【上机】查资料，完成一个简单的自定义的线程池，对线程池底层原理更加熟悉。
【上机】完成课上线程池调用测试代码。
附3：设计模式初步专题(自学,适合初级.更深入的会在框架阶段)
什么是设计模式?
设计模式是一套被反复使用的、多数人知晓、经过分类编目的优秀代码设计经验的总结。特定环境下特定问题的处理方法。
重用设计和代码 重用设计比重用代码更有意义，自动带来代码重用
提高扩展性 大量使用面向接口编程，预留扩展插槽，新的功能或特性很容易加入到系统中来。
提高灵活性 通过组合提高灵活性，可允许代码修改平稳发生，对一处修改不会波及到其他模块。
提高开发效率 正确使用设计模式，可以节省大量的时间。

设计模式的优点有哪些？
23种经典设计模式都有哪些，如何分类?

面向对象的设计原则有哪些？
面向对象设计原则是面向对象设计的基石，面向对象设计质量的依据和保障，设计模式是面向对象设计原则的经典应用。
单一职责原则 ：SRP
开闭原则：OCP
里氏替代原则：LSP
依赖注入原则：DIP
接口分离原则：ISP
迪米特原则：LOD
组合/聚合复用原则：CARP
开闭原则具有理想主义色彩，它是面向对象设计的终极目标。其它设计原则都可以看作是开闭原则的实现手段或方法。
开闭原则的含义和实现。
依赖注入原则的含义和实现。
【上机】使用简单工厂模式实现可以进行四则运算的运算器
【上机】使用工厂方法模式完善可以进行四则运算的运算器
【上机】写出饿汉式、懒汉式的单例模式。
结合Java IO流体系说明装饰模式。
java IO中需要完成对不同输入输出源的操作，如果单纯的使用继承这一方式，无疑需要很多的类。比如说，我们操作文件需要一个类，实现文件的字节读取需要一个类，实现文件的字符读取又需要一个类….依次类推每个特定的操作都需要一个特定的类。这无疑会导致大量的IO继承类的出现。显然对于编程是很不利的。
而使用装饰模式则可以很好的解决这一问题，在装饰模式中：节点流（如FileInputStream）直接与输入源交互，之后通过过滤流（FilterInputStream）进行装饰，这样获得的io对象便具有某几个的功能，很好的拓展了IO的功能。

结合InputStreamReader类说明适配器模式。
请选择一个对你所熟悉的一个设计模式进行介绍。

XML技术
用自己的语言说出，为什么需要XML?
XML提供了一种比较简单的描述内容的方法，而且这种方法能表述列表、树等常见的数据结构，可扩展性好。XML使用纯文本方法书写，人们可以读懂内容，也可以自行修改里面的内容。XML是树形的结构，关于树，有非常非常多很成熟的算法进行描述、操作、生成、分析，使得XML描述的数据可以很方便的生成和处理。
用自己的话描述XML有什么作用？
同上题。
XML文件的基本语法要求有哪些？
格式良好的XML文档需要满足：
必须有XML文档的声明语句；
必须有且仅有一个根元素；
标签成对出现；
标签名称大小写敏感；
属性值用双引号；
元素正确嵌套。
下面的XML代码有什么问题,请指出：
没有xml文档声明，如：
没有根元素；
属性值没有双引号，朱重八；
标签名称大小写敏感, 朱元璋,起始标签和结束标签大小写一致；

【上机】完成课堂代码：

【上机】如下信息，能不能用JSON来表示？能不能用XML表示？请写出代码。
“我叫高小七，今年18了，我喜欢如花姑娘，也喜欢我的宠物旺财”


高小七
18
如花姑娘

旺财

【上机】CDATA有什么作用?写出测试代码
CDATA的作用：XML文档中的所有文本均会被解析器解析，只有CDATA区段中的文本会被解析器忽略。
实例：

     xml解析器通常会解析xml文档中的所有文本。
     当某个xml元素被解析时，其标签之间的文本也会被解析，如：

This text is also parsed
解析器之所以这么做是因为 XML 元素可包含其他元素，就像这个实例中，其中的 元素包含着另外的两个元素（first 和 last）：
BillGates
而解析器会把它分解为像这样的子元素：
BillGates< /name>
但是,在实际应用中有这样一种情形：“name”标签之间的内容不需要被解析成子元素,而是整体作为“name”标签的内容，也就是“name”标签的字符数据，这个时候，就需要加CDATA标记，如下：

BillGates
]]>< /name>
这样”name”之间的内容就不会被解析了（虽然它包含<,>等标签语法），而是全部当作字符（文本）数据来处理。CDATA表示“字符数据”（CharacterData）。

dtd技术有什么作用? schema技术什么作用?二者之间有什么关系?
在xml技术里，我们可以编写一个文档来约束某一个xml文档的书写规范，如一个xml文档要包含哪些元素，元素与元素之间的嵌套关系，某些元素必须具备哪些属性等，这称为xml约束。

    常用的xml约束技术有两种：dtd和schema。
    dtd:document type definition, 文档类型定义。近几年来XML技术领域所使用的最广泛的一种模式。但是它有其局限性：不能完全满足XML自动化处理的要求，例如不能很好实现应用程序不同模块间的相互协调，缺乏对文档结构、属性、数据类型等约束的足够描述等等。所以W3C于2001年5月正式推荐XML Schema为XML 的标准模式。显然，W3C希望以XML Schema来作为XML模式描述语言的主流，并逐渐代替XML DTD。XML Schema与XML DTD相比到底有哪些优势呢？

DTD 的局限性 DTD不遵守XML语法（写XML文档实例时候用一种语法，写DTD的时候用另外一种语法） DTD数据类型有限（与数据库数据类型不一致） DTD不可扩展 DTD不支持命名空间（命名冲突）

Schema的新特性 Schema基于XML语法 Schema可以用能处理XML文档的工具处理 Schema大大扩充了数据类型，可以自定义数据类型 Schema支持元素的继承Schema支持属性组
Schema支持命名空间（命名冲突）

xsl技术是做什么的?
XSL（eXtensible Stylesheet Language）是可扩展样式表语言的外语缩写，是一种用于以可读格式呈现 XML（标准通用标记语言的子集）数据的语言。
XML解析中，请说出DOM和SAX的区别。
DOM:
基于XML树结构
比较耗资源
适用于多次访问XML

SAX:
基于事件
消耗资源小
适用于数据量较大的XML

【上机】使用JDOM解析XML文档。参考老师课堂代码。
JDOM是一种解析XML的Java工具包。
JDOM和DOM的区别：
DOM适合于当今流行的各种语言，包括Java,JavaScripte,VB,VBScript，Perl,C,C++等。它了为HTML和XML文档提供了一个可应用于不同平台的编程接口。W3C DOM的最新信息可从http://www.w3.org/TR2001/WD-DOM-Lever-3-Core-20010913查阅。

DOM的设计为了适用于不同的语言，它保留了不同语言中非常相似的API。但是它并不适合于Java编程者的习惯。而JDOM作为一种轻量级API被制定，它最核心的要求是以Java为中心，只适合于Java语言，它遵循DOM的接口主要规则，除去了DOM中为了兼容各语言而与Java习惯的不同。

代码示例：
要处理的XML文档：




9.6



9.6



38.9


import java.io.File;
import java.io.IOException;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
public class JDOMParse {
public static void main(String[] args) throws JDOMException, IOException {
//使用JDOM首先要指定使用什么解析器;
SAXBuilder sb=new SAXBuilder();
File file=new File("e:\books.xml");
//得到Document，我们以后要进行的所有操作都是对这个Document操作的：这个//Document类是org.jdom2.Document;
Document document=sb.build(file);
//得到根元素;在JDOM中所有的节点都是一个org.jdom.Element类，当然他的子节点
//也是一个org.jdom.Element类;
Element root=document.getRootElement();
//得到元素（节点）的集合;这表示得到“books”元素的所在名称为“book”的元素，
//并把这些元素都放到一个List集合中;
List bookList=root.getChildren("book");
//遍历List集合;
for(int i=0;i Element book=(Element)bookList.get(i);
//取得元素的子元素的值：
String title=book.getChildText("title");
String price=book.getChildText("price");
System.out.println("第"+(i+1)+"本书："+title+""+price);
}
}
}
【上机】使用XPATH读取XML文档，测试各种XPATH。

XPath(XML Path Language)即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言。XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。

代码示例：
要处理的XML文档：




9.6



9.6



38.9


public class XPathTest {
public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException, TransformerException, XPathExpressionException {
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
DocumentBuilder db=dbf.newDocumentBuilder();
Document document=db.parse("e:\books.xml");
// 创建XPath对象;
XPath xPath=XPathFactory.newInstance().newXPath();
//获取根结点；
Node root=(Node)xPath.evaluate("//", document,XPathConstants.NODE);
System.out.println(root);
System.out.println(root.getNodeName());
//获取子元素并打印；
NodeList nodeList=(NodeList)xPath.evaluate("/books/", document, XPathConstants.NODESET);
for(int i=0;i System.out.println(nodeList.item(i).getNodeName());
}

    //只获取元素名称为"title"的元素；
    NodeList nodeList1=(NodeList)xPath.evaluate("//<em>[name()='title']", document, XPathConstants.NODESET);
for(int i=0;i<nodeList1.getLength();i++){
System.out.println(nodeList1.item(i).getNodeName()+""+nodeList1.item(i).getTextContent());
    }
    //获取含有子元素的元素；
    NodeList nodeList2 = (NodeList) xPath.evaluate("//</em>[<em>]", document,XPathConstants.NODESET);
    for (int i = 0; i < nodeList2.getLength(); i++) {
        System.out.println(nodeList2.item(i).getNodeName());
    }
    //获取指定层级的元素；
    NodeList nodeList3 = (NodeList) xPath.evaluate("/</em>/<em>/</em>", document,XPathConstants.NODESET);
    for (int i = 0; i < nodeList3.getLength(); i++) {
        System.out.println(nodeList3.item(i).getNodeName());
    }
}

XPath非常类似对数据库操作的SQL语言，或者说JQuery，它可以方便开发者抓起文档中需要的东西。
注：以上代码只是简单实例，详细学习请参照API。

【上机】jQuery中，如何解析xml文档。建立项目，测试之。

反射
什么情况下需要使用反射？
在编译时无法知道该对象或类属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息。此时用反射。
Class类的作用及其主要功能？
我们说类是对象的设计图，像User类，Person类，Student类，每个类可以创建多个对象。而Class类是谁的设计图呢？Class类是类的设计图？也就是说，User类，Person类，Student类等每个类都是一个Class类的实例，在运行时都对应着一个Class对象。
Class类提供了很多方法，比如反射技术常用到的Class.forName("包.类（如User类）");这样可以获取User类的Class对象。通过这个Class对象，我们可以调用User类的方法，属性，构造方法等。
如何使用反射创建一个对象？
方法一：使用Class的newInstance()方法，仅适用于无参构造方法；
示例代码：
Class clazz=(Class)Class.forName("cn.bjsxt.bean.User");
User u=clazz.newInstance();

方法二：调用Constructor的newInstance()方法，适用所有构造方法；
示例代码：
Class clazz=(Class)Class.forName("cn.bjsxt.bean.User");
Constructor cons = clazz.getConstructor(int.class,int.class, String.class,String.class );
User u= cons.newInstance( 1001,19,"王一一","男");
如何使用反射操作属性？
操作属性基本步骤：
通过Class对象获取Field（属性）对象；
调用Field对象的方法操作属性；

代码示例：
Class clazz=(Class)Class.forName("cn.bjsxt.bean.User");

//获得User类里属性名为”name”的属性并将其封装成一个Field对象name，接下来可//以用name调用Field的方法来操作属性；（略）
Field name=clazz.getField(“name”);

通过Class对象获得属性的方法有：
获取public的属性:object.getFields()
获取所有的属性: object.getDeclaredFields()
根据属性名称获取public的属性信息: object.getField(“sex”);
根据属性名称获取属性的信息:object.getDeclaredField(“name”);

如何使用反射执行方法？
调用方法基本步骤：
1.通过Class对象获取Method 对象；
2.调用Method对象的invoke()方法；

代码示例：
Class clazz=(Class)Class.forName("cn.bjsxt.bean.User");
User u=clazz.newInstance();
Method m2=clazz.getDeclaredMethod("show", String.class);
Object o=m2.invoke(u, "大家好");
System.out.println(o);

反射的优缺点有哪些？
优点：
反射提高了Java程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提前硬编码目标类。
反射是其它一些常用语言，如C、C++、Fortran 或者Pascal等都不具备的。
Java反射技术应用领域很广，如软件测试、 EJB、JavaBean等。
许多流行的开源框架例如Struts、Hibernate、Spring在实现过程中都采用了该技术。

缺点：
性能问题:
使用反射基本上是一种解释操作，字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。
使用反射会模糊程序内部逻辑:
程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。
【上机】使用反射模拟请求调用不同的Servlet实例。
正则表达式(自学)
正则表达式是用来做什么的?用自己的话描述。
正则表达式是用来操作字符串的，即用一些特定的符号来表示一些代码操作，从而简化对字符串的复杂操作。换句话说，用一个“字符串”来描述一个特征，然后去验证另一个“字符串”是否符合这个特征。
说出下面规则的含义：
\d,\w,\s,.,[1234],[^a-f],{},?,+,,\b
\d : 数字：[0-9];
\w: 单词字符：[a-zA-Z_0-9];
\s: 空白字符：[ \t\n\x0B\f\r];空格、水平制表符、换行、垂直制表符、换页、回车等。
.:任何字符。
[1234]：字符串长度为1，值为1、2、3、4中的一个数字；
[^a-f] ：字符串长度为1，值为除了a-f的其它字符；
{}：匹配长度，如 \s{3} 表示匹配三个空白字符;
?:它前面相邻的字符重复0或1次;
+:它前面相邻的字符重复1到多次;
*:它前面相邻的字符重复0到多次;
\b:单词边界。匹配的是一个位置而不是字符，这个位置的一侧是构成单词的字符，另一侧是非单词字符、字符串的开始或结束位置。

分别说出在单行模式和多行模式下，他们的含义：
^ab, ab$；

先介绍一下多行模式和单行模式的概念：

多行模式：
^　可以匹配字符串开头（字符串的开始位置），也可以匹配行的开头（即换行符\n之后的位置）$　可以匹配字符串结尾（字符串的结束位置）, 也可以匹配行的结尾（即换行符\n之前的位置）
单行模式：
^　只能匹配字符串开头$　只能匹配字符串结尾
注意这里有一个知识点：\r为回车符，\n 为换行符。在windows中，我们平常说的换行，实质上是先回车，后换行。
还是来看例子吧,以本题中的^ab , ab$为例：
String str="ab\nab\nab\n";
String reg="^ab";//默认是单行模式；
//String reg=”(?m)^ab”; 这个是多行模式，需要加(？m)，m是”multiLine”的缩写。
Pattern p=Pattern.compile(reg);
Matcher m=p.matcher(str);
while(m.find()){
System.out.println(m.group());
System.out.println(m.start()+""+m.end());
}
单行模式时：无输出，也就是没有匹配的字符串。因为单行模式时从头到尾地匹配，字符串"ab\nab\nab\n"和正则表达式"^ab"是不匹配的。
多行模式时：
ab
0 2
ab
3 5
ab
6 8
因为多行模式是从字符串开始匹配到换行符（\n）之前，接下来从\n之后重新匹配再到下一个\n之前（或字符串结束）。字符串"ab\nab\nab\n"中有3个”\n”,每两个”\n”之间的字符都与正则表达式"^ab"匹配，所以输出以上结果。
单行，多行模式，都是正则表达式的模式修饰符里面出现的参数。
单行跟多行是冲突的，一次只能指定一个选项，不能同时使用

贪婪模式和非贪婪模式的区别是? 并说出如何使用贪婪模式、如何使用非贪婪模式。
1.什么是正则表达式的贪婪与非贪婪匹配
　　如：String str="abcaxc";
　　　　Patter p="abc";
　　贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(abc)。
　　非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(abc)。
2.编程中如何区分两种模式
　　默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。
　　量词：{m,n}：m到n个
　　　　　：任意多个
　　　　　+：一个到多个
　　　　　？：0或一个
\D,\d分别表示什么意思?
\d:数字[0-9];
\D:非数字[^0-9];
说明反向引用是什么意思?
（1）捕获组捕获到的内容，不仅可以在正则表达式外部通过程序进行引用，也可以在正则表达式内部进行引用，这种引用方式就是反向引用。要了解反向引用，首先要了解捕获组，关于捕获组，请参考相关资料。

（2）捕获组(Expression)在匹配成功时，会将子表达式匹配到的内容，保存到内存中一个以数字编号的组里，可以简单的认为是对一个局部变量进行了赋值，这时就可以通过反向引用方式，引用这个局部变量的值。一个捕获组(Expression)在匹配成功之前，它的内容可以是不确定的，一旦匹配成功，它的内容就确定了，反向引用的内容也就是确定的了。（3）反向引用必然要与捕获组一同使用的，如果没有捕获组，而使用了反向引用的语法，不同语言的处理方式不一致，有的语言会抛异常，有的语言会当作普通的转义处理。

（4）示例说明：
源字符串：abcdebbcde
正则表达式：([ab])\1，这里的”\1”就是反向引用。
对于正则表达式“([ab])\1”，捕获组中的子表达式“[ab]”虽然可以匹配“a”或者“b”，但是捕获组一旦匹配成功，反向引用的内容也就确定了。如果捕获组匹配到“a”，那么反向引用也就只能匹配“a”，同理，如果捕获组匹配到的是“b”，那么反向引用也就只能匹配“b”。由于后面反向引用“\1”的限制，要求必须是两个相同的字符，在这里也就是“aa”或者“bb”才能匹配成功。

说明预搜索的含义?用自己的语言描述。
预搜索是用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像 \b ^ $ < > 这样的锚定作用，仅仅用于指定一个位置，不参与内容匹配。
还是来用例子说话吧：
（1）正则表达式：(?<=src=").?(?=")， "表示转义，即双引号"
其中(?<=)为反向预搜索，表示要匹配的字符串前面必须是src="
(?=)为正向预搜索，表示要匹配的字符串后面必须是"
.?表示要匹配的内容
（2）用上例来匹配以下文本：
待测试的文本：

那么执行这个正则表达式后，就可以提取出/UploadFiles/image/^20140304⁄_{20140304094318}_2971.png
预搜索的语法：
(?=xxx)
正向预搜索（向右）
正向预搜索，判断当前位置右侧是否能匹配指定表达式
(?!xxx)
正向预搜索否定，判断当前位置右侧是否不能够匹配指定表达式
(?<=xxx)
反向预搜索（向左）
反向预搜索，判断当前位置左侧是否能够匹配指定表达式
(? 反向预搜索否定，判断当前位置左侧是否不能够匹配指定表达式
预搜索分两种,一种是向右,另外一种是向左。

【上机】完成电子邮件的表达式
根据对电子邮箱格式要求的不同所得的正则表达式也是不同的。下例写得有点复杂，仅做参考：
/^https://link.jianshu.com?t=%5Ba-z0-9%5D%5B-%5D?%5Ba-z0-9%5D+” target=”blank” rel=“nofollow”>a-z@([a-z0-9][-]?[a-z0-9]+)+[.][a-z]{2,3}([.][a-z]{2})?$/i

解释：

/内容/i： 构成一个不区分大小写的正则表达式；^ 匹配开始；$ 匹配结束。②[a-z]： E-Mail前缀必需是一个英文字母开头③([a-z0-9][-]?[a-z0-9]+) ：和a_2、aaa11、1_a_2匹配，和a1、aaff_33a、a__aa不匹配，如果是空字符，也是匹配的，表示0个或者多个。④表示0个或多个前面的字符.⑤[a-z0-9]* ：匹配0个或多个英文字母或者数字；[-]? 匹配0个或1“-”，因为“-”不能连续出现。⑥[a-z0-9]+： 匹配1个或多个英文字母或者数字，因为“-”不能做为结尾⑦@： 必需有个有@⑧([a-z0-9]*[-]?[a-z0-9]+)+ ：见上面([a-z0-9][-]?[a-z0-9]+)解释，但是不能为空，+表示一个或者为多个。⑨[.]： 将特殊字符(.)当成普通字符；[a-z]{2,3} 匹配2个至3个英文字母，一般为com或者net等。⑩([.][a-z]{2})? ：匹配0个或者1个[.][a-z]{2}(比如.cn等) 我不确定一般.com.cn最后部份是不是都是两位的,如果不是请修改{2}为{起始字数,结束字数} 。

【上机】完成电话号码和手机号码的表达式。
验证手机号码：13XXXX,15XXXX,18XXX开头的手机号码：
String tel="13900098900";
String telReg="1[358]\d{9}";
System.out.println(tel.matches(telReg));

【上机】完成获取一个HTML元素的表达式。
【上机】完成163网页中所有的图片url地址的表达式。
【上机】完成如下测试代码：

说出：group(),group(1),group(2)的区别。
group(int index)的参数和所匹配正则表达式的分组有关。Index就是正则表达式中组的编号（第几组）。group()和group（0）都是指的整个串，group（1） 指的是第一组的内容，group（2）指的第二组的内容。

代码示例：
String str = "Hello,World! in Java.";
Pattern pattern = Pattern.compile("W(or)(ld!)");//对正则表达式进行分组
Matcher matcher = pattern.matcher(str);
while(matcher.find()){
System.out.println("Group 0:"+matcher.group(0));//得到第0组——整个匹配
System.out.println("Group 1:"+matcher.group(1));//得到第一组匹配——与(or)匹配的
System.out.println("Group 2:"+matcher.group(2));//得到第二组匹配——与(ld!)匹配的，组也就是子表达式
}
结果：
Group 0:World!
Group 1:or
Group 2:ld!
【上机】Javascript中，正则对象的test方法如何使用？写出测试代码。
【上机】Javascript中，字符串的match、split、replace方法，如何使用?写出代码。
【上机】Javascript中，使用正则对象时，模式：i,g。分别指的是什么?
阶段项目课程6
【项目】采用模拟数据实现网页三级联动的功能及用户名是否已注册校验的功能
练习目标：
熟悉HTML5
熟悉JavaScript语言
熟悉jQuery技术

百大项目第一阶段：项目调研
按照《百大项目》要求，自选项目主题，按照指定格式，完成操作手册的编写。
完成操作手册内容讲解视频的录制。
Oracle和Mysql数据库技术
查资料，回答下面问题：
Oracle公司的诞生和发展
(1)1977年程序员埃里森和另外两名程序员创建了软件开发实验室(Software Development Laboratories)。
(2)1970年IBM的一名研究人员写了一篇名为《大型共享数据库的关系数据模型》的论文，埃里森3人受到这篇文章的启发，决定构建一种新型数据库，称为关系数据库系统(relational database system).
(3)他们的第一个项目是为美国政府做的，他们给它取名为”Oracle”,因为他们认为“Oracle”有“智慧之源”的意思，作为这个项目的名字很恰当。
(4)1978年，此软件开发试验室迁至硅谷。为了扩大影响力，让人们更加了解公司的业务范围，他们将公司的名字从“软件开发实验室”更名为“关系软件公司（Relation Software Inc，简称RSI）”。
(5)1979年RSI开发出第一款商用SQL数据库。
1982年从RSI更名为Oracle系统公司（Oracle System Coroperion）。
1983年Oracle开发出便携式的RDBMS(关系型数据库管理系统)，这是第一款能在PC机，小型机和大型机上运行的便携式数据库。
1984年，年收入突破千万，业务扩张至奥地利、德国、日本、瑞典、瑞士。
1986年，公司上市，年收入达5,500美元。同年推出第一个客户端/服务器数据库。业务继续向全球扩张。
1987年，年收入过亿元。Oracle正式成为世界上最大的DBMS软件公司。它组建了由七个员工和两个产品组成的应用产品部，这标志着它开始进入企业应用产品市场。开始开展咨询和支持业务，旨在帮助客户更好地使用他们的软件。
现在，Oracle咨询部是世界上最大的咨询部之一。
1989年，年收入突破5亿元。建起了6座摩天大楼，试图营造自己的园区。
同年，Oracle在IBM大型机，DEC和Unix小型机以及OS/2 PC机上，创下了事物处理业绩的最佳纪录。
1991 年，年收入达到 10.28 亿美元。
Oracle中国公司正式在中国注册为“北京甲骨文软件系统有限公司”.
1992年，Oracle7数据库发布。
1993 年，年收入达到 15.03 亿美元。
1997年6月，ORACLE第八版发布。ORACLE8支持面向对象的开发及新的多媒体应用，这个版本也为支持Internet、网络计算等奠定了基础。同时这一版本开始具有同时处理大量用户和海量数据的特性。
1998年9月，ORACLE公司正式发布ORACLE 8i。“i”代表Internet，这一版本中添加了大量为支持Internet而设计的特性。这一版本为数据库用户提供了全方位的Java支持。ORACLE 8i成为第一个完全整合了本地Java运行时环境的数据库，用Java就可以编写ORACLE的存储过程。
在2001年6月的ORACLE OpenWorld大会中，ORACLE发布了ORACLE 9i。
2003年9月8日，旧金山举办的ORACLE World大会上，Ellison宣布下一代数据库产品为“ORACLE 10g”。ORACLE应用服务器10g（ORACLE Application Server 10g）也将作为甲骨文公司下一代应用基础架构软件集成套件。“g”代表“grid ,网格”。这一版的最大的特性就是加入了网格计算的功能。
2007年11月，Oracle 11g正式发布，功能上大大加强。11g是甲骨文公司30年来发布的最重要的数据库版本，根据用户的需求实现了信息生命周期管理（Information Lifecycle Management）等多项创新。
2009年，收购了SUN公司。

Oracle数据库安装后启动的几个服务都代表什么含义.我们一般启动哪几个服务即可?
共7个服务：
Oracle ORCL VSS Writer Service;手动启动；
描述：Oracle卷映射拷贝写入服务，VSS（Volume Shadow Copy Service）能够让存储基础设备（如磁盘，阵列等）创建高保真的时间点映像，即映射拷贝。它可以在多卷或者单个卷上创建映射拷贝，同时不会影响到系统性能。
OracleDBConsoleorcl;默认自动启动；
描述：数据库控制台服务，orcl是Oracle的实例标识，默认是orcl。在运行Enterprise Manager(企业管理器OEM)时，需要启动这个服务。
OracleJobSchedulerORCL;默认自动禁止；
描述：Oracle作业调度（定时器）服务，ORCL是Oracle的实例标识，默认是ORCL，可以自定义。
OracleMTSRecoveryService;默认自动启动；
描述：服务器端设置。该服务允许数据库充当一个微软事务服务器MTS。
OracleOraDb11ghome1ClrAgent;手动启动；
描述：数据库.Net扩展服务的一部分。
OracleOraDb11g_home1TNSListener;默认自动启动；
描述：监听器是Oracle基于服务器端的一种网络服务，用于监听客户端向数据库服务器端发出的连接请求。只存在于服务器端，监听器的设置也是在服务器端设置的。
服务只有在数据库需要远程访问时才需要启动（无论是从另一台主机远程访问还是从本机通过SQLNet网络协议进行访问都属于远程访问）。如果不开启这个服务就只能访问本地数据库。
OracleServiceORCL;默认自动启动；
描述：数据库（实例）服务，是Oracle的核心服务，是数据库启动的基础。只有该服务启动，数据库才能正常启动。
【上机】安装Oracle 数据库，并使用sqlplus和浏览器分别测试。
在DOS系统中（用cmd进入）：键入命令sqlplus，实际调用的是Oracle的sqlplus工具。调用成功按要求输入数据库用户名和密码即可。
在浏览器中连接数据库：
http://localhost:1158/em
如果你只有一个Oracle实例，用1158端口是可以登录的。
如果有多个Oracle实例，登录不同的数据库需要对应不同的端口号。端口号查询：
查询地址为：你本地oracle服务器安装地址下：如D:\database_oracle_11g_install\product\11.2.0\dbhome_1\install\portlist.ini文件中。
使用Oracle自带的可视化工具sql developer;使用时需要配置使用的jdk的安装路径。
使用pl/sql可视化客户端工具访问Oracle数据库。

     第一范式：

} catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }finally{<br />

 以下是代码：
 try {

         }

    try {<br />
        conn = JdbcUtils.getConnection();<br />
        //通过只打开一个连接 ;
        st = conn.prepareStatement(sql);<br />
        for (int i = 0; i < 10; i++) {<br />
            st.setString(1, "SN</em>" +( i+1));<br />
            st.setInt(2, i+10);<br />
            st.addBatch();<br />
            // 需要防止Preparedstatement对象中的命令列表包含过多的待处理sql语句, 而造成outOfMemory错误<br />
            if (i % 5== 0) {<br />
                st.executeBatch();<br />
                st.clearBatch();<br />
            }<br />
        }<br />
        // 将剩下的未处理命令发送给数据库  ;
        st.executeBatch();<br />
    } catch (SQLException e) {<br />
        e.printStackTrace();<br />
    } finally {<br />
        JdbcUtils.release(null, st, conn);<br />
    }<br />
}<br />