java基础语法学习
从零开始学习java的基础语法。
本次使用的工具是IDEA。
1、注释
注释不会被编译器编译，用于代码的解释。
// 这是一个单行注释
/*
这是多行注释
*/
// 下面是文档注释
/**
* @Author 作者名称
*/
彩蛋
百度搜索“有趣的代码注释”，可以查看到众多有趣的注释。如：
/***
* ┌─┐ ┌─┐
* ┌──┘ ┴───────┘ ┴──┐
* │ │
* │ ─── │
* │ ─┬┘ └┬─ │
* │ │
* │ ─┴─ │
* │ │
* └───┐ ┌───┘
* │ │
* │ │
* │ │
* │ └──────────────┐
* │ │
* │ ├─┐
* │ ┌─┘
* │ │
* └─┐ ┐ ┌───────┬──┐ ┌──┘
* │ ─┤ ─┤ │ ─┤ ─┤
* └──┴──┘ └──┴──┘
* 神兽保佑
* 代码无BUG!
*/
2、标识符
标识符相当于名字，java中所有组成部分都需要名字，类名、变量名以及方法名都是标识符。
关键字：指在java中已经被定义的单词。
标识符注意事项
3、数据类型
所有变量必须定义类型后才能使用。
int a = 10; // 定义变量a的类型为int类型
System.out.println(a); // 输出结果为10
b = 10; // b未定义类型，直接报错
（1）基本类型和引用类型
java分类两大类型：基本类型(八大基本类型)和引用类型
// 八大基本数据类型
// 整数型
byte num1 = 1; // byte类型占1字节
short num2 = 54; // shrot类型占2字节
int num3 = 456; // int类型占4字节
long num4 = 44868L; // long类型占8字节，使用（L）来标记为Long类型
// 小数型：浮点型
float num5 = 1.5465F; // 占4字节，使用（F)标记表示为float类型
double num6 = 1.235465; // 占8字节
// 字符型
char user = 'A'; // 2字节，只能赋值一文字字或一个字母，要使用单引号
// 布尔类型
boolean flag = true; // 只有两个结果，对（true）或错（false）
// 引用类型
// 类（class）
// 接口（interface）
// 数组（array）
（2）字节解释
位（bit）：是计算机内部数据存储的最小单位，00001010是一个八位的二进制数
字节（byte）：是计算机中数据处理的基本单位，1字节（byte）等于8位（bit）。
1byte = 8bit
1bit表示1位
1byte表示1字节
字符：是指计算机总使用的字母、数字、文字和符号
（3）浮点型拓展
// float 是有限的 取值取的是大约值 接近但不等于
// 小数比较最好是使用double比较
float f = 3.14f;
double d = 3.14;
System.out.println(f == d); // 结果为false，因为float取的是大约值，接近但不等于
float f1 = 13456789564f;
float f2 = f1 +1;
System.out.println(f1 == f2); // 结果为true，float取的是大约的值
double d1 = 113456789564.1;
double d2 = d1 + 1;
System.out.println(d1 == d2); // 结果为false
（4）char字符拓展
// 所有的字符本质还是数字
// 编码 Unicode 表：（97 = a 65 = A） 2字节
char c = 'a';
int i = (int)c;
System.out.println(i); // 结果：97
char c1 = 'u0061'; // u0061 为 unicode表代码
System.out.println(c1); // 结果：a
boolean布尔值拓展
boolean flag = true;
// if括号内只有一个值时，自动判断
if(flag == true) {} // 新手用法
if(flag) {} //老手用法，代码简洁易读
（5）类型转换
高类型转低类型,需要强制转换
低类型转高类型,不用强制转换
布尔值不能被转换
//==============================================================
// 类型 低 ---------------> 高
// byte,short,char --> int --> Long --> float --> double
//==============================================================
byte b = 5;
int i = 8;
byte b1 = (byte)i; // 从int-->byte，高类型到低类型,需要进行强制转换
int i1 = b; // 从byte-->int,低类型到高类型，不需要转换，直接赋值没问题
char c = 'a';
int i2 = c;
int i2 = 98;
char c1 = (char)i4;
System.out.println(i2); // 字母“a”转换成int类型，数值为97；
System.out.println(c1); // int类型为98的变量，转换为char类型是b
（6）溢出问题
// int类型是4字节（byte），4byte = 32bit，
// 2^32 = 4294967296全部范围，分为负数和正数：-2147483648-2147483647
// int类型超出这个范围-2147483648-2147483647，表示溢出。
int num1 = 10_0000_0000; // JDK7就有的特性，数字之间可以用下划线分割
int year = 20;
long sun = ((long)num1)*year; // 先强制转换在计算，就能解决溢出问题
System.out.println(num1*year); // 溢出就会报错
System.out.println(sun);
// 标记为long类型，一般用大写（L），因为小写（l）与数字1相似。
4、变量
（1）变量的作用域
局部变量：指在方法内声明的变量。（一般都必须初始化值）
是在方法中声明，并且只能方法中使用。
public class Demo2 {
// 类变量（使用static标记的变量）
// 与类一起出来，一起消失，
// 使用类变量在方法中可以不用新建对象，直接调用即可
static double dou = 4585;
// 实例变量：从属与对象，如果不进行初始化，这个数据类型默认是 0或0.0
// 布尔值默认是false
// 出了基本类型，其他的都默认为 null
String name;
int age;
public static void main(String[] args) {
int a = 1; // 局部变量，必须声明和初始化
// 使用声明的实例变量
Demo2 demo2 = new Demo2(); // 新建Demo2对象
demo2.age = 18;
System.out.println(demo2.name);
System.out.println(demo2.age);
System.out.println(dou); // 不用新建对象，直接使用类变量
}
}
（2）常变量
常量可以理解为特色的变量，初始化后不能再改变值。
常量名一般使用大写字符。
// 关键字：static（静态的）、final（常量）
// 关键词不区分先后
staic final double Pi = 3.14; // 该静态常量，可以在方法中直接调用
（3）变量的命名规范
1、见名知意，使用英文命名。
2、成员变量：使用首字母小写和驼峰原则（第一个单词以外，后面的单词首字母大写），如：lastName，createDate
3、常量：大写字母和下划线：MAX_VALUE
4、类名：首字母大写和驼峰原则，如：Man，ForntUserSave
5、方法名：首字母小写和驼峰原则
5、运算符
（1）自增（++）、自减（--）
// ++ -- 自增 自减 一元运算符（只使用到一个数值）
int a = 3;
int b = a++; // 变量a先赋值给b后，在自增 b值结果为3
// 相当于
// int b = a;
// int a = a + 1;
int c = ++a; // 变量a先加1后，在赋值给C， c值结果为5
// 相当于
// int a = a + 1;
// int b = a;
（2）运算拓展
// 幂运算 2^3 很多运算 我们都会使用一些工具类操作
double pow = Math.pow(2,3);
System.out.println(pow);
（3）逻辑运算符
// 与 或 非
boolean a = true;
boolean b= false;
System.out.println(a && b); // 与（&&）运算，当两个都为真才为真，否则为假
System.out.println(a || b); // 或（||）运算，只要有一个为真，则为真
System.out.println(!(a && b)); // 非（！）运算，取反
// 短路运算
// 使用&&时第一个为假，则后面就不会执行了
int c = 3;
boolean d = (c > 4)&&(++c < 2);
System.out.println(d);
System.out.println(c); // 结果d的值为3，因为(c>4)为假，后面就不执行了
// 使用||时第一个为真，则后面就不会执行了
boolean f = (c > 2)||(++c < 10);
System.out.println(f);
System.out.println(c); // 结果为3
boolean g = (++c > 1)||(c < 10); // 测试在运算时，可以使用自增
System.out.println(c); // 结果为4
（4）位运算
/*
A = 1001 0001 // 八个数字
B = 0001 1101 // 八位数字
// A低第一个数字对应B第一个数字，A的第二个数字对应B的第二个数字.....
A&B = 0001 0001 // 对应的数字都为1（即为true）时，得到1，否则得到0
A|B = 1001 1101 //对应数字只要有一个为1（true）时，得到1，否则得到0
A^B = 1001 1101 // 对应连个都为1时得到1，两个都为0是得到0，一个为1一个为0时，得到1
~B = 1110 0010 // 取反
2*8 = 16 2*2*2*2
<< *2
>> /2
*/
/*
0000 0001 1
0000 0010 2
0000 0011 3
*/
System.out.println(1<<3); // 即1*2*2*2 = 8，所以结果为8
（5）字符串拼接
int a = 3;
int b = 5;
// 字符串连接符
System.out.println("a" + a +b); //当运算中有字符，则默认为字符类型，进行拼接，结果为：35a
System.out.println(a + b + "a"); // 当字符是在后面时，先进行运算，在拼接，结果为：8a
（6）三元运算符
// 三元运算符 ？：
// x?y:z 表示：如果x为真，则输出y，否则输出z
int x = 3;
int y = 4;
int z = 5;
int a = x>2?4:5;
System.out.println(a); // 因为x>2为真，结果为4
6、包（pachage）
创建不同的包，避免同样类名的冲突，同一个名字的类名可以放到不同的包中，就不会冲突了。
包名一般使用域名的倒置。
使用定义的类，需要导入包。
7、javaDoc
@author 作者名
@version 版本号
@ since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值
@throws 异常抛出情况
