第一章

1.public         公共的
2.static         静态的
3.void       无返回值的
4.main           主方法
5.class            类
6.system           系统
7.out              输出
8.print            打印

第二章

1.double   双精度浮点型
2.string       字符串型
3.character        字符型
4.integer          整型
5.scanner   扫描仪/键盘
6.score       成绩 分数
7.name       名字、姓名

第三章
1.boolean 布尔类型/逻辑类型
2.true             真
3.false            假
4.if               如果
5.else             否则

第四章
1.case             案例
2.default          默认
3.switch           开关
4.break            中断
5.match            匹配
6.assess           评估

第五章

1．while   当……的时候
2．do              做
3．index           索引
4．bug             缺陷
5．debug           调试
6．equal           等于
7．step            步长
8．error           错误

第六章

1．rate            比例
2．young           年轻的
3．schedule        调度
4．negative        负
5．customer        客户
6．birthday        生日
7．point           点，积分
8．continue        继续
9．return          返回

第七章

1．array           数组
2．length          长度
3．exception       异常
4．sort            排序
5．type            类型
6．primitive       原型
7．reference       引用
8．info            信息

第九章

1．insert          插入
2．island          岛
3．compare         比较
4．ignore          忽略
5．triangle        三角
6．invert          反转
7．diamond         钻石
8．password        密码

第十章

1．class           类
2．object          对象
3．OOP             面向对象
4．return          返回
5．Encapsulation   封装
6．null            空
7．initial         初始化
8．type            类型

第十一章

1．document        文件
2．display         显示
3．method          方法
4．version         版本
5．orient          导向
6．parameter       参数
7．since           因为

第十三章

1．search          搜索
2．triangle        三角
3．practice        练习
4．loan            贷款
5．shape           形状
6．operator        操作符
7．protect         保护
8．private         私有的

第十四章

1．height          高度
2．customer        客户
3．manage          管理
4．search          搜索
5．upper           大写
6．case            情况

第十五章

1．equal           相等
2．ignore          忽略
3．lower           降低
4．last            最后
5．trim            修剪
6．Concatenate     连接
7．buffer          缓冲区
8．final           不可修改

第十七章

1．mini            迷你
2．initial         初始化
3．delete          删除
4．search          搜索
5．count           计数
6．simple          简单
7．charge          负责人
8．list            列表

第一章 初识Java

1.什么是计算机程序?
  计算机按照某种顺序完成一系列指令，这一系列指令的集合称为程序。

2.Java相关的技术有哪些?
  JavaSE--
  JavaEE--

3.开发Java程序的步骤有哪些？
  编写源程
  编译
  运行

4.Java程序的结构
  编写程序框架
  编写main方法的框架
  编写代码

5.Java程序的注释类型有哪些?
  多行注释
  单行注释

6.使用记事本开发Java程序的步骤
  使用记事本编辑源程序，以.java为后缀名保存
  使用javac命令编译.java文件，生成.class文件
  使用java命令运行.class文件，输出程序结果

7.使用转义符
  \n 将光标移动到下一行的第一格
  \t 将光标移到下一个水平制表位置

8.编码规范是作为一个程序员应该遵守的基本规则，是行业内大家都默守的做法
  不遵守规范的代码不是好的代码 ，不是专业的代码
  Java编码规范
  类名使用public修饰
  一行只写一条语句
  { }的使用及位置
  代码缩进

1.Java领域的相关技术---JavaSE平台标准版 JavaEE平台企业版

2.Eclipse中开发一个Java程序的步骤---编写源程序 编译 运行

3.使用记事本编写Java程序.
  创建记事本程序以Java作为后缀名进行保存

1.编写程序框架

public class HelloWorld{}

这里命名类名为HelloWorld.它要和程序文件的名称一模一样.至于"类"是什么,我们会在以后的章节中深入学习.类名前面要用public(公共的)和class(类)两个修饰,它们的先后顺序不能改变.中间要用空格分隔.类名后面跟一对大括号,所有属于这个类的代码都放在"{""}"中间

2.编写main方法的框架

public static void main(String[] args){}

Java的主函数， 就像C语言之中的main一样，它是整个程序的入口。
static是静态方法的意思，只要的静态的方法才能够在不声明对象就是用。（String[ ] args）这个是命令行参数.

3.编写代码

System.out.println ("Hello Wold!");

System.out.println来向控制台输出信息。

System.out.println()和System.out.print()有什么区别?

不同的是，println()在打印完引号中的信息后会自动换行，
print()在打印输出信息后不会自动换行。

*1.多行注释“/*”开头，以“*/结尾之间的内容都被看作注释。
*1.单行注释“//”后面的文字都被认为是注释。

$规范要求类名必须使用public修饰
$一行只写一条语句
$用{}括起来的部分通常表示程序的某一层次结构。“{”一般放在这一结构开始的最末，“}”与该结构的第一个字母对齐，并单独占一行。
$低一层次的语句或注释应该比高一层次的语句或注释缩进若干格后书写，使程序更加清晰，增加程序的可读性。

常见错误
1.类名不可以随便起
  public修饰的类名称必须与Java文件同名！
2.void不可少
  main()方法中的void不可少！
3.Java对大小写敏感
4.";"是必须的
  在Java中，一个完整的语句都要以“；”结束！
5.“"”是必须的
  输出的字符串必须用引号引起来，而且必须是英文的引号。

第二章 变量、数据类型和运算符

1.变量
变量---根据数据的类型为它在内存中分配一块空间，然后数据存入内存的过程。

2.Java常用数据类型
int---整型---用于存储整数，比如，学员人数、华为公司的员工编号、一年的天数、一天的小时数

double---双精度浮点型---用于存储带有小数的数字，比如，商品的价格、世界银行给其他国家（地区）的贷款金额、员工工资

char---字符型---用于存储单个字符，比如，性别“男”或“女”、成绩“优”或“良”

String---字符串型---用于存储一串字符，比如，员工姓名、产品型号、产品的介绍信息

例1：
public class MyVariable {
   public static void main(String[] args) {
      int money=1000;             
      System.out.println(money);
    }
}

语法

1.数据类型 变量名；
double score;//声明双精度浮点型变量score存储分数
String name;//声明字符串型变量name存储学生姓名
char sex;//声明字符型变量sex存储性别

2.变量名=值；
score=98.5;    //存储98.5
name=“张三”；//存储“张三”
sex=“男”     //存储“男”

3.数据类型 变量名=值；
double score=98.5;
String name =“张三”
char sex =“男”

变量命名规则
1.变量必须以字母、下划线“_”或“$”符号开头，不能以*和数字开头。

2.变量可以包括数字，但不能以数字开头，不能包含%。

3.除了“_”或“$”符号以外，变量名不能包含任何特殊字符，不能包括+和空格。

4.不能使用Java语言的关健字，比如int、class、public等，不能包括连字符。

规范
变量名要简短且能清楚地表明变量的作用，通常第一个单词的首字母小写，其后单词的首字母大写。
例如：
int ageOfStudent;//学生年龄
int ageOfTeacher;//教师年龄

常见错误
1.变量要先声明并赋值，后才能使用，不然会出错。
2.变量在命名时如果不符合规则，Java编译器同样无法正常编译。
3.变量不能重名。

第三章 运算符和基本选择结构

一、运算符
1.“=”称为赋值运算符。切记“=”的功能是将等号右边表达式的结果赋值给等号左边的
变量。

二、算术运算符
+-*/  %---取余运算符，求操作数相除的余数。

下面就使用Java 提供的算术运算符来解决一个简单的问题。

问题：从控制台输入学员王浩三门课程的成绩，编写程序实现：Java课和SQL课的分数之差；三门课的平均分。

分析；首先要声明变量来存储数据，数据来源于用户从控制台输入的信息。然后进行计算并输出结果。

Scanner input=new Scanner(System.in);
System.out.print();
记住，这两行代码做的事情就是通过键盘的输入得到STB的成绩。

如何进行数据类型转换
1.自动数据类型转换
要解决不同类型之间的数据计算问题，就必须进行数据类型转换。

规则1:如果一个操作数为double型，则整个表达式可提升为double型。

规则2：满足自动类型转换的条件。
★两种类型要兼容：数值类型（整型和浮点型）互相兼容。

★目标类型大于源类型：double型可以存放int型数据，因为为double型变量分配的空间宽度足够存储int型变量。因此，我们也把int型变量转换成double型变量形象地称为“放大转换”。

2.强制数据类型转换
（数据类型）表达式
double d=34.5634;
int b=(int)d;
运行后b的值是34

本章总结

1.变量是一个数据存储空间的表示,它是存储数据的基本单元。

2.Java中常用的数据类型有整型(int)、双精度浮点型(doublle)、字符型(char)和字符串型(String)。

3.变量要先声明并赋值，然后才能使用。

4.Java提供各种类型的运算，具体如下。
  ◆赋值运算符(=)
  ◆算术运算符(+,-,*,/,%)。

5.数据类型转换是为了方便不同类型的数据之间进行运算。
6.数据类型转换包括自动类型转换和强制类型转换，发生自动类型转换  必须符合一定的条件。
  ★两种类型要兼容：数值类型（整型和浮点型）互相兼容。

★目标类型大于源类型：double型可以存放int型数据，因为为double     型变量分配的空间宽度足够存储int型变量。因此，我们也把int型      变量转换成double型变量形象地称为“放大转换”。

7.Java提供Scanner类可以实现从控制台获取键盘输入的信息。
Scanner input=new Scanner(System.in);
int H=input.nextInt();

boolean类型表示真假。“boolean”又称“布尔”，所以我们常说“布尔类型”。boolean是Java的关分键字，所有字母为小写。

boolean类型有两个值，而且只有这两个值。true真 false假

boolean 也需要首先进行声明和赋值。

关系运算符
>  大于
<  小于
>= 大于等于
<= 小于等于
== 等于
!= 不等于

if选择结构

if选择结构是根据条件判断之后再做处理的一种语法结构。
if (条件){代码块}

符号汇总

圆角长方形——程序开始或结束

长方形——计算步骤/处理符号

平行四边形——输入/输出指令

菱形——判断和分支

圆形——连接符

↑↓——流程线

复杂条件下的if选择结构

常用逻辑运算符

1.&& 与 并且 条件1 && 条件2——两个条件同时为真，结果为真；两个条件有一个为假，结果为假。

2.|| 或 或者 条件1 || 条件2——两个条件有一个为真，结果为真；两个条件同时为假，结果为假。

2.!  非 !条件 条件为真时，结果为假；为假时，结果为真。

使用if-else选择结构

if (条件1) {代码块1} else {代码块2}

本章总结

1.Java中使用boolean类型表示真假，boolean类型的两个值为true和false。

2.Java中使用关系运算符可以用来比较大小，高低，多少等，比较后的结果是boolean类型。

3.Java中的if选择结构，包括以下形式。
  ◆if选择结构：可以处理单一或组合条件的情况。
  ◆if-else选择结构：可以处理简单的条件分支情况。

第四章 复杂选择结构

1.多重if选择结构

if (条件1) {代码块1} else if (条件2) {代码块2} else {代码块3}

2.嵌套if选择结构

if (条件1) {if (条件2) {代码块1} else {代码块2} } else {代码块3}

注意：1.只有当满足外层if的条件时，才会判别内层if的条件。
       2.else总是与它前面最近的那个缺少else的if配对。

规范：1.为了使if结构更加清晰，应该把每个if或else包含的代码块都用大括号括起来。
      2.相匹配的一对if和else应该左对齐。
      3.内层的if结构相对于外层的if结构要有一定的缩进。

switch选择结构

switch (表达式) {
     case 常量 1：
         代码块1；
         break;
     case 常量 2：
         代码块2；
         break;
     case 常量 3：
         代码块3；
         break;
     default:
         代码块4；
         break;
}

1.switch: 表示“开关”，这个开关就是switch关键字后面小括号里的值，小括号里要放一个整型变量或字符型变量。

2.case:表示“情况、情形”，case后必须是一个整型或字符型的常量表达式，通常是一个固定的字符、数字，例如8、a。case块可以有多个，顺序可以改变，但是每个case后常量必须各不相同。

3.default:表示“默认”，即其他情况都不满足。default后要紧跟冒号。default块和case块的先后顺序可以变动，而不会影响程序执行的结果。通常，default块放在末尾，当然它也可以省略。

4.break:表示“停止”，即跳出当前结构。

经验
每个case后的代码块可以有多个语句，也就是说可以有一组语句，而且不需要用“{}”括起来。case和default后都有一个冒号，不要忘记了；否则编译不通过。对于每个case的结尾，都要想一想是否需要从这里跳出整个switch选择结构。如果需要，一定不要忘记写一个语句，那就是“break;”！

小结
学到这里，你会发现多重if选择结构和switch选择结构很相似，它们都是用来处理多分支条件的结构，但是switch选择结构只能处理等值条件判断的情况，而且条件必须是整型变量或字符型变量，而多重if选择结构却没有这个限制。

处理系统异常

if (input.hasNextInt()==true){
   int num = input.nextInt();
   switch (num){
   case 1:
      break;
   case 2:
      break;
   defauft:
      break;
   }
}else{
   System.out.println("请输入正确的数字");
}
      
本章总结

1.Java中的if选择结构，包括以下形式。

◆基本if选择结构：可以处理单一或组合条件的情况。
  ◆if-else选择结构：可以处理简单的条件分支情况。
  ◆多重if选择结构：可以处理复杂的条件分支情况。

2.在条件判断是等值判断的情况下，可以使用switch选择结构代替多重if选择结构，在使用switch选择结构时不要忘记每个case的最后写上break语句。

3.为了增加程序的健壮性，可以在程序中主动做判断，并给出用户友好的提示。

第五章 循环结构（一）

循环结构可以让程序帮助我们完成繁重的计算任务，同时可以简化程序编码。

while (循环条件) {
   循环操作
}

while (i<=100){System.out.println("好好学习！");i=i+1;}

do-while
do {
   循环操作
}while(循环条件)；

do {System.out.println("好好学习！");i++;}while(i<=100);

对比
我们学习了while和do-while两种循环。这两种循环有什么异同呢？

相同点：都是循环结构，使用“while(循环条件)”表示循环条件，使用大括号将循环操作括起来。

不同点：表现在以下三个方面。
1.语法不同。与while循环相比，do-while循环将while关键字和循环条件放在后面，而且前面多了do关键字，后面多了一个分号。

2.执行次序不同。while循环先判断,再执行；do-while循环先执行，再判断。

3.一开始循环条件就不满足的情况下，while循环一次都不会执行，do-while循环则不管什么情况都至少执行一次。

本章总结

1.循环结构由循环条件和循环操作构成。只要满足循环条件，循环操作就会反复执行。
2.使用循环解决问题的步骤：分析循环条件和循环操作，套用循环的语法写出代码，检查循环能否退出。
3.编写循环结构代码时需注意：循环操作中对循环变量值的改变和循环条件三者间的关系。确保循环次数正确，不要出现“死循环”。
4.while循环的特点是先判断，后执行。do-while循环的特点是先执行，再判断。
5.程序调试是满足我们暂停程序，观察变量和逐条执行语句等功能的工具和方法的总称，主要方法包括设置断点，单步运行和观察变量。

第六章 循环结构（二）

用循环结构进行描述，大大简化了编码工作，使得代码更加简洁，易读。
Java中的循环结构不只有while 和do while 两种，还有for循环结构。

for循环将循环结构的四个组成部分集中体现在一个for结构中，更加清晰。因此，在解决有固定循环次数的问题时，就可以首选for循环结构。

注意：
for(i=0,j=val;i<=val;i++,j--){}
“，”隔开的多个表达式组成的表达式。

在表达式1中，分别对两个变量i和j赋初值，它们表示两个加数。表达式3也使用了这种形式。

在这种特殊形式的表达式中，运算顺序是从左到右。每次循环体执行完，先执行i自加1，再执行j自减1。

我们知道for循环的循环条件中有三个表达式，在语法上，这三个表达式都可以省略，但表达式后面的分号不能省略。

1.省略“表达式2”，即不判断循环条件，循环将无终止运行，也就形成了“死循环”。

2.省略“表达式3”，即不改变循环变量的值，也会出现“死循环”。我们可以在循环体中改变i的值，解开“死循环”。

3.三个表达式都省略，即如下语句。
在实际开发中，为了提高代码的可读性，尽量不要省略各个表达式。如果需要省略，可以考虑是否改用while或do-while循环。

小结
break语句用于终止某个循环，使程序跳到循环块外的下一条语句法。在循环中位于break后的语句将不再执行，循环也停止执行。

经验
break语句不仅可以用在for循环中，也可以用在while和do-while循环中。
break语句通常与if条件语句一起使用。

continue语句的使用
不想执行完所有的循环体，就想跳出本次循环开始执行下一次循环。

小结
continue可以用于for循环，也可以用于while和do-while循环。在for循环中，continue使程序先跳转到迭代部分，然后判断循环条件。如果为ture,继续下一次循环；否则终止循环。在while循环中，continue执行完毕后，程序将直接判断循环条件。continue语句只能用在循环结构中。

三种循环的对比：

while (<条件>){
  //循环体
}

do{
  //循环体
}while(<条件>);

for (初始化；条件；迭代){
  //循环体
}

1.执行顺序不同。
  ◆while循环：先进行条件判断，再执行循环体。如果条件不成立，退出循环。
  ◆do-while循环：先执行循环体，再进行条件判断，循环体至少执行一次。
  ◆for循环：先执行初始化部分，再进行条件判断，然后执行循环体，最后进行迭代部分的计算。如果条件不成立，跳出循环。

2.适用情况不同
  在解决问题时，对于循环次数确实的情况，通常选用for循环。对于循环次数不确定的情况，通常选用while和do-while循环。

本章总结

1.for循环的语法格式如下。
  for(参数初始化；条件判断；参数值改变){}
2.在循环中，可以使用break和continue语句控制程序的流程。
  ◆break语句是终止某个循环，程序跳转到循环块外的下一条语句法。
  ◆continue语句是跳出本次循环，进入下一次循环。

第七章 数组

1.为什么需要数组
用数组集中操作数据比使用多个变量操作数据便捷得多。

2.Java中的数组

3.如何使用数组

①声明数组

*1.数据数型[] 数组名；
int[] scores;

②分配空间

*1.数组名=new 数据类型[数组长度];
scores=new int[30];

*2.数据类型[] 数组名=new 数据类型[数组长度];
int scores[]=new int[30];

③赋值

*1.数组名[下标值]；
scores[0]=89;

注意；
在编写程序时，数组和循环往往结合在一起使用，可以大大简化代码，提高程序效率。

*2.数据类型[] 数组名{值1，值2，值3，...，值n};
int[] scores={60,70,80,90,100}
int[] scores=new int[]{60,70,80,90,100}

④对数据进行处理。

注意；
数组一经创建，其长度（数组中包含元素的数目）是不可改变的，如果越界访问（即元素下标超过0至数组长度-1的范围），程序会报错。因此，当我们需要使用数组长度时，一般用如下方式。
数组名.length;
i<scores.length;

常见错误
1.数组下标从0开始
2.数组访问越界

数组应用
1.数组排序
Arrays.sort(数组名)；

2.求数组最大值
3.求数组最小值

深入理解数据类型
我们前面学的类型称为基本数据类型，除了基本数据类型，还有一种数据类型称为引用数据类型。

本章总结

1.数组是可以在内存中连续存储多个元素的结构，数组中的所有元素必须属于相同的数据类型。
2.数组中的元素通过数组的下标进行访问，数组的下标从0开始。
3.一维数组可用一个循环动态初始化，或者用一个循环动态输出数组中的元素信息。
4.利用Arrays类提供的sort()方法可以方便地对数组中的元素进行排序。
5.int、double、char、boolean类型是基本数据类型。
6.String和数组是引用数据类型。

第八章 指导学习：幸运抽奖

会使用选择结构解决问题

会使用循环结构解决问题

会使用各种数据类型

会使用数组解决问题

第九章 循环结构进阶

掌握二重循环的使用

掌握二重循环中跳转语句的使用

插入算法
  1.向数组中插入元素
    music = input.nextLine();
  2.String.compareToIgnoreCase(String2);
    这个方法是按字典顺序比较两个字符串的，并且忽略了大小写。
    如果按照字典顺序String1大于String2,该方法返回一个正数。
    如果按照字典顺序String1小于String2,该方法返回一个负数。
    两个字符串相等则返回0。

二重循环结构
  1.为什么使用二重循环
  2.什么是二重循环
  //while与while循环嵌套
  while(循环条件1){
      循环操作1
      while(循环条件2){
        循环操作2；
      }
  }
  //do-while与do-while循环嵌套
  do{
     循环操作1
     do{
        循环操作2
     }while(循环条件1);
  }while(循环条件2)；
  //for与for循环嵌套
  for(循环条件2){
      循环操作1
      for(循环条件2){
          循环操作2
      }
  }
  //while与for循环嵌套
  while(循环条件1){
      循环操作1
      for(循环条件2){
          循环操作2
      }
  }

如何使用二重循环

跳转语句进阶
  1.在二重循环中使用continue
  2.在二重循环中使用break
  3.二重循环中continue和break语句的对比
  4.二重循环综合应用

本章总结
  1.通过循环比较移位的方法，向数组中插入一个元素。
  2.二重循环就是一个循环体内又包含另一个完整的循环结构。
  3.在二重循环中可以使用break,continue语句控制程序的执行。

第十章

这个世界是由不同类别的事物组成的

在Java的世界中,"万物皆对象"！

UML用例图

项目经理要做的事

因此，在实际应用中，我们要根据待解决问题的需要，选择合适
的标准或角度对问题中出现的事物进行分类。

对象：用来描述客观事物的一个实体，由一组属性和方法构成。

类：具有相同属性和方法的一组对象的集合。

属性就是类的特征或特点

方法就是类的动作或功能

类是对象的类型

对象
  1.身边的对象
  2.对象的属性和方法
  3.封装

类
  1.类和对象的关系
  2.类是对象的类型

Java是面向对象的语言
  1.Java的类模板
    语法
    public class <类名>{
        //定义属性部分
        属性1的类型  属性1;
        属性2的类型  属性2;
        ……
        属性3的类型  属性3;
        
        //定义方法部分
        方法1;
        方法2;
        ……
        方法n;
    }
规范
    类名通常由多个单词组成，每个单词的首字母大写。
    另外，类名应该简洁而有意义，尽量使用完整单词，避免使用缩写词
   （除非该缩写词已被广泛使用，比如HTML、HTTP、IP等）。

如何定义类
  1.定义类名
    ★语法
    public class 类名{
        //程序体
    }
  2.编写类的属性
    通过在类的主体中定义变量来描述类所具有的静态特征（属性）,
    这些变量称为类的成员变量。
  3.编写类的属性
    通过在类中定义方法来描述类所具有的行为，
    这些方法称为类的成员方法。

public String showCenter(){
     //方法体
  }
  定义了一个类的方法，方法名是showCenter()。
  这个方法的作用是显示中心的信息，即中心名
  称以及教室和机房的配置情况。
  编写showCenter()方法时，你只需要在“方法体”
  部分写出你要实现的功能即可，showCenter是方法名。
  ★语法：
  访问修饰符 返回值类型 方法名() {
      方法体
  }

如何创建和使用对象
  ★语法
  类名 对象名 = new 类名();
  School center = new School();
      这里变量center的类型就是School类型。使用new创建对象时，我们并没
  有给它的数据成员赋一个特定的值。考虑到每个对象的属性值可能是不一样
  的，所以在创建对象后再给它的数据成员赋值。
  ★语法
  对象名.属性    //引用对象的属性
  对象名.方法名()//引用对象的方法
  例如：创建School类的对象center后，就可以给对象的属性赋值或调用方法
  center.neme = "北京中心"；//给name属性赋值
  center.showCenter();      //调用showCenter()方法
 
  说明
  main()方法是程序的入口，可以出现在任何一个类中，但要保证一个Java类
  中只有一个main()方法。因此，我们可以将main()写在School类中。但这里
  ，我们将main()放在了InitialSchool类中，目的是使不同的类实现不同的
  功能。
 
  1.首先使用关键字new创建类的对象"center"
    School center = new School();
  2.使用点操作符访问类的属性。
    //引用shoolName属性
    center.schoolName = "北京中心"
  3.使用点操作符访问类的方法。
    center.showCenter();
 
Java数据类型的默认值
int     0
double  0.0
char    "\u0000"
boolean false
String  null

面向对象的优点
  1.与人类的思维习惯一致：面向对象的思维方式是从人类考虑问题的角度
    出发，把人类解决问题的思维过程转变为程序能够理解的过程。面向对
    象程序设计能够让我们使用"类"来模拟现实世界中的抽象概念，用“对
    象”来模拟现实世界中的实体，从而用计算机解决现实问题。

2.信息隐藏，提高了程序的可维护性和安全性：封装实现了模块和信息隐
    藏，即将类的属性和行为封装在类中，这保证了对它们的修改不会影响
    到其他对象，有利于维护。同时，封装使得在对象外部不能随意访问对
    象的属性和方法，避免了外部错误对它的影响，提高了安全性。

3.提高了程序的可重用性：一个类可以创建多个对象实例，增加了重用性。
    面向对象程序设计还有其他优点，在以后的学习中会慢慢介绍。相信通
    过不断实践，你的理解会不断加深。

数据类型总结
  ★对比
  1.基本数据类型分为两类。
    ①基本数据类型：比如整型(int)、双精度浮点型(double)、字符型(char)
      布尔型(boolean)
　　②引用数据类型：比如字符串(String)、数组、使用class自定义的类型
      (School、Student等)。
  ★问答
    问题：为什么String类型是引用数据类型呢？
    解答：我们一直使用的String类型实际上是Java开发人员使用class关键
          字给我们定义的一个类，直接使用即可。因此，它也是属性和方法。
          
本章总结

1.对象是用来描述客观事物的一个实体，由一组属性和方法构成。

2.类是具有相同属性和方法的一组对象的集合。

3.类和对象的关系是抽象和具体的关系。类是对象的集合，对象是类的实例。

4.对象的属性和方法被共同封装在类中，相辅相成，不可分割。

5.面向对象程序设计的优点如下。
  ◆与人类的思维习惯一致。
  ◆隐藏信息，提高了程序的可维护性和安全性。
  ◆提高了程序的可重用性。

