java的注释、关键字、标识符、变量常量、
数据类型、运算符、流程控制等
1. java概述
1.1 java的技术体系
Java SE：是Java的标准版，提供了完整的java核心API。
Java EE：是Java的企业版，主要用于开发企业级分布式网络程序系统，核心为EJB（企业Java组件模型）。
Java ME：主要用于嵌入式系统开发。
1.2 Java语言特点
（1）简单性：语言省略所有难以理解和困惑的特点在C++语言，如头文件、指针、结构、单元、运算符重载、虚拟基础类，等它更简洁严谨；
（2）面向对象：两个基本概念“类”和“对象”；三大特征“封装”，“继承”，“多态”；
（3）跨平台性：自带解释器，在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机，在不同的系统平台上都可以运行；
（4）既是编译执行的语言，也是解释执行的语言：源文件通过编译，形成一个文件（不是二进制文件），而是“字节码的文件.class”，这个自节码文件是跨平台 的文件（java的内部会有自己的解释器（虚拟机）），使用自带的“解释器”解释执行.class。
2. Java程序的编写流程
2.1 Java应用程序的编写流程如下：
（1）编写源文件：编写Java源文件，他的扩展名为.java；
（2）编译：通过编译器把源文件编译成字节码文件，字节码文件的扩展名为.class；
（3）运行：使用解释器来运行字节码文件
2.2 源文件代码编写
在e盘下新建一个文本文档,文件名为MyFirstCode.java，内容如下：
public class MyFirstCode {public static void main(String[] args) {System.out.println("This is my fisrt code");}
}2.3 编译源代码文件
编译操作需要使用编译器来完成，它属于JDK的一部分，在安装JDK的时候已经安装好了，位置位于JDK的bin目录 下的javac.exe，使用DOS命令来运行它，如下图。
在编译时控制台上不会有输出，如果有输出说明源代码有错误，所以大家一旦编译出错，就要去查看源文件中是否 存在错误，正确编译后会在源文件同目录下生成字节码文件，扩展名为.class。
2.4 运行字节码文件
运行字节码文件需要使用java.exe命令，它与javac.exe在同一目录下，运行字节码文件与编译不同的是需要进入到 字节码文件所在的目录，并且在运行字节码文件是不要加扩展名，运行如下图。
2.5 简化编译和运行操作
可以发现每次程序编译与运行都要输入E:\ProgramFiles\jdk-8u144\bin后，才能使用javac.exe与java.exe，这样的 方式很麻烦，通过通过配置Windows的PATH环境变量就可以在不同位置编译运行。
配置PATH环境变量：鼠标右键点击计算机 → 属性 → 高级系统设置 → 点击环境变量 → 找到系统变量中的 PATH → 点击编辑按钮。将JDK安装目录\bin路径（我的电脑上的E:\ProgramFiles\jdk-8u144\bin）配置到PATH变量中，用 英文分号与其他变量隔开。还可如下配置环境变量：
（1）创建变量：变量名为:JAVA_HOME 变量值：安装JDK的目录；
（2）修改Path变量：在末尾添加信息: ;%JAVA_HOME%\bin;
（3）配置classpath: .;%JAVA_HOME%\lib\tools.jar。
3. 注释
Java中提供了三种注释方式，分别是：
（1）单行注释 //注释内容
（2）多行注释 /*注释内容*/
（3）文档注释 /**注释内容*/
文档注释的使用：javadoc –d 生成目录 –version –author 类名
4. 关键字
关键字是被Java语言赋予特殊含义，具有专门用途的单词，Java中的关键字均为小写关键字如下：
5. 标识符
5.1 定义
在Java程序中，其实标识符就是名称的意思，除了关键字以外基本上都是标识符了，在定义类、方法、变量时总 要给它们起名字，这些名字就是标识符。
5.2 组成元素
（1）英文字母： a-zA-Z
（2）数字：0-9
（3）符号：_和$
5.3 规则
（1）不能以数字开头；
（2）不可以使用关键字
（3）严格区分大小写
6. 变量与常量
6.1 常量
在程序运行过程中一直不会改变的的量称为常量，通常也被称为“final变量”，。常量在整个程序中只能被赋值 一 次。在Java中声明一个常量除了要指定数据类型外。还需要通过final关键字进行限定，语法如下：
final 数据类型 常量名 [ = 值 ]
常量名通常使用大写字母，但这并不是必须的，是为了清除的表名变量。
6.2 变量
在程序运行过程中其值能被改变的量称为变量，可以看成是存储数据的“盒子”。定义变量就是要告诉编译器这个变 量的数据类型，这样编译器才知道要分配多少内存给它，以及它能存放什么样的数据。在程序运行过程中，空间内的值是 变化的，这个内存空间就称为变量。内存空间内的值就是变量值。语法如下：
变量类型 变量名 [ = 变量值] []中的叫做变量的初始化
内存分配方式：
（1）基本数据类型：占用一块内存，如局部变量int i=1;在内存里面只分配了一块内存，里面存放的就是值 1，储到栈内存中，使用i这个名字来访问这块内存。
（2）引用数据类型：占用两块内存，如 String s此时为引用变量s分配了一块内存，但是目前这个内存什么 也没有存，因为此时s不指向任何一个对象，所以是null。当s=new String(“hi”)使用new创建了一个对象后，又分配 一块内存（堆），这个对象的内容“hi”就存放在新分配的内存中。而之前给s分配的内存也有了内容，根据这 个内容就可以找到第二块内存，使用其中的内容（“hi”）
7. 数据
7.1 数据类型
Java中的数据类型分为基本数据类型和引用数据类型。
引用数据类型(无限个数)：类，接口，数组 ，String 等(它用双引号)
7.2 数据类型分类
| 四类 | 八种 | 字节数 | 范围 |
| 整型 | byte | 1 | -2^7~2^7-1 |
| short | 2 | -2^15~2^15-1 | |
| int | 4 | -2^31~2^31-1 | |
| long | 8 | -2^63~2^63-1 | |
| 浮点型 | float | 4 | -3.403E38～3.403E38 |
| double | 8 | -1.798E308～1.798E308 | |
| 字符型 | char | 2 | 表示一个字符 |
| 布尔型 | boolean | 1 | 只有两个值true与false |
7.3 类型的转换
2.2.1.高低的级别：
byte,short,char=>int=>long=>float=>double其中，boolean类型不能跟其他类型之间做转换。
2.2.2.自动类型转换（隐式转换，宽向型转换）：
将第类型赋值给高类型，如：Short s=10;Int i=20;i=s;
2.2.3.强制类型转换：
将高类型赋值给低类型，需要强制装换，格式：低类型 变量=（低类型）变量。
注意：强制类型转换可能会丢失精度，代码如下
int i = 357; //4字节 32位的二进制数
byte b = (byte)i; //1字节 8位的二进制
System.out.println(b); // 结果为101
2.2.4.字符串和其它类型转换：
字符串和其它类型转换会提升成String类型
8. 运算符
8.1 算术运算符
| 运算符 | 运算规则 | 范例 | 结果 |
| + | 拼接字符串 | "拼" + "接" | 拼接 |
| + | 正号 | +1 | 1 |
| + | 加 | 1+2 | 3 |
| - | 负号 | -1 | -1 |
| - | 减 | 2-1 | 1 |
| * | 乘 | 1*2 | 2 |
| / | 除 | 5/2 | 2 |
| % | 取余 | 3/2 | 1 |
| ++ | 自加 | int a=1; a++/++a | 2 |
| -- | 自减 | int b=3; a--/--a | 2 |
注意：%取余操作和取模操作的区别，在于商：取余操作：商向0取整；模操作：商向下取整
++：前置++ 后置++：无论是前置还是后置，都对原来的变量进行+1， 对于表达的结果不同，后置++（会缓 存变量之前的值）指向的是变量+1之前的结果。
8.2 赋值运算符
| 运算符 | 运算规则 | 范例 | 结果 |
| = | 赋值 | int i=2； | 2 |
| += | 加后赋值 | int i= 2，i+=1 | 3 |
| -= | 减后赋值 | int i= 2，i-=1 | 1 |
| *= | 乘后赋值 | int i= 2，i*=1 | 2 |
| /= | 除后赋值 | int i= 2，i/=1 | 2 |
| %= | 取余后赋值 | int i= 2，i/=1 | 0 |
8.3 比较（关系）运算符
| 运算符 | 运算规则 | 范例 | 结果 |
| == | 相等于 | 2==2； | True |
| ！= | 不等于 | 2!=2； | False |
| < | 小于 | 2<1 | False |
| > | 大于 | 2>1 | True |
| <= | 小于等于 | 2<=1 | False |
| >= | 大于等于 | 2>=1 | True |
注意：==如果两侧都是基本数据类型，则比较的是值大小；如果两侧都是引用类型，则比较的是地址是否是同一个
8.4 逻辑运算符
| 运算符 | 运算规则 | 范例 | 结果 |
| & | 与 | false&true | False |
| | | 或 | false|true | True |
| ！ | 非 | !true | False |
| ^ | 异或 | false^true | True |
| && | 短路与 | false&&true | False |
| || | 短路或 | false||true | True |
短路现象：&& 第一个表达式为false，则后面的表达式不执行
|| 第一个表达式为true，则后面表达式不执行
8.5 位运算符
| 符号 | 运算规则 | 范例 | 结果 |
| >> | 右位移 | 12 >> 2 | 3 |
| << | 左位移 | 12 << 2 | 48 |
| >>> | 无符号右位移 | 12>>> 2 | 3 |
| & | 按位与 | 12 & 9 | 8 |
| ｜ | 按位或 | 12| 9 | 13 |
| ^ | 按位异或 | 12^ 9 | 5 |
位运算符是对于补码进行的按位操作：
& :如果两个都是1，则返回1，否则返回0
| : 如果两个都是0，则返回0，否则返回1
^ : 如果两个相同，则返回0，否则 ，返回1
~ ：一元运算符，对于某一个数的补码进行按位取反，包括符号位。
8.6 三元运算符
语法： 条件表达式?值1：值2
规则：如果条件表达式返回为真，取值1，否则取值2；值1表达式的类型和值2的表达式类型一致
8.7 运算符的优先级
| 优先级 | 描述 | 运算符 |
| 1 | 括号 | ()、[] |
| 2 | 正负号 | +、- |
| 3 | 自增自减，非 | ++、--、! |
| 4 | 乘除，取余 | *、/、% |
| 5 | 加减 | +、- |
| 6 | 移位运算 | <<、>>、>>> |
| 7 | 大小关系 | >、>=、<、<= |
| 8 | 相等关系 | ==、!= |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | | |
| 12 | 逻辑与 | && |
| 13 | 逻辑或 | || |
| 14 | 条件运算 | ?: |
| 15 | 赋值运算 | =、+=、-=、*=、/=、%= |
| 16 | 位赋值运算 | &=、|=、<<=、>>=、>>>= |
优先级： ()调整优先级
大体遵循规则：
算术运算符> 比较运算符 > 位运算符> 逻辑运算符> 赋值运算符
！优先级别最高
9. 流程控制
9.1 顺序结构
程序从上到下，从左到右执行。
9.2 分支结构
if结构语法，有3种如下：
（1） if（条件表达式）{
//执行语句
}
int i = 2;
if(i == 2) {System.out.println(i);
}（2） if（条件表达式）{
//执行成立语句1
}else {
//执行不成立语句2
}
int x = 5;
int y = 2;
if(x==3) {y = x + y;
}else {y = x - y;
}
System.out.println(y);（3） if（条件表达式1）{
//执行语句2
}else if（条件表达式2）{
//执行语句2
}else {
//执行语句3
}
int x = 10;int y = 0;if(x>=3) {y = 2 * x + 1;}else if(-1<x && x<3){y = 2 * x;}else if(x<=-1){y = 2 * x - 1;} System.out.println(y);
}注意：（1）分支语句中执行语句只有一个表达式可以省略大括号，否则不能省略。
（2）多分支语句中将条件范围小的放在最前面；如果前面的条件成立，后面的条件即使成立也不执行。
switch结构语法：
switch（变量/常量）{
case 值1：
//执行1；
break；
case 值2：
//执行2；
break；
......
defualt：
//执行3；
break；
}
注意：（1）变量/常量的类型只能是：byte，short，int，char，String（jdk1.7后），枚举；
（2）当省略break时，顺序从满足条件的语句从上到下执行，与case无关；
（3）case块中的值是唯一的，并且是等值比较的。
int score = 99;
switch (score / 10) { case 9:case 10:System.out.println("A");break;case 8:System.out.println("B");break;case 7:System.out.println("C");break;case 6:System.out.println("D");break;default:System.out.println("不及格");break;}9.3 循环
for循环
for（初始值表达式①，条件表达式②，迭代④）{
//执行③
}
//水仙花树(100~500) 153=1*1*1+5*5*5+3*3*3
for(int i=100;i<500;i++) {int theUnit = i%10;int decade = i/10%10;int hundred = i/100;if(i==theUnit *theUnit *theUnit +decade *decade *decade +hundred *hundred *hundred ) {System.out.println(i);}
}while循环
初始值①
while（条件表达式②）{
//执行③
//迭代④
}
//100以内能被5整除的数的和
int sum = 0;
int i=1; //初始值 1
while(i<=100) { if(i%5==0) {sum += sum;}i++;
}do while循环
//初始值①
do{
//执行②
//迭代③
}while(条件表达式④);
//输入字母，如果为q则退出系统
Scanner in=new Scanner(System.in);
System.out.println("请输入字母, 输入q则退出系统");
String letter ="";
do
{letter=in.nextLine();
}
while (!letter.equals("q"));
System.out.println("退出系统");foreach循环（增强for循环）
for（类型 对象 : 数组或集合）{
//执行操作
}
注意：（1）按照①-④的循序执行；
（2）for循环和while循环的特点：先判断，后执行；do while先执行一次再判断；增强for循环用于变量数组 或集合。
//遍历数组
int[] array = new array[]{11,22,33,44,55,66};
for(int every : array){System.out.println(every + " ");
}9.4 嵌套循环
在一个循环中又嵌套另一个循环结构。
嵌套循环特点：外层循环执行一次，内层循环执行全部。
for(int i=0;i<10;i++) { for(int j=0;j<=i;j++) {System.out.print("*");}System.out.println();}9.5 关键字break与continue
break（终止，打断）：只能出现在switch语句和循环结构中；在循环中表示终止循环；后面不能跟输出语句；
continue（继续）：只能出现在循环结构中；表示结束当前循环，进入下一次循环；
循环标号见如下代码：
label:for(int i=2;i<=100;i++) { for(int j=2;j<=Math.sqrt(i);j++) { if(i%j==0) {continue label;}}}break和continue都遵循就近原则。正常的break只退出一重循环，你可以用标号标出你想退出哪一个语句。
