目录
走进Java编程世界
1.程序框架
2.main()方法
3.从控制台获取键盘上输入的信息
4.注释
5.编码规范
变量、常量和运算符
1.数据类型
2.变量
3.常量
4.算数运算符
5.数据类型转换
6.关系运算符
if选择结构
1.逻辑运算符
2.简单if选择结构
3.if-else选择结构
4.多重if选择结构
5.嵌套if选择结构
6.生存1~5的随机整数
switch选择结构
1.switch语法
2.处理输入异常
循环结构
1.while语法
2.do-while循环结构
for循环结构
1.for循环
2.break跳转语句
3.coutinue跳转语句
数组
1.数组的基本要素
2.声明数组
3.分配空间
4.获取数组长度
5.为数组元素赋值
2+3+5 声明数组+分配空间+赋值
6.数组元素，数据类型的初始值
深入循环结构
1. while循环中嵌套while循环
2.do-while循环中嵌套do-while循环
3.for循环中嵌套for循环
4.不同循环结构的嵌套
5.coutinue跳转语句
6.break跳转语句
7.break 跳转语句和 continue 跳转语句的对比
类的对象
1.对象的组成
2.类
3.定义类
4.声明方法
5.创建对象
6.引用对象的属性和方法
7.面向对象编程的优点
类的无参方法
1.类的方法
2.类的方法定义
3..类的方法调用
4.成员变量和局部变量
5.面向对象程序开发
6.JavaDoc注释
类的带参方法
1.带参方法
2.调用带参方法
3.java中的包
4.声明包
5.导入包
字符串
1.创建字符串
2.获取字符串长度
3.字符串比较
4.字符串中字母大小写转化
5.连接字符串
6.String类中比较常用的提取和查询方法
7.拆分字符串
8.创建StringBuffer对象
9.调用StringBuffer对象
10.追加字符串
11.插入字符串
走进Java编程世界
* Java语言是前Sun公司于1995年推出的高级编程语言
* Java技术可以应用在几乎所有类型和规模的设备上，无所不在
1.程序框架
public class HelloWorld {}public：表示公用的
class：表示声明一个类
HelloWorld：类的名称，可自定义
2.main()方法
public static void main(String[] args){}3.从控制台获取键盘上输入的信息
Scanner input=new Scanner(System.in)
int 接收的变量=input.nextInt();4.注释
//：单行注释
/* */：多行注释
5.编码规范
* 类名必须使用public
* 一行只写一条语句
* 用{}括起来的部分表示程序的某一层次结构。”{“一般放在这一行的结尾出，”}“与该结构的每个字母对齐，并单独占一行。
* 低一层次的语句或注释应该比高一层次的语句或注释缩进若干个空格再书写，使程序更加清晰，增加程序源代码的可读性。
变量、常量和运算符
1.数据类型
数据类型
数据类型 | 关键字 | 占用内存空间/字节 |
布尔型 | boolean(true/flase) | 1 |
字节型 | byte | 1 |
字符型 | char | 2 |
短整型 | short | 2 |
整型 | int | 4 |
长整型 | long | 8 |
单精度浮点型 | float | 4 |
双精度浮点型 | double | 8 |
2.变量
变量是可变化的量，是存储数据的基本单元，每个变量都是通过变量名来标识的。变量名简单清晰，具有更好的可读性。
//方法一：先声明变量后初始化
数据类型 变量名
变量名=数值
//方法二：声明变量的同时初始化
数据类型 变量名=数值命名规范：
* 变量名的组成：变量名由任意数量的字母、数字、下画线“__”或“$”符号组成。
* 变量名的开头不能是数字。
* 变量名不能使用Java语言本事定义的关键字，如int、class、public等关键字。
* 变量名区分大小写。
3.常量
常量的值是固定不变的，一旦被赋值，其值便不可修改。
final 数据类型 常量名4.算数运算符
算数运算符
算数运算符 | 名称 | 作用 | 示例 |
+ | 加法运算符 | 求操作数的和 | 4+6=10 |
- | 减法运算符 | 求操作数的差 | 6-4=2 |
* | 乘法运算符 | 求操作数的乘积 | 6*4=24 |
/ | 除法运算符 | 求操作数的商 | 6/4=1 |
% | 求余运算符 | 求操作数相除的余数 | 6%4=2 |
+ | 自加运算符 | 求操作数加1后的结果 | int x =6;x++;x=x+1 |
+ | 自减运算符 | 求操作数减1后的结果 | int x =6;x--;x=x-1 |
5.数据类型转换
自动转换以下次序进行：
byte、short—>int—>long—>float—>double
强制类型转换：
(数据类型) 表达式6.关系运算符
关系运算符
关系运算符 | 说明 | 举例 | 结果 |
> | 大于 | x>y | 如果x>y，成立，则为真，否则为假 |
< | 小于 | x<y | 如果x<y，成立，则为真，否则为假 |
>= | 大于等于 | x>=y | 如果x>=y，成立，则为真，否则为假 |
<= | 小于等于 | x<=y | 如果x<=y，成立，则为真，否则为假 |
== | 等于 | x==y | 如果x==y，成立，则为真，否则为假 |
!= | 不等于 | x!=y | 如果x!=y，成立，则为真，否则为假 |
if选择结构
1.逻辑运算符
逻辑运算符
运算符 | 名称 | 说明 |
&& | 逻辑与 | 表示并且、与。多个条件同时为true，结果为true，否则为false。 |
| | 逻辑或 | 表示或、或者。多个条件有一个为true，结果为true；多个条件同时为false，结果则为false。 |
！ | 逻辑非 | 条件为true时，结果为flase；条件 |
2.简单if选择结构
if(条件表达式){
//代码块
}
//应用场景：只须处理一个分支的if选择结构，条件表达式为 true 时执行代码块其中，条件表达式的结果是boolean类型，其值为true时，执行大括号{}中的语句。
3.if-else选择结构
if(条件表达式){
//代码块
}else{
//代码块2
}
//应用场景：可处理两个分支的if选择结构，条件表达式为true时执行代码块 1，否则执行代码块2。在实际开发中，if-else 选择结构的使用频率很高if-else选择结构还可以使用条件运算符表示，该运算符由问号(?)和冒号(:)组成，
运算规则：
先计算表达式1的值，如果表达式1的值为true，则返回表达式2的值；如果表达式1的值为false，则返回表达式3的值。
语法如下：
//三元运算法
表达式1?表达式2:表达式3
//示例：
String str=(1+2==3)？"算对啦！"："算错啦！"；
System.out.println(str)；//输出："算对啦！"可以看出，表达式1相当于if-else语句中的条件表达式，如果该条件值为true，则执行？和：之间的内容：否则执行：之后的内容。为使结构清晰，可在各表达式外加括号"()"。
4.多重if选择结构
if(条件1){
//代码块1
}else if{
//代码块2
}else{
//代码块3
}
//应用场景：可以处理更多分支的if选择结构。当要判断的条件是连续区间数值时更具优势。其中，elseif块有多个，也可没有，这取决于实际需求- else if语句块可以有很多个
- 最终以else语句块结束，代表所有条件都不满足时执行的代码，else块最多有一个或没有，且必须放在所有else if块之后。
- 程序自下从上执行，当满足任何一个条件时，都会执行其相应的代码块，执行完毕跳出此多重if选择结构，执行其后的程序。
- 如果多重if选择结构中所有的条件之间只是简单的互斥，不存在连续区间的关系，则条件没有顺序要求。
5.嵌套if选择结构
if(条件表达式1){
if(条件表达式2){
//代码块1
}else{
//代码块2
}
}else{
//代码块3
}
//应用场景：在if选择结构中又包含了一个或多个if选择结构，一般用于更为复杂的流程中- 只有当满足外层if选择结构的条件时，才会判断内层if的条件。
- else总是与它前面最近的未配对的if配对(就近原则)。
6.生存1~5的随机整数
Math.random():可生成[0.0,1.0)的double类型的随机数
Math.random()*5:可生成[0.0,5.0)的double类型的随机数
Math.random()*5+1:可生成[0.0,5.0]的double类型的随机数
(int)Math.random()*5+1:可生成[1,5]的int类型的随机数switch选择结构
1.switch语法
swich(表达式){
case常量1：
//代码块1；
break；
case常量2：
//代码块2；
break；
......
default：
//代码块n；
break；
}
//应用场景：一种更为简洁地处理多分支情况的选择结构，当条件判断是等值判断的情况时，比使用多重if选择结构更具优势- switch:表示“开关”。这个开关就是switch 关键字后面小括号里的值，这个表达式值可以是byte、short、char、int、枚举类型及 String 类型。
- case:表示“情况、情形”。case 后必须是一个常量，其类型与 switch 后表达式值的类型相同 case 块可以有多个，没有固定顺序，但每个case 后常量的值必须各不相同。当 switch 后表达式的值与某个case块的常量相等时，则执行该case块中的语句，类似于在多重if选择结构中，哪个条件满足即执行哪个条件后的代码块。
- default:表示“默认”。即表达式和值与任何一个case后的常量都不相等时，执行default后面 的代码，可以理解为多重if选择结构中最后的 else 块。default 块和 case 块的先后顺序可以变动，不会影响程序的运行结果。通常，default 块放在末尾，也可以省略。
- break:表示“停止”，即跳出当前循环。每个 case 块中都可以有一条 break 语句，这个 break语句具有极其重要的意义，它表示当程序执行完此 case 块后，即跳出整个 switch选择结构。
2.处理输入异常
Sanner类的常用方法
方法 | 描述 |
boolean hasNext() | 判断输入的数据是否为String 类型 |
boolean hasNextInt() | 判断输入的数据是否为int类型 |
boolean hasNextDouble() | 判断输入的数据是否为 double 类型 |
boolean hasNextBoolean() | 判断输入的数据是否为boolean类型 |
Scanner类中存在着一系列形如hasNextXXX 的方法，它们用于判断控制台输入的数据是否为某一指定类型，返回结果为boolean 数据类型。如果方法返回 true ，则表示输入的数据类型正确;否则，返回false，表示数据类型不正确。
循环结构
1.while语法
while(循环条件){
//循环操作
}- 循环条件：位于 while 关键字之后，与if选择结构中中的条件类似，循环条件也是一个表达式它的值为 boolean 类型，结果为 true 或 false。
- 循环操作：位于大括号“{}”中的代码，重复执行日的代码，又被称为“循环体”。
2.do-while循环结构
do{
//循环操作
}while(循环条件)- do-while 循环的执行过程是先执行循环操作，再判断循环条件是否成立，如果成立，则继续执行循环操作:如果不成立，则跳出循环。也就是说，无论循环条件是否成立，循环操作至少会执行一次。
- do-while 循环结构必须以分号结尾。
- 相同点:都是循环结构，使用“while(循环条件)”表示循环条件，使用大括号将循环作括起来。
- 不同点:表现在以下2个方面：
- 语法不同。与 while 循环结构相比，do-while 循环结构将 while 关键字和循环条件放在后面，而且前面多了关键字 do，后面多了一个分号。
- 执行次序不同。while 循环结构先判断，再执行;do-while 循环结构先执行，再判断。
- 在一开始循环条件就不满足的情况下，while 循环结构一次都不会执行，do-while 循环结构则无论什么情况都至少执行一次。
for循环结构
1.for循环
for(表达式1;表达式2;表达式3){
//循环体
}- 表达式1:用于设定循环变量初始值的表达式，确定从哪个值开始计数。
- 表达式2:循环条件表达式，结果为boolean 类型，作用是确定循环的终点。如果无此表达式此循环就成为死循环。
- 表达式3:用于完成循环变量递增或递减的表达式，即循环变量更新。通常会使用到“+”或“-”运算符，此表达式保证循环能正常退出。
- 循环体:重复执行的操作。
- 循环变量的更新：修改循环中的变量，从而保证循环能够退出。
- 多个表达式之间使用分号隔开，表达式3后无须使用分号。
2.break跳转语句
- break 跳转语句常用于结束循环操作，除可用于 for 循环结构外，还可用于其他循环结构，如 while 循环和 do-while 循环。
- break 跳转语句经常与if结构结合使用，实现在某种条件下退出当前循环结构。
3.coutinue跳转语句
for(表达式1;表达式2;表达式3){
//循环体
coutinue；
}- 使用在只需要结束本次循环，而继续执行后面的循环操作。
- continue 跳转语句可以用于 for 循环结构，也可以用于 while 和 do-while 循环结构。在 for 循环结构中，continue 跳转语句使程序先跳转到循环变量更新部分，然后判断循环条件。如果为 true，则继续下一次循环;否则终止循环。
- 在 while 循环结构中，continue 跳转语句执行完毕后，程序将直接判断循环条件，不再执行 continue 后的循环操作;如果更新循环变量的语句在 continue 后，那么将被忽略。continue跳转语句只能用在循环结构中。
- 不同点：
1.break跳转语句用于终止某个循环，程序跳转到循环体外的下一条语句。
2.continue 跳转语句用于跳出本次循环，进入下一次循环。
数组
1.数组的基本要素
数组的基本要素
名称 | 说明 |
标识符 | 也称为数组名，用于区分不同的数组 |
数组类型 | 一个数组中所有元素具有统一的数据类型 |
数组元素 | 数组中存放的数据 |
数组下标 | 数组元素的编号，通过这些编号访问数组元素。数组下标从0开始，最大下标为:数组长度-1，通过下标，可以访问数组中的每个元素。 其中，数组长度即为数组中最多可存储的元素个数 |
2.声明数组
数据类型[] 数组名 或 数组类型 数组名[];3.分配空间
数组名=new 数据类型[数组长度]4.获取数组长度
数组名.length5.为数组元素赋值
数组名[下标值]2+3+5 声明数组+分配空间+赋值
数据类型[] 数组名={值1,值2,值3, 值n};
或
数据类型[] 数组名=new 数据类型[]{ 值1,值2,值3,…,值n};6.数组元素，数据类型的初始值
数据类型 | 初始值 |
int | 0 |
doule | 0.0 |
char | '\u0000' |
boolean | false |
定义的数组是基本数据类型的数组时，即int、double、char 和 boolean 数据类型，在 Java语言中定义数组之后，若没有指定初始值，则根据数据类型的不同，会给数组元素赋一个默认值。
Arrays.sort(数组名)深入循环结构
1. while循环中嵌套while循环
while(循环条件1){
//循坏操作1
while(循坏条件2){
//循环操作2
}
}2.do-while循环中嵌套do-while循环
do{
//循环操作1
do{
//循环操作2
}while(循环条件2)
}while(循环条件1)3.for循环中嵌套for循环
for(循环条件1){
//循环操作1
for(循环条件2){
//循环操作2
}
}4.不同循环结构的嵌套
while(循坏条件1){
//循环操作1
for(循环条件2){
//循环操作2
}
}5.coutinue跳转语句
for(...){
for(...){
...
continue
...
}
...
}coutinue跳转语句,跳出本次循环，coutinue跳转语句后代码将不再执行，继续精度下一次循环。coutinue跳转语句只会影响内层循环结构，对外层循环无影响。
6.break跳转语句
for(...){
for(...){
...
break
...
}
...
}内层循环的break跳转语句只是跳出内层循环，如果要跳出外层循环，则还应在外层循环中加入break跳转语句
7.break 跳转语句和 continue 跳转语句的对比
以二重循环为例，当 continue 跳转语句和 break 跳转语句用于内层循环时，只会影响内层循环的执行，对外层循环没有影响，它们的不同点在于执行该语句后，程序跳转的位置不同
continue 跳转语句：只跳出本轮内层循环的执行，还会继续进行下一轮内层循环。 break 跳转语句：跳出整个内层循环。
类的对象
1.对象的组成
不同的对象拥有不同的特征和行为。我们把对象的特征和行为分别称为对象的属性和方法，它们是构成对象的两个主要因素。其中，属性是用来描述对象特征的一个数据项，该数据项的值即属性值。而方法是用来描述对象行为的一个动作序列。
在程序中，对象的属性被存储在一些变量中。对象的行为则通过定义方法来实现，对象是用来描述客观事物的一个实体，由一组属性和方法构成。
对象的属性和方法是相辅相成、不可分割的，它们共同组成了实体对象。因此，对象具有封装性。封装(Encapsulation)就是把一个事物包装起来，并尽可能隐藏内部细节。
2.类
类定义了对象将会拥有的特征(属性)和行为(方法)。
类的属性：对象所拥有的的特征在类中表示时称为类的属性。
类的方法：对象的执行的操作称为类的方法。
- 类是对象的模板
- 类是对象的类型，对象是类的实例
3.定义类
public class <类名>{
//定义属性的部分
属性1的类型 属性1
属性2的类型 属性2
...
属性3的类型 属性3
//定义方法部分
方法1();
方法2();
...
方法n();
}- 不能使用Java中的关键字。
- 不能包含任何空格或点号“”，以及除下画线“”、字符“$”外的特殊字符。
- 不能以数字开头。
4.声明方法
访问修饰符 返回值类型 方法名(){
//方法体
}5.创建对象
类名 对象名 = new 类名();6.引用对象的属性和方法
对象名.属性 //引用对象的属性
对象名.方法名 //引用对象的方法对象属性在未赋值之前使用默认值。
类的属性，也可称为类的成员变量；为属性赋值，也可以称为成员变量的初始化，这些都是较常用的说法。
类名和对象名不能混淆。
7.面向对象编程的优点
- 与人类的思维习惯一致。
- 隐藏信息，提高了程序的可维护性和安全性。
- 提高了程序的可重用性，可扩展性
类的无参方法
1.类的方法
类是由一组具有相同特征和共同行为的实体抽象而来的。类的方法用来实现对象的行为
2.类的方法定义
public 返回值类型 方法名(){
//方法体
[return 返回值]
}方法名：方法的名称，用于调用方法。首字母小写，采用“骆驼命名法”
方法体：方法的{}中的代码，表示具体完成方法名所表示的功能的代码。
返回值类型：限定返回结果的数据类型。执行方法后可能需要返回一个结果，使用return语句返回，语法如下：
return 返回值;方法中声明的返回值类型与方法体中return的返回值类型必须匹配:否则，编译报错.
功能1:跳出方法。结束当前的方法，表示“功能已经完成，要结束这个方法”。
功能2:返回结果。如果功能执行完产生了一个值，将这个值放在return后，表示“结束方法并把执行产生的值返回给调用它的程序”。
- 一个类中可以定义多个方法，方法之间是平行关系，不能在方法中再定义另一个方法。
- 一个类中多个方法间没有先后顺序，只要存在便可调用。
3..类的方法调用
对象名.方法名();4.成员变量和局部变量
- 成员变量：定义的类中，方法外的的变量。
- 局部变量：定义在方法中的变量或代码块中的变量(一对{}中)
- 使用成员变量和局部变量时需要注意以下几点：
1.作用域是不同的。
局部变量的作用域仅限于定义它的方法，在该方法外无法访问。成员变量在整个类中都有效，所有的成员方法都可以使用。如果访问权限允许，还可以在类的外部使用成员变量。
2.初始值不同。
成员变量拥有默认的初始值，局部变量没有。对于成员变量，如果在类定义时没有给它赋初始值，Java会给它一个默认值。基本数据类型的变量默认值为0，引用数据类型的变量默认值为null。但是，Java不会为局部变量赋初始值，所以局部变量定义后，必须要被赋初始值才能使用
3.在同一个方法中，不允许有同名的局部变量。在不同的方法中，可以有同名的局部变量。
4.局部变量可以和成员变量同名，并且在使用时，遵循就近原则，局部变量的优先级更高。
5.面向对象程序开发
面向对象程序开发是一种计算机编程架构。面向对象程序开发的一条基本原则是：计算机是由单个能够起到子程序作用单元或者对象组合起来的。采用这种架构编程可具有重用性，灵活性和扩展性的强大作用。
好处：类的方法用于实现某个特定的功能；其他的类不需要知道这个功能具体实现的，只要知道这个功能所在的类和实现它的方法就可以直接调用，提高代码的重用性。
6.JavaDoc注释
能够生成规范、完整的开发文档，是推荐注释的方式
/**
*
*
*/ 常用的JavaDoc标签
标签 | 含义 |
@author | 作者名 |
@parameter | 参数及其含义 |
@return | 返回值 |
@version | 版本标识 |
@since | 最早使用该方法/类/接口的JDK版本 |
@throws | 异常抛出条件 |
类的带参方法
1.带参方法
如果方法在完成特定的功能时依赖它所接收到的初始信息，那么在定义方法时，就需要在括号中加入参数列表
[<访问修饰符>] 返回值类型 <方法名> ([<参数列表>]){
//方法体
[return 返回值]
}<访问修饰符>指定该方法允许被访问的权限范围，可以是public、protectedprivate或defau(默认访问权限)。其中，public 访问修饰符表示该方法可以被任何其他代码调用。
<参数列表>是传送给方法的参数列表。参数列表包括参数的数据类型、参数的个数、参数的顺序。列表中各参数间以逗号分隔，语法格式如下：
数据类型:参数1，数据类型 参数2,…,数据类型 参数n，2.调用带参方法
调用带参方法和调用无参方法的语法相同，但是在调用带参数的方法时必须传入实际参数的值，语法如下：
对象名.方法名(参数1参数2…，参数n);- 在定义方法和调用方法时，把参数分别称为形式参数和实际参数，简称形参和实参
- 形式参数:在方法定义中，方法名后圆括号中的变量起到占位作用，指定完成该功能需要传入的参数个数和类型。
- 实际参数:调用方法时传递给方法处理的实际的值，本质就是赋值给形参变量的值。调用方法时，需要注意以下两点：
1.先实例化对象，再调用方法。 2.实参的数据类型、数量、顺序都要与形参--对应。
3.java中的包
在Java语言中，我们将这个特殊的文件夹称为“包” 。ava通过包来管理类，类似于文件存储于文件夹中，Java的类文件可以存储于包中。
包主要有以下3个方面的作用：
1.把功能相似或相关的类组织在同一个包中，方便找到和使用相应的类文件。
2.可以防止命名冲突。
3.包设定了访问权限，拥有包访问权限的类才能访问某个包中的类
4.声明包
package 包名包的声明必须是java源文件的第一条非注释性语句
5.导入包
import 包名.类名
//当要用到的某个包下的类超过1个时，可以使用”包名*“写法
import 包名.*- 要使用其他包中的类，首先要使用impo ort 关键字导入这个类。注意:包的声明必须位于 Java源文件的第一条语句，导入包的语句要写在类定义之前。
- 声明包的含义:声明当前类所处的位置。
- 导入包的含义:导入当前类中要使用用到的其他类所处的位置。
字符串
字符串就是将多个字符按一定的顺序排列组成的字符序列
1.创建字符串
//方式一：直接赋值
String str1="xxx";
//方式二:创建字符串对象
String str2=new String("xxx")2.获取字符串长度
字符串.length();3.字符串比较
字符串1.equals(字符串2)//不区分大小写
字符串1.equals(字符串2)//9区分大小写4.字符串中字母大小写转化
字符串.toLowerCase()；//返回字符串小写形式
字符串.toLUpperCase()；//返回字符串大写形式5.连接字符串
字符串1.concat.字符串26.String类中比较常用的提取和查询方法
String类中比较常用的提取和查询方法
方法 | 描述 |
public int indexOf(int ch)/public int indexOf(String value) | 查询第一个出现的字符ch或字符串value |
public int lastindexOf(int ch)/public int indexOf(String value) | 查询第一个出现的字符ch或字符串value |
public String substring(int index) | 提取从index位置开始到最后一个字符为止的字符串部分 |
public String substring(int beginIndex,int endIndex) | 提取从beginIndex到endIndex的字符串部分(不包含endIndex部分) |
public String trim() | 返回一个前后不含空格的字符串副本 |
7.拆分字符串
字符串.split(string regex);用于将一个字符串分隔为子字符串，将结果作为字符串数组返回，参数regex为分隔符
8.创建StringBuffer对象
//创建一个StringBuffer类的空对象
StringBuffer sb1=new StringBuffer();
//创建一个带有内容的StringBuffer对象
StringBuffer sb2=new StringBuffer("xxxx");9.调用StringBuffer对象
StringBuffer对象.toString();10.追加字符串
字符串1.append(字符串2)不仅可以将一个字符串追加到字符串后面，还可以将任何类型的值追加到字符后面
11.插入字符串
字符串.insert(位置，参数)；将参数插入字符串的指定位置并返回，参数类型可以是任意数据类型