6.使用类的步骤如下。
  1.定义类：使用关键字class
  2.创建类的对象：使用关键字new。
  3.使用类的属性和方法：使用点操符"."。

7.Java中的数据类型分为两类；基本数据类型和引用数据类型。

第十一章

本章技能目标

1.会定义和使用类的方法
2.理解变量作用域
3.会添加类方法的JavaDoc注释

什么是类的方法

类是由一组具有相同属性和共同行为的实体抽象而来的。

如何定义类的方法

类的方法必须包括以下三个部分。
1.方法的名称
2.方法的返回值类型。
3.方法的主体

★语法
public 返回值类型 方法名(){
    //方法的主体
}
通常，编写方法时，分两步完成。
第一步：定义方法名和返回值。
第二步；在{}中编写方法的主体部分。

在编写方法时，要注意以下三点。
1.方法体放在一对大括号中。方法体就是一段程序代码，完成一定的工作。
2.方法名主要在调用这个方法时使用。在Java中一般采用骆驼式命名法。
3.方法执行后可能会返回一个结果，该结果的类型称为返回值类型。
  使用return语句返回值。

★语法
return 表达式；
比如在bark()方式中，返回类型是String类型，因此在方法体中必须使用
return 返回一个字符串。
如果方法没有返回值，则返回值类型为void。比如：run()方法没有返回值。
所以返回值类型为void。
因此，在编写程序时一定要注意方法声明中返回值的类型和方法体中真正
返回值的类型是否匹配。如果不匹配，编译器就会报错。
其实这里的return语句是跳转语句的一种，它主要做两件事情。
1.跳出方法。意思是“我已经完成了，要离开这个方法”。
2.给出结果。如果方法产生一个值。这个值放在return后面。即<表达式>
  部分，意思是“离开方法，并将<表达式>的值返回给调用它的程序”。
  就像我们按动按钮，电动狮子就会跑，这个“跑”就是方法返回给我们
  的一个结果。

方法调用

★语法
对象名.方法名();

常见错误
public class Student{
    public void showInfo(){
         return"我是一名学生";
    }
}
原因分析:方法的返回类型为void,方法中不能有return返回值。

public class Student{
   public void showInfo(){
       double weight = 95.5;
       double height = 1.69;
       return weight,height;
   }
}
原因分析：方法不能返回多个值。

public class Student{
    public String showInfo(){
        return"我是一名学生";
        public double getInfo(){
            double weight = 95.5;
            double height = 1.69;
            return weight,height;
        }
    }
}
原因分析：多个方法不能相互嵌套定义。

public class Student{
    int age=20;
    if(age<20){
         System.out.println("年龄不符合入学要求！");
    }
    public void showInfo(){
        return "我是一名学生";
    }
}
原因分析：不能在方法外部直接写程序逻辑代码。

变量的作用域

成员变量和局部变量
    成员变量：AutoLion类的方法可以直接使用该类定义的
成员变量。如果别的类的方法要访问它，必须首先创建该类
的对象，然后才能通过点运算符来引用。
    局部变量:它的作用域仅仅在定义该变量的方法内，因
些只有在这个方法中能够使用它。

常见错误

1.误用局部变量

2.控制流语句块中的局部变量

面向对象的编程思维

1.如何使用面向对象思维

JavaDoc注释

1.什么是JavaDoc注释
/**
 *AccpSchool类
 *@author    JadeBird
 *@version   1.0  2007/06/21
 */

小技巧
在Eclipse中，输入“/**”，然后按Enter键，Eclipse平
台会自动显示JavaDoc注释格式，并且字体颜色显示蓝色。
另外，当使用JavaDoc标签时，输入@,Eclipse平台会自动
显示一个下拉列表，它提供情报了所有的JavaDoc注释标签
供选择。

2.如何生成JavaDoc文档
使用命令行方式生成。
使用Eclipse工具生成。

本章总结

1.定义类的方法必须包括以下三个部分
  ◆方法的名称。
  ◆方法返回值的类型。
  ◆方法的主体。

2.类的方法调用，使用如下两种形式。
  ◆同一个类中的方法，直接使用方法名调用该方法。
  ◆不同类的方法，首先创建对象，
    再使用“对象名，方法名”来调用。
3.在Java中，有成员变量和局部变量，它们的作用域名不相同。
4.JavaDoc注释以"/**"开头，以"*/"结尾，并且提供了
JavaDoc注释标签。使用JavaDoc技术可以生成开发文档。

第十三章

会定义带参方法

会使用带参方法

会创建包组织Java工程

本章开始学习的内容----带参数的方法，你将会看到，带参方法
能够根据不同的外界条件，给出不同的结果。

1.带参方法

如何定义带参方法

★语法
<访问修饰符>返回类型<方法名>(<参数列表>){
     //方法的主体
}
  ◆<访问修饰符>指该方法允许被访问调用的权限范围，只能是public、protected或
private。其中public访问修饰符表示该方法可以被任何其他代码调用，另外两种修
饰符将在后续课程中陆续学习。
  ◆返回类型指方法返回值的类型。如果方法不返回任何值，它应该声明为void类型。
Java对待返回值的要求很严格。方法返回值必须与所说明的类型相匹配。使用return
关键字返回值。
  ◆<方法名>是定义的方法的名字，它必须使用合法的标识符。
  ◆<参数列表>是传送给方法的参数列表，列表中各参数间以逗号分隔，每个参数由
