Java基础语法
注释
注释是不会执行的，而是给写代码的人看的。分为单行注释、多行注释、文档注释。
-
单行注释： //注释内容
-
多行注释：/* 注释内容 */
-
文档注释(JavaDoc):
/**
*/
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符
命名规则：
- 由数字(0-9)、字母(a-z或A-Z)、美元符号($)和下划线(_)构成，每个字符之间不能有空格
- 不能以数字开头
- 严格区分大小写
- 可以使用中文命名，但是一般不见以这样使用，也不建议使用拼英
关键字
a. 数据类型相关的
byte / short / int / long / float / double / char / boolean / class / interface;
b. 流程控制相关的
if / else / do / while / for / switch / case / default / break / continue / return / try / catch / finally;
c. 修饰符相关的
public / private / protected / final / void / static / abstract / synchronized;
d. 动作相关的
package / import / throw / extends / implements / this / super / new;
e. 保留字
true / false / null
不能使用关键字作为类名
数据类型
java是强类型语言(变量的使用要严格符合规范，所有变量必须先定义后在使用)。
弱类型语言(变量的使用可以不符合规范)
数据类型分为基本数据类型和引用数据类型
基本数据类型(primitive type)
-
数值类型
byte 字节型 1个字节 -2^7 ~ 2^7-1 或 -128 ~ 127
short 短整型 2个字节 -2^15 ~ 2^15-1 或 -32768 ~ 32767（3万多）
int 整型 4个字节 -2^31 ~ 2^31-1 （20多亿）
long 长整型 8个字节 -2^63 ~ 2^63-1long类型要在数字后面加个L
float 单精度浮点型 4个字节 -2^128 ~ 2^128 （约+/-3.4E+38） （8个有效位）
float类型要在数字后面加个F
double 双精度浮点型 8个字节 +/-1.8E+308F （16个有效位）
char 字符型 2-3个字节 所有字母、汉字 如果是数字、字母、英文符号均占用2个字节。如果是汉字，那么在GBK或者UTF16编码下占用2个字节，而在UTF8编码下是占用3个字节。
-
boolean类型 占1位，其值只有true或false
整数拓展
进制：二进制0b 八进制0 十进制 十六进制0x （十六进制由0-9和A-F组成）
int i = 10; //十进制 输出结果为：10
int i1 = 010; //八进制(逢8进1) 输出结果为8
int i2 = 0x01; //十六进制(逢16进1) 输出结果为16
浮点数扩展
浮点数的形容有有限、离散、舍入误差、大约、接近但是不等于
float f = 0.1f;//0.1
double d = 1.0/10;//0.2
System.out.print(f == d );//输出结果为false
float d1 = 232323232323f;
float d2 = d1+1;
System.out.print(d1 == d2 );//输出结果为true
因此，最好完全避免使用浮点数进行比较
比如银行业务的表示不能使用浮点数但是我们可以使用数学工具类BigDecimal
字符拓展
所有的字符本质还是数字
char c1 = 'a';
char c2 = '中';
System.out.print(c1);//输出结果是a
System.out.print((int)c1);//强制转换为int类型 输出结果是97
System.out.print(c2);//输出结果是中
System.out.print((int)c2);//强制转换为int类型 输出结果是20013
编码
Unicode 2字节 0-65536(2^16) 对应的字符对应相应的数字
Unicode的编码的表现范围为：U0000-UFFFF
Excel的最大为 2^16
转义字符
\t 制表符
\n 换行。。。。。
对象（从内存分析）
布尔值扩展
boolean flag = true;
//if(flage)和if(flage==true)
if(flage){
System.out.print("为true");
}
引用数据类型 (reference type)
除去基本数据类型之外的就是引用数据类型
类:String
String不是关键字，是一个类
接口
数组
类型转换
低---------------------------------------------------->高
byte,short,char->int->long->float->double
（float在long的前面的原因是小数的优先级高于整数）
- 强制转换 （类型）变量名 高到低
- 自动转换 低到高
注意点：
- 不能对布尔值进行转换
- 不能将对象类型转换为不相干的类型
- 把高容量转换到低容量的时候，强制转换
- 转换的时候可能出现内存溢出，或者精度问题
package com.ll.parse1;
public class Demo {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i;//强制转换
System.out.println(i); //输出结果为128
System.out.println(b); //输出结果为-128 因为内存溢出了所以为-128
//精度问题
System.out.println((int)23.7); //输出结果为23
System.out.println((int)-47.89f); //输出结果为-47
char c = 'a';
int d = c+1;
System.out.println(d); //输出结果为 98
System.out.println((char)d); //输出结果为 b
//操作较大的数，注意溢出问题
//JDK7的新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money * years;
System.out.println(total); //输出结果为： -1474836480 计算溢出了
long total2 = money * years;//因为money和years是int类型，所以它们相乘默认为int，因此转换前已经出现问题了
System.out.println(total2);//输出结果为： -1474836480
//解决办法：先转换一个数为long
long total3 = money*((long)years);
System.out.println(total3);//输出结果20000000000
//long一般用大写L
}
}
变量
可以变化的量，每个变量都必须声明其类型，变量是程序中最基本的存储单元，其要素包括变量类型、变量名和作用域
格式：数据类型 变量名 = 值；
public class Demo {
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = 3;
String name = "chongqing";
char x = 'X';
double pi = 3.14;
}
}
注意事项
- 每个变量都需要有数据类型，数据类型可以是基本数据类型也可以是引用数据类型
- 变量名要是合法的标识符
- 变量声明是一条完整的语句，最后必须有分号最为结束
作用域
- 类变量：由static修饰的变量
- 实例变量：从属于对象，在类里面
- 局部变量：在方法里面定义的变量，且必须声明和初始化值，只能在该方法里面有用
不同数据类型变量的默认值
整数型：默认为0
浮点数型：默认为0.0
布尔值：默认为false
除了基本类型，其余的默认值都是null
package com.ll.parse1;
public class Demo {
//类变量 添加一个static的关键字
static double salary = 2500;
//属性：变量
//实例变量：在类里面，从属对象
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量:必须声明和初始化值,只在这个方法内有用
int i = 10;
System.out.println(i);
//变量类型 Demo 变量名字：demo 变量值：new Demo()
Demo demo = new Demo();
System.out.println(demo.age);//输出结果为0，age没有初始化，int类型默认为0
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
常量(Constant)
初始化后不可以改变，不会变动的值。常量名一般为大写的字符
格式：final 常量名 = 值;
package com.ll.parse1;
public class Demo {
//修饰符，不存在先后顺序(变量名前面都是修饰符)，final可以放在static前面也可放在后面
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
变量的命名规范
- 所有的变量、方法名、类名：见名知意
- 类成员变量、局部变量、方法名都是首字母小写和驼峰命名原则(除了第一个单词首字母小写，后面的单词的首字母都大写)，如monthSalary
- 常量：大写字母和下划线，如MAX_VALUE
运算符(operator)
- 算数运算符：+，-，*，/，%(模运算---就是取余)，++，--
- 赋值运算符：=
- 关系运算符：>，<，>=，<=，==，!=，instanceof
- 逻辑运算符：&&，||，！
- 位运算符：&，|，^，~，>>，<<，>>>，<<<
- 条件运算符：？，：
- 扩展赋值运算符：+=，-=，*=，/=
package com.ll.parse1;
public class Demo {
public static void main(String[] args) {
//二元运算符
//Ctrl+D:赋值当前行到下一行
int a = 10;
int b = 20;
System.out.println(a+b); //30
System.out.println(a-b); //-10
System.out.println(a*b); //200
System.out.println(a/(double)b); //0.5 不进行强转double，除出来后的值就会四舍五入为0
int d = 123;
long c = 123123123123123L;
short e = 10;
byte f = 8;
double r = 3.4;
//如果操作数中没有double类型但是有一个操作数为long类型结果为long类型，
//如果有个操作数为double类型结果为double类型
// 如果没有long类型结果都为int类型
System.out.println(c+d+e+f+r);//1.231231231232674E14 double类型
System.out.println(c+d+e+f);//123123123123264 long类型
System.out.println(d+e+f);//141 int类型
System.out.println(e+f);//18 int类型
System.out.println(d+e+f+r);//144.4 double类型
}
}
package com.ll.parse1;
public class Demo {
public static void main(String[] args) {
//关系运算符返回的结果： 正确、错误 布尔值
int a = 10;
int b = 20;
int c = 21;
//取余，模运算
System.out.println(c%a); //1
System.out.println(a>b);//false
System.out.println(a<b);//true
System.out.println(a==b);//false
System.out.println(a!=b);//true
}
}
package com.ll.parse1;
public class Demo {
public static void main(String[] args) {
//++ 自增 --自减 一元运算符
int a = 3;
int b = a++; //执行这行代码后，先给b赋值，在自增
//a++ a = a + 1
System.out.println(a);//4
//a++ a = a + 1
int c = ++a;//执行完这行代码前，先自增在给c赋值
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5
//幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具来做
double pow = Math.pow(2, 3);
System.out.println(pow); //8.0
}
}
逻辑运算：
- 逻辑与运算 两个变量都为真，结果为true
- 逻辑或运算，两个变量有一个为假，结果为false
- 逻辑非运算，如果是真的，结果为假，如果是假的，结果为真
package com.ll.parse1;
public class Demo {
public static void main(String[] args) {
//逻辑运算符
//与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));//逻辑与运算，结果为false
System.out.println("a || b:"+(a||b));//逻辑或运算，结果为true
System.out.println("!(a && b):"+!(a&&b));//逻辑非运算，结果为true
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d); //false 由于c<4为假，所以直接输出结果为false不进行后面的运算,这就是短路运算
System.out.println(c); //5
}
}
/*
A = 0011 1100
B = 0000 1101
-------------------------------------------------
A&B=0000 1101 (如果上面和下面的数字都是1才为1，否则是0)
A|B=0011 1101 (如果对应位都是0则为0，反之为1)
A^B=0011 0001 （如果对应位相同则为0，不同则为1）异或
~B=1111 0010 取反
2*8 = 16 2*2*2*2
效率高
<<左移(相当于 *2) >>右移(相当于 /2)
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);//16
package com.ll.parse1;
public class Demo {
public static void main(String[] args) {
int a =10;
int b = 20;
a+=b; //a = a+b
System.out.println(a); //30
a-=b; //a = a-b
System.out.println(a); //10
//字符串连接符 +,String
System.out.println(a+b);//30
System.out.println(""+a+b);//1020 如果字符串在前面就会进行拼接
System.out.println(a+b+"");//30 如果字符串在后面前面的会继续进行运算
}
}
//三元运算符
// x ? y : z
//如果x==true，则结果为y，否则结果为z
int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type);//及格
字节
位(bit)：计算机内部数据储存的最小单位，如1001 1110 是一个8位二进制
字节(B)：计算机中数据处理的基本单位，习惯用大写的B来表示
字符：计算机中使用的字母、数字、字和符号
1bit表示一位
1B = 8bit
1024KB=1M
1024M=1G
JavaDoc
- @author作者名
- @version版本号
- @since指明需要最早使用的jdk版本
- @param参数名
- @return返回值情况
- @throws异常抛出情况
java生成文档的方法
- 在cmd中运行 javadoc -encoding UTF-8 -charset UTF-8 xxx.java
- 在Idea中生成：
- 选中要生成文档的类）找到工具栏tools --> Gencrate JavaDoc…打开
- 选择生成文档范围（也可以选中要生成的文档类）
- 生成文件存放的位置3.语言：中文：zh_CN
- 输入-encoding UTF-8 -charset UTF-8，避免出现乱码，在点击ok就可以了