标签：引用 定义变量 声明 open lse 字符串类型 不同 原码 i++
Java的基本概念，包括标识符、关键字、数据类型、字面值、变量和常量等。
尽量使每个变量的声明单独占一行；关键字与关键字间只认一个空格；不要使用技术性很高、难懂、易混淆的语句；对于关键的方法要多加注释。
代码中使用英文半角符号。
1 //这里是单行注释 2 3 /* 4 这里是多行注释 5 */ 6 7 /** 8 *这里是多行的文档注释（可导出doc帮助文档） 9 * 10 */
| 四种声明 | 内存空间 | 取值范围 |
| byte | 1字节 | -128~127 |
| short | 2字节 | -32768~32767 |
| int | 4字节 | -2147483648~2147483647 |
| long | 8字节 | -9223372036854775808~9223372036854775807 |
注：
（1）1字节=8位，以byte为例，256=2^7+2^6+2^5+2^4+2^3+2^2+2^1+2^0 对应正负范围区间-128~127
（2）long整型赋值时，整数后面要加上l或者L。否则可能造成精度丢失，因为java的默认整数类型是int。
（3）8进制，以0开头： int a = 033;即十进制下的27
16进制，以0x或0X开头： int a = 0x33;即十进制下的51
| 两种声明 | 内存空间 | 取值范围 |
| float | 4字节 | 1.4E-45~3.4028235E38 |
| doudle | 8字节 | 4.9E-324~1.7976931348623157E308 |
注：
（1）float赋值时，数值后面要加上f或F。
（2）doudle赋值时，数值后面可以加上d或D，也可不加，因为java中浮点型的默认类型是double。
（3）java中近似值不精确，使用Math.round( )，四舍五入法。
1 public class Demo{ 2 public static void main(String[] args){ 3 double a = 4.35 * 100; 4 System.out.println(a); 5 System.out.println(Math.round(a)); 6 } 7 } 8 9 10 输出结果： 11 434.99999999999994 12 435
（4）java中近似值不精确，使用Math.abs( )<1e-6 ，最小值对比法。
1 public class Demo{ 2 public static void main(String[] args){ 3 double a = 0.1; 4 double b = 2.0 - 1.9; 5 System.out.println(a); 6 System.out.println(b); 7 System.out.println(a==b); 8 System.out.println(Math.abs(a-b)<1e-6); 9 } 10 } 11 12 13 输出结果： 14 0.1 15 0.10000000000000000000009 16 false 17 true
用单引号包含的可打印的单个符号。
字符‘8‘（以字符编码参与运算）与数字8，字面值相同但是值是不同的。
| 类型 | 取值范围（采用unicode编码） |
| char | 0~65536 |
char可以保存字符，也可以保存对应的字符编码值。
| 上下赋值结果相同 | char a = ‘a‘ | char b = ‘汉‘ | char c = ‘2‘ |
| char a = 97 | char b = 27721 | char c = 50 |
问题：如何给char赋值单引号？‘ ‘ ‘三个单引号是错误的，因此引入转义字符，代表特殊的字符。
| 转义字符 | 含义 |
| \‘ | 单引号字符 |
| \" | 双引号字符 |
| \\ | 反斜杠字符 |
| \t | 垂直制表符，将光标移到下一个制表符位置 |
| \r | 回车 |
| \n | 换行 |
| \b | 退格 |
| \f | 换页 |
\101表示八进制值101，即字符编码值65对应的字符A。
关键字boolean定义变量， true或false，逻辑上的真假。
1 boolean a; 2 boolean a = true; 3 boolean a = true, b = false;
原则：“勿以小杯盛大物”，不同的数据类型占用的内存空间不同，低精度可以放入高精度，高精度放入低精度则可能精度丢失。
| 转换方式 | |
| 低精度→高精度 | 隐式转换（自动转换）、显式转换（强制转换） |
| 高精度→低精度 | 显式转换（强制转换） |
1: int a = 100;
2: byte b = (byte)a;
显式转换导致精度损失举例：
| 结果 | 精度损失分析 | |
| float f=(float)3.1415926 | 3.1415925(默认double强制转float) | 数据失准 |
| int i=(int)f; | 3 | 小数点丢失 |
| byte b=(byte)129 | -127 | 数值越界溢出 |
标识符：用来标识类名、变量名、方法名、数组名等等的有效字符序列。
标识符命名规则：由任意顺序的字母、_ 、$ 和数字组成，第一个字符不能是数字，不能是Java中的保留关键字，严格区分字母大小写。
注：标识符使用汉字，字符编码集发生改变后，代码中的中文标准符全部显示乱码。
标识符的命名规范：
| 类名 | 方法名 | 变量名 | 常量名 |
| 通常使用名词，所有单词首字母大写。 | 通常使用动词，首单词字母小写，后续单词首字母大写。 | 首单词字母小写，后续单词首字母大写。 | 所有字母均大写。 |
| PandaFamily | openDoor() | sisterName | GENDER(性别) |
关键字：Java语言中被赋予特定意义的单词。以下就是Java中所有的关键字。
为什么需要变量？
内存地址直接使用十分繁琐，变量名对应着数据存储的内存地址，通过变量名就可以找到数据存储的位置，变量名直接调用为存储的数值。
语法： 数据类型 变量名 = 变量值; //变量的值是可以改变的
为什么需要常量？
实际开发中，有些值是不需要更改的，甚至不允许更改。将不会改变的量称为常量。
语法： final 数据类型 常量名 = 常量值; //final是声明常量的关键字
算术、赋值、逻辑和条件等常用运算符，以及简单的条件结构if和if-else。
1: 量 = 值
2: //量：做写的操作，被赋予等号右侧的值
3: //值：做读取操作，可以是常量、公式
| 运算符 | 说明 | 实例 | 结果 |
| + | 加 | 12.45f+15 | 27.45 |
| - | 减 | 4.56-0.16 | 4.4 |
| * | 乘 | 5L*12.45f | 62.25 |
| / | 除 | 7/2 | 3 |
| % | 取余 | 12%10 | 2 |
注：(1) + 运算符还有作用：拼接字符串 如：”hello”+”world”
(2)使用除法运算符与取余运算符，0不能做除数。
运算对象：整数或浮点数
| 自加运算符 | 自减运算符 | 区别 | |
| 前置形式 | ++a | --a | 先自增自减，再赋值 |
| 后置形式 | a++ | a-- | 先赋值，再自增自减 |
| 计算结果 | a+1 | a-1 |
单目运算符不可以放在圆括号之外。
1: (a + b)++ //错
2: --(x + y) //错
关系运算符的结果是布尔值。
注： a<b<c //错误
运算对象：布尔型数据。 逻辑运算符的运算结果是布尔值。
位运算符分为：（1）位逻辑运算符（2）位移运算符
以下是位逻辑运算符真值表（位逻辑运算结果）：
与 或 异或 取反
异或：A和B不相等则返回1，相等则返回0。
位逻辑运算过程（位逻辑运算结果）：
注：位取反运算涉及到符号数的三种表示法：原码、反码、补码。（将单独一篇日志说明）
位逻辑运算的逻辑结果：
左移<<（二进制码整体左移），示例：
注：符号位（首位0正1负）不发生改变的情况下，左移一位即原来的数字乘二。
右移>>（二进制码整体右移），示例：
注：正数右移符号不会发生改变（左侧补0）；负数右移符号也不会发生改变（此时左侧自动补1）。
无符号右移>>>（二进制码整体右移，此时不分操作数是否为正负数，高位一律补0），示例：
注：byte和short为低精度整型，不适合做无符号右移（高位补0不会发生，即一直为负数）待定
三元运算符的功能与if…else相似。
1: //语法 返回值=判断公式？结果1：结果2;
2: //判断公式：一个返回布尔值的公式
3: //结果1：如果公式返回的是true，运算符结算返回结果1
4: //结果2：如果公式返回的是false，运算符结算返回结果2
5: int a = 1;
6: int b = a<3?2:3; //显然1小于3，则b=3
注：返回值不可忽略。（int b = a<3?2:3;正确）（a<3?2:3;错误）（a<3?2:3;可以整体做参数输出）
运算符的优先级列表：
注：（1）从操作数个数来看，单目运算符的优先级高于双目运算符的优先级；
（2）按照运算符的作用来看，（）级别最高，之后依次是算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符。
进一步学习选择结构，包括多重if与嵌套if结构 ，以及switch结构。
1: if(布尔表达式){
2: 语句;
3: }
4: //(布尔表达式)为true则执行{}中的语句；为false则跳过{}中的语句。
5:
6:
7:
8: if(布尔表达式)
9: 语句；
10: //(布尔表达式)为true则执行第一个";"前的语句；为false则跳过第一个";"前的语句。
注：严格遵守if格式，if(布尔表达式);错误，后续语句不受if控制
1: if(布尔表达式){
2: 语句1;
3: }else{
4: 语句2;
5: }
6: //(布尔表达式)为true执行语句1所在的{}中的所有语句;
7: //为false执行语句2所在的{}中的所有语句。
注：出现多个if情况下（非嵌套），else会匹配一个距离最近的未匹配的if语句。
1: if(表达式1){
2: 语句1;
3: }else if(表达式2){
4: 语句2;
5: ...
6: }else if(表达式n){
7: 语句n;
8: }else{
9: 语句m;
10: ]
11:
12: //多分支表达语句
if判断语句的总结：
(1)表达式：关系表达式或者逻辑表达式。
(2)表达式的运算结果应该是真或假。
真：执行该语句；假：跳过该语句，执行下一条语句。
(3)“语句”可以是单条语句也可以是复合语句。
(4)else if可以有很多条，无上限。
(5)if和else if都需要判断表达式真假，else不需要，else if和else必须配合if一起使用，不能单独使用。
1: switch(用于判断的参数){ //整数、枚举、字符串
2: case 常量表达式1:语句1；break; //break用于跳出switch语句,可以不写。
3: case 常量表达式2:语句2；break;
4: ...
5: case 常量表达式n:语句n；break;
6: default:语句n+1;break; //所有case无匹配，则执行该条语句。
7: }
注：(1)若某一case后的语句为空（无;），但是case匹配，则执行下一条非空的case语句（不一定匹配）。
(2)字符串作switch的参数（JDK1.7的新特性，仅支持1.7及以上的版本）
掌握while循环、do-while循环、for循环和循环嵌套的使用。
Alt+/ 自动补全
Ctrl+shift+F 自动调整格式
Ctrl+S 保存
语法格式：
1: while(布尔表达式){ //返回布尔值，判断是否执行语句
2: 语句; //可被循环执行的语句
3: }
1到100相加，举例：
1:
2: public class Demo {
3: public static void main(String[] args) {
4: int sum = 0;
5: int i=1;
6: while(i<=100) {
7: sum=sum+i;
8: i++;
9: }
10: System.out.println("1到100相加的结果是："+sum);
11: }
12: }
13:
14:
15: 输出：
16: 1到100相加的结果是：5050
注：（1）表达式不允许为空；
（2）表达式不应该是常数；
1: while(true){ //无线循环
2: ...
3: }
4:
5:
6: while(false){ //永不循环
7: ...
8: }
（3）循环体中要有改变条件表达式值的语句，否则将成为死循环。
1: int i=1;
2: while(i<=2)
3: {
4: System.out.println(i); //死循环
5: }
语法格式：
1: do{
2: 语句;
3: }while(布尔表达式)；
4:
5: //相比较于while,do...while先执行循环语句，再判断。
密码输入示例：
1: import java.util.Scanner;
2:
3: public class Demo {
4: public static void main(String[] args) {
5: Scanner sc=new Scanner(System.in);
6: String pwd1="0";
7: String pwd2="-1";
8: do {
9: System.out.println("请输入密码：");
10: pwd1=sc.nextLine();
11: System.out.println("请再次输入密码：");
12: pwd2=sc.nextLine();
13: if(!pwd1.equals(pwd2))
14: System.out.println("您输入的密码不一致，请重新输入！");
15: }while(!pwd1.equals(pwd2));
16: System.out.println("设置密码成功！");
17: }
18: }
19:
注：（1）表达式不允许为空（同while）；
（2）表达式不应该是常数（同while）；
（3）循环体中要有改变条件表达式值的语句，否则将成为死循环（同while）；
（4）不要少写结尾的分号。
1: do{
2: ...
3: }while(...)
;
//少分号，程序会报错
语法格式：
1: for(初始化表达式1;布尔表达式2;表达式3){
2: 语句;
3: }
4: //初始化表达式1：循环开始前运行一次，可做赋值操作。
5: //布尔表达式2：返回布尔值，控制循环是否继续执行。
6: //表达式3：通常是赋值表达式，在完成一次循环之后执行。
计算从1加到100的和，示例：
1: public class Demo {
2: public static void main(String[] args) {
3: int sum=0;
4: for(int i=1;i<=100;i++) {
5: sum +=i;
6: }
7: System.out.println("sum="+sum);
8: }
9: }
10:
注：多层for循环嵌套，配合嵌套if，可以解线性最优解问题（问题：100元买鸡，公鸡5元一只，母鸡3元一只，小鸡3只1元，如何在用完100元的情况下分配买鸡情况）。
foreach相当于for的特殊简化版本。
语法格式：
1: for(type x:obj){
2: 引用了x的java语句;
3: }
4:
5: //type x：循环变量，依次将obj中的值赋给x
6: //obj：一个可以被遍历的集合，例如数组
7:
8: //**遍历**//
9: //简单的理解为：对数组或者集合中的所有元素，逐一访问，依次读取一遍。
10:
11: //**数组**//
12: //相同数据类型的元素按一定顺序排列的集合。
示例：
1: public class Demo {
2: public static void main(String[] args) {
3: int arr[]={5,8,9};
4: for(int x:arr){
5: System.out.println(x);
6: }
7: }
8: }
9:
10: 输出结果：
11: 5
12: 8
13: 9
break作用：中断循环
break适用的语句：
break控制内层循环和外层循环：
注：单单的break只能中断内层循环，通过使用标签（变量Loop可自定义）可以直接中断标记位置的外层循环。
4.2关键字continue
continue的作用：直接跳转执行下一次循环
注：continue也可以只用标签，跳转至外层执行下一次循环。
介绍维数组的定义和使用，以及增强型for循环的应用，并能够实现冒泡排序。
语法格式：
1: 数组元素类型 数组名[];
2: 数组元素类型[] 数组名; //创建一维数组两者一样，只创建了数组没有定义数组长度
3:
4:
5: //数组初始化三种方法，初始化就是给数组赋初值。
6: //(1)
7: int a[] = new int[3]; //指定数组长度
8: a[0] = 7; //赋初值
9: a[1] = 8;
10: a[2] = 9;
11:
12: //(2)
13: int b[] = new int[]{4,5,6}; //根据集合元素的个数自动指定数组长度
14:
15: //(3)
16: int c[] = {1,2,3}; //相当于方法（2）的简化版
注：（1）常见一维数组类型：整型数组、浮点型数组、字符数组、字符串数组。
（2）int arr[] = new int[3]{4,5,6}; //语法错误
(3)java数组沿用C语言风格，数组下标从0开始。若a[]长度为3，a[3]属于下标越界。
数组的length属性：（返回数组长度）
1: //数组名.length 返回的是数组长度值
2: public class Demo {
3: public static void main(String[] args) {
4:
5: int a1[] = new int[15];
6: System.out.println(a1.length);
7:
8: }
9: }
10:
11: //输出
12: //15
注：(1)length返回的是int型；
(2)数组长度不可以定义成负数；
(3)length的值是常量。
示例：
1: //打印每个月的天数
2: public class Demo {
3: public static void main(String[] args) {
4: int day[] = {31,28,31,30,31,30,31,31,30,31,30,31};
5: for(int i=0;i<day.length;i++) {
6: System.out.println((i+1)+"月有"+day[i]+"天");
7: }
8:
9: }
10: }
语法格式：
1: 数组元素类型 数组名[][];
2: 数组元素类型[][] 数组名; //创建二维数组两者一样，只创建了数组没有指定行数列数
3:
4: //二维数组初始化的三种方法
5: //(1)
6: int tdarr1[][] = {{1,3,5},{5,9,10}}; //方法（2）的简化版
7:
8: //(2)
9: int tdarr2[][] = new int[][]{{1,3,5},{5,9,10}}; //第一个大括号即第一行tdarr[0]，后同理
10: //自动指定2行3列
11:
12: //(3)
13: int tdarr3[][] = new int[2][3]; //创建二维数值，指定行数列数
14: tdarr3[0] = new int[]{1,3,5}; //一次性初始化第一行tdarr[0]
15: tdarr3[1][0] = 5; //对第二行初始化
16: tdarr3[1][1] = 9;
17: tdarr3[1][2] = 10; //相当于tdarr[1] = new int[]{5,9,10};
二维数组下标对应的位置关系：
示例：（用二维数组将《春晓》以横版和竖版输出？）
横版：
竖版：
注：（1）arr.length返回行数，arr[i].length返回当前i行的元素个数，即列数。
（2）System.out.print(); //输出不换行
3.1遍历数组
遍历数组就是获取数组中的每个元素。
遍历二维数组方法：（1）双for循环（2）双foreach循环
示例：（双for）
(双foreach)
3.2填充替换数组元素
3.3对数组排序
3.4复制数组
3.5数组查询
的
方法的定义和调用，数组作为方法参数、方法重载、传值和可变参数列表等概念和应用。
补充：
包声明：一个java应用程序是由若干个类组成，语句package Number为声明该类所在的包，package为包的关键字。
声明成员变量和局部变量：将类的属性称为类的全局变量（成员变量），将方法中的属性称为局部变量。全局变量声明在类体中，局部变量声明在方法体中。
编写主方法：main()方法是类体中的主方法，从 { 开始至 } 结束。Java程序中的main()方法必须声明为public static void，public是权限修饰符，static是静态修饰符，void是返回值修饰符。String[] args是一个字符串类型的数组，它是main()方法的参数。main()方法是程序开始执行的位置。
导入API类库：在Java语言中可以通过import关键字导入相关的类。
标签：引用 定义变量 声明 open lse 字符串类型 不同 原码 i++
原文地址：https://www.cnblogs.com/wuguangzong/p/8930989.html