一个类型和一个标识符名组成。参数列表的格式为数据类型 参数1，数据类型 参数2，
……数据类型 参数n 。其中n>=0。
    如果n=0,代表没有参数，这时的方法就是前面学习过的无参方法。

2.带参方法的调用
    调用带参方法与调用无参方法的语法相同，但是在调用带参方法时必须传入实际
的参数值。

★语法
对象名.方法名(变量1，变量2，……变量n);

◆在定义方法和调用方法时，我们把参数分别称为形式参数和实际参数，简称形参
和实参。形参是在定义方法的时候对参数的称呼，目的是用来定义方法需要传入的参数
个数和类型。实参是在调用方法时传递给方法处理的实际的值。

调用方法时，需要注意以下几点。
  ◆先实例化对象，再调使用方法。
  ◆实参的类型、数量、顺序都要与形参一一对应。
  ◆没处理、没使用也是错的。

3.带有多个参数的方法
  ◆在使用时只要注意实参和形参一一对应。
  ◆传送的实际参数值的数据类型与形参相同。
  ◆个数相同，顺序一致，就掌握了带参方法的使用。

4.包
 
包主要有以下三个方面的作用。
  ◆包允许将类组合成较小的单元（类似文件夹），易于找到和使用相应的类文件。
  ◆防止命名冲突：Java中只有在不同包中的类才能重名。
  ◆包允许在更广的范围内保护类，数据和方法，可以在包内定义类。根据规则，
包外的代码有可能不能访问该类。

5.如何创建包
    要创建一个包(package)，只要包含一个package命令作为一个Java源文件的第
一条语句就可以了。

★语法
package 包名;

package是关键字。包的声明必须是Java源文件中的第一条非注释性语句，而且一个
源文件只能有一个包声明语句。包被设计与文件系统结构相对应。

◆Java包的名字通常由小写字母组成，不能以圆点开头或结尾，例如，".mypackage"
是错误的包名。
  ◆一个唯一包名的前缀通常是全部小写的ASCll字母，并且是一个顶级域名com、
edu、gov、net及org。通常使用组织的网路域名的逆序。例如，如果域名为
javagroup.net。我们可以声明包为：

package net.javagroup.mypackage;

◆包名的后续部分依不同机构自内部的规范不同而不同。

6.使用Eclipse创建包

在Eclipse中创建包有以下两种方式。

方法一、分别创建包和类，即在“文件”菜单中，根据提示依次完成“新建项目”
→“新建包”→“新建类”

方法二、在创建类的过程中创建类所属的包，即依次完成“新建项目”→“新建类”。

7.包和目录的关系

8.如何导入包

//导入java.util包
import java.util.*;

★语法
import 包名.类名;

import 包名.*;

本章总结

1.带参方法定义的一般形式如下。
  <访问修饰符>返回类型<方法名>(<参数列表>){
     //方法的主体
  }

2.调用带参方法与调用无参方法的语法是相同的，但是在调用带参方法时必须传入
实际的参数的值。

3.形参是在定义方法的时候对参数的称呼，实参是在调用方法时传递给方法的实际
的值。

4.Java中提供包来管理类。创建包使用关键字package.导入包使用关键字import。

第十四章

会使用数组作为方法的参数和返回值

会使用对象作为方法的参数

本章开始学习引用数据类型作为方法的类型以及作为参数时是如何使用的。

1.引用类型作为参数

◆数组类型的方法返回值

◆对于方法返回值的数据类型，使用引用类型和使用基本数据类型是一样的，
    只要记住方法体内return的返回类型与方法定义的返回值类型一致就可以了。

2.对象类型的参数
  对象作为参数也是很常用的。Java允许你像传递其他类型的参数那样，将对
  象以参数的形式传递给方法。但必须记住，对象属于引用数据类型，引用数据类型所传
  递的值为该对象的地址。当把一个对象作为参数传递给方法时，其实是把对象的地址传
  递给了该方法的参数。

将对象作为参数来传递实际上体现了面向对象的设计理念，它把相关的数据通过这种
  方式进行了很好的封装，这样数据可以很容易地被传递，并且对数据的整体操作也很
  方便。

3.对象数组类型的参数
  既然数组，对象都可以作为方法的参数，那么对象数组能够作为参数传递数据吗？答案
  当然是肯定的。

本章总结

◆Java把数据类型分为两大类
    1.基本数据类型
    2.引用数据类型

◆对于方法返回值的数据类型，使用引用类型和使用基本数据类型一样的。只要记
    住方法体内return的返回类型与方法定义的返回值类型一致就可以了。

◆对象属于引用数据类型，引用数据类型所传递的值为该对象的地址。当把一个对象
    作为参数传递给方法时，其实是把对象的地址传递给了该方法的参数。

◆使用对象数组作为参数，只是将对象作为一个数组元素，其引用方法与基本数据类
    型的数组完全相同。但针对对象数组中的单个元素来讲，它又具有对象的属性和
    方法。

第十五章

掌握String的基本用法

会使用==和equals()比较字符串

会使用StringBuffer类的方法对字符串进行操作

我们来学习非常常用的技能点——字符串。字符串被广泛地用在Java程序设计中，很
多操作都要使用字符串来完成。

1.字符串概述
  主要分为两步。
  ◆定义并初始化字符串。
  ◆使用字符串，对字符串进行一些处理。
 
  创建String对象的另外两种方法如下列代码所示。
  //创建一个空字符串
  String s=new String();

//创建一个字符串对象“Hello World”
  String s=new String("Hello World");
 
2.字符串的长度
  ★语法
  字符串1.length();
  返回字符串1的长度。

3.字符串的比较
  equals()方法
  ★语法
  字符串1.equals(字符串);

★语法
  字符串1.equalsIgnoreCase(字符串2);
  忽略大小写比较字符串1和字符串2。如果都相同，则返回真值；否则返回假值。

★语法
  字符串.toLowerCase()
  返回字符串的小写形式
  转换字符串中的英文字符为小写。

★语法
  字符串.toUpperCase()
  返回字符串的大写形式
  转换字符串中的英文字符为大写。

4.复杂的字符串处理
  ◆字符串的连接
  System.out.println("SQL"+sqlScore");
  这里的“+”运算符就起到了连接字符串的作用。同样，在定义一个字符串时也可以
  使用“+”运算符进行连接。

★语法    
  字符串1.concat(字符串2);
  字符串2被连接到字符串1的后面，返回连接后的新字符串。
 
  连接字符串的方法有两种：使用“+”运算符；使用String类的concat()方法。

5.字符串的提取和查询
 
  常用提取和查询字符串的方法
    //搜索第一个出现的字符ch(或字符串value)
  1.public int indexOf(int ch)
    public int indexOf(String value)

//搜索最后一个出现的字符ch(或字符串value)
  2.public int lastIndexOf(int ch)
    public int lastIndexOf(String value)

//提取从位置索引开始的字符串部分
  3.public String substring(int index)

//提取beginindex和endindex之间的字符串部分
  4.public String substring(int beginindex,int endindex)
   
    //返回一个前后不含任何空格的调用字符串的副本
  5.public String trim()

1.indexOf()方法
  该方法是在字符串内搜索某个指定的字符或字符串，它返回出现第一个匹配的位置。如
  果没有找到匹配，则返回-1。调用时，括号中写明要搜索的字符（或字符串）的名字。
  例如，搜索字符串“青春无悔”中字符“春”的位置；
 
  String s = "青春无悔";
  int index = s.indexOf('春');
  执行后，返回字符“春”的位置是1。

2.lastIndexOf()方法
  该方法也是在字符串内搜索某个指定的字符或字符串，但是它是搜索最后一个出现的字
  符（或字符串）的位置。例如，搜索字符串“青春无悔无悔青春”中最后出现字符串
  “青春”的位置；

String s = "青春无悔无悔青春";
  int index = s.lastIndexOf("青春")
  执行后，返回字符串“青春”的首字符位置，index的值为6。

3.substring(int index)方法
  该方法用于提取从位置索引开始的字符串部分，调用时括号中写的是你想提取的字符串
  的开始位置，方法的返回值就是要提取的字符串。例如，要提取字符串“青春无悔”中
  的“春无悔”
 
  String s = "青春无悔";
  String result = s.substring(1);

4.substing(int beginindex.int endindex)方法
  该方法的用于提取位置beginindex和位置endindex位置之间的字符串部分。特别要注意的
  是，对于开始位置beginindex，Java是基于字符串的首字符为0来进行处理的，但是对
  于终止位置endindex,Java是基于字符串的首字符为1来处理的。
  例如，要提取“青春无悔无悔青春”中的“无悔无悔”

String s = "青春无悔无悔青春";
  String result = s.substring(2,6);

5.trim()方法
  该方法可以忽略字符串前后的空格。

6.字符串的拆分
  字符串的拆分在实际应用中也是经常用到的

★语法
字符串名.split(String separator,int limit);

separator 可选项，标识拆分字符串时使用一个或多个字符。如果不选择该项，则返
回包含该字符串所有单个字符的元素数组。

limit可选项，该值用来限制返回数组中的元素个数。

7.StringBuffer类

1.声明StringBuffer对象并初始化
    
    //声明一个空的StringBuffer对象
    StringBuffer sb1 = new StringBuffer();
    
    //声明一个字符串“青春无悔”
    StringBuffer sb2 = new StringBuffer("青春无悔");

2.使用StringBuffer对象
    StringBuffer类提供了很多方法以供使用，调用时使用点操作符完成。

8.常用的StringBuffer类方法

★语法
字符串1.toString();
将StringBuffer类型的字符串1转换为String类型的对象并返回。
    例如：
    //转换为String类
    String s1 = sb2.toString();

★语法
字符串1.append(参数);
将参数连接到字符串1后并返回。

该方法和String类的concat()方法一样，都是把一个字符串追加到另一个字符串后面，
所不同的是String中只能将String类型的字符串追加到一个字符串后，而StringBuffer
可以将任何类型的值追加到字符串之后。

★语法
字符串1.insert(位置，参数);
将参数插入到字符串1的指定位置（int类型）后并返回。参数可以是包括String的任何
类型。

本章总结

1.定义一个字符串可以使用String类和StringBuffer类。
2.String类提供了大量的操作字符串的方法，常用的如下。
  ◆获得字符串的长度：length()
  ◆比较字符串：equals()
  ◆连接字符串：concat()
  ◆提取字符串：substring()
  ◆搜索字符串：indexOf()
  ◆拆分字符串：split()
3.常用的StringBuffer类提供的方法如下。
  ◆转换成String类型：toString()
  ◆连接字符串：append()
  ◆插入字符串：insert()