注释
- Java中注释有三种：单行注释、多行注释、文档注释
public class HelloWorld {
public static void main(String[] args) {
// 单行注释
System.out.println("Hello,World!"); // 输出一个HelloWorld
/*
* 多行注释,
* 可以注释一段文字
*/
/* 文档注释：JavaDoc /**回车
* 用法：
* 1.用在类的外面，用于对类解释说明
* 2.写在方法上面，对方法解释说明
* 3.解释说明成员变量
*/
/**
* @Description HelloWorld
* @Author BruisesL
*/
}
}
标识符
Java所有的组成部分都需要名字。类名、变量名、以及方法名都被称为标识符。
-
所有的标识符都应该以 字母(A-Z 或者 a-z)、美元符($)、下划线(_) 开始
-
首字符之后可以是 字母(A-Z 或者 a-z)、美元符($)、下划线(_) 或数字的任何字符 组合
-
不能使用关键字作为变量名或方法名
-
标识符是大小写敏感的
-
类名命名必须大驼峰。大驼峰：首字母大写，后面每个单词首字母大写。 例如：UserManagement
-
方法名、变量名小驼峰。小驼峰：首字母小写，后面每个单词首字母大写
例如：userName
-
合法标识符举例：age、 $salary、_value、__1_value
-
非法标识符举例：123abc、-salary、 #abc
-
关键字
分隔符
-
分号（ ; ）：语句的分割，表示一句话结束，好比使用的句号。
-
花括号（ {} ）：表示一个代码块，是一个整体，花括号要成对使用。
-
方括号（ [] ）：定义数组和访问数组元素时使用。
-
圆括号（ () ）：使用很广泛，具体用到细讲。
-
圆点（ . ）：类和对象访问它的成员时使用，从属关系。
-
空格 [ ]：把一整条语句分割成几段，空格的次数不限制，一般单词之间一个空格即可。
什么是字节
- 位(bit)：是计算机内部数据储存的最小单位，11001100是一个八位二进制数
- 字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示
- 1B(byte) = 8bit
- 字符：是指计算机中使用的字母、数字、字和符号
数据类型
Java是强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
Java的数据类型分为两大类：
-
基本类型(primitive type)
- 数值类型
-
整数类型
- byte占1个字节范围：-128到127
- short占2个字节范围：-32768到32767
- int占4个字节范围：-2147483648到2147483647
- long占8个字节范围：-9223372036854775808到9223372036854775807
-
浮点类型
-
float占4个字节
tips：float是离散的，具有舍入误差，接近但不等于
-
double占8个字节
tips:
-
double 和 float 的区别是double精度高，有效数字16位，float精度7位（可提供7位或8位有效数字，构成包括符号位、指数位和尾数位）。但double消耗内存是float的两倍，double的运算速度比float慢得多，能用单精度时不要用双精度。
-
浮点的误差来自十进制小数跟二进制小数之间的转换。如果这个转换对你具体的应用来说不是必须的，那么你就完全可以用浮点。
-
-
字符类型char占2个字节，数据需使用单引号。
-
boolean类型：占1位，其值只有true和false两个
-
1public class Demo01 { public static void main(String[] args) { // 八大基本数据类型 // 整数 int num1 = 10; // 最常用 byte num2 = 20; short num3 = 30; long num4 = 30L; // long类型要在数字后加L //小数，浮点数 float num5 = 40.1F; // float类型要在数字后加F或f double num6 = 3.1415926; // 字符 char name = 'A'; // 字符串，String不是关键字，是类 String namea = "BruisesL"; // 布尔值：是非 boolean flag = true; // boolean flag = false; } }拓展：
public class Demo02 { public static void main(String[] args) { //整数拓展 进制问题：二进制0b 十进制 八进制0 十六进制0x int i1 = 10; int i2 = 010;//八进制的10 int i3 = 0x1F;//十六进制的1F System.out.println(i1); System.out.println(i2); System.out.println(i3); System.out.println("======================================"); //======================================// //浮点数拓展 银行业务中钱怎么表示 //使用 BigDecimal 数学工具类 float f = 0.1f; double d = 1.0/10; System.out.println(f==d);//false System.out.println(f); System.out.println(d); //结论：最好完全使用浮点数进行比较，即 float和float比较 double和double比较 System.out.println("======================================"); float f1 = 113213112112f; float f2 = f1+1; System.out.println(f1); System.out.println(f2); System.out.println(f1==f2);//true 是因为超过精度导致f1和f2相等 System.out.println("======================================"); double d1 = .0; for (int i = 1; i <= 11; i++) { d1 += .1; } double d2 = .1 * 11; System.out.println(d1);//由于二进制与十进制转化的时候存不下丢了值导致结果不是1.1 System.out.println(d2); System.out.println(d1 == d2); System.out.println("======================================"); //======================================// //字符串拓展 char c1 = 'a'; char c2 = '赜'; System.out.println(c1); System.out.println((int)c1);//强制转换 System.out.println(c2); System.out.println((int)c2);//强制转换 //所有的字符本质还是数字 //编码 unicode 占2字节 0 - 65536 每个字符都有对应的数字 char c3 = '\u0061';//还可以直接用转义字符杠u+Unicode编码来表示一个字符 System.out.println(c3); System.out.println("======================================"); //======================================// //转义字符 //例如：\t 制表符 \n 换行 System.out.println("Hello\tWorld"); System.out.println("Hello\nWorld"); System.out.println("======================================"); //======================================// //布尔值扩展 boolean flag = true; if (flag==true){} if (flag){} //两句意思一样，代码要精简 } } - 数值类型
-
引用类型(reference type)
- 类 class
- 接口 interface
- 数组 数据类型 []
- 枚举 enum
-
转义符
-
\r 表示回车符
-
\n 表示换行符
-
\t 表示 Table 键制表符
-
\b 表示退格键，相当于 Back Space 键 表示单引号
注意：因为系统差异性，在不同的系统中 ，有时候 \r 起作用，有时候 \n 起作用。所以，一般建议：\r\n 连用，这样可以在任意系统中都可以换行。
-
变量、常量
-
变量：Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
type varName [=value] [{,varName[=value]}]; //数据类型 变量名 = 值；可以使用 , 隔开来声明多个同类型变量，不过不建议一行定义多个变量。 例： int num1 = 1 , num2 = 2;
tips:
-
每个变量都有类型，类型可以是基本类型，也可以是引用类型，例如String。
-
变量名必须是合法的标识符。
-
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
-
变量作用域：类变量、实例变量、局部变量
- 成员变量：成员变量分为类变量和实例变量，均存储在堆内存中。
- 类变量：声明的位置在类里面、方法的外面，用static修饰，也叫静态变量，生命周期跟随类。
- 实例变量：声明的位置在类里面、方法的外面，与类变量的区别是不用static修饰。
- 局部变量：声明的位置在类里面、方法()或{}内，存储在栈内存中。
tips：类变量和实例变量在加载类的时候会默认初始化，所以可以不赋值直接输出，输出值即为变量类型的默认值；而局部变量则不会被程序初始化，需要人工进行初始化，否则输出会报错；命名相同的变量不可存储在统一内存区域中。
public class Demo04 { //属性：变量 //类变量 static static double salary = 2500; //实例变量：从属于对象,如果不进行初始化，则为默认值,布尔值默认是false int age; String name; //main方法 public static void main(String[] args) { //局部变量：必须声明和和初始化值 //int i; //System.out.println(i);会报错，因为没有初始化i的值 int i = 10; System.out.println(i); //变量类型 变量名字 = new Demo04(); Demo04 demo04 = new Demo04(); System.out.println(demo04.age); System.out.println(demo04.name);//除了基本类型，其他类型的初始值都是null double salary = 1; // 局部变量 System.out.println(salary); // 输出时，优先找相同内存区域的变量，若找到，则直接输出，找不到时会换内存区域查找 /* * 输出结果为 * 10 * 0 age的值，因为没有赋值，int默认值为0 * null name的值，因为没有赋值,String默认值为null * 1.0 */ } } -
常量：初始化后不能再改变值。
-
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
-
常量名一般用大写字符。
final 常量名 = 值; final double PI = 3.14;public class Demo05 { //修饰符不区分前后，变量类型前的都是修饰符，下列语句等同 final static double PI = 3.14; static final double PI = 3.14; public static void main(String[] args) { System.out.println(PI); } } -
-
命名规范：
- 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词以外，后面的单词首字母大写lastName
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线MAX_VALUE
- 类名：首字母大写和驼峰原则：Man, GoodMan
- 方法名：首字母小写和驼峰原则run(), runRun()
类型转换
-
由于Java是强类型语言，所以要进行有些运算时，需要用到类型转换。
-
运算中，不同类型的数据先转化为同一类型，然后进行运算。
字节从低到高排列：
byte, short, char –> int –> long –> float –> double
由高到低转换：强制转换，格式为 (类型)变量名
由低到高转换：自动转换
tips：
-
不能对布尔值进行转换
-
不能把对象类型转换为不相干的类型
-
在把高容量转换到低容量的时候，强制转换
-
转换的时候可能存在内存溢出，或者精度问题
-
当表达式中所有的变量类型小于int的时候，运算后的结果都会自动提升为int类型。当表达式中有变量类型大于int的时候，运算后的结果以表达式中精度最高的为主。
public class Demo03 { public static void main(String[] args) { int i = 128; byte b = (byte)i;//强制转换格式 (类型)变量名 由高到低转换 double d = i;//自动转换 由低到高 System.out.println(i); System.out.println(b);//byte的范围是-128到127，所以128对于byte会内存溢出，输出的值会变 System.out.println(d); System.out.println("=============================="); //精度问题 System.out.println((int)23.7);//23 System.out.println((int)-45.89f);//-45 System.out.println("=============================="); char c = 'a'; int i1 = c+1; System.out.println(c); System.out.println(i1); System.out.println((char)i1); System.out.println("=============================="); //操作比较大的数的时候，注意溢出问题 int money = 1_000_000_000;//数字之间可以用下划线分割 int years = 20; int total1 = money*years;//-1474836480 计算时内存溢出了 long total2 = money*years;//先进行int类型的计算，再将结果转换成long类型,所以也会溢出 long total3 = ((long)money)*years; System.out.println(money); System.out.println(total1); System.out.println(total2); System.out.println(total3); } } -
运算符
-
Java语言支持如下运算符
算术运算符：+ , - , * , / , % (取余,模运算) , ++ , –
赋值运算符：=
关系运算符：> , < , >= , <= , == , != , instanceof
逻辑运算符：&&(与) , ||(或) , !(非)
位运算符：& , | , ^ , ~ , » , « , »>
扩展赋值运算符：+= , -= , *= , /=
条件运算符：? :
public class Demo01 {
public static void main(String[] args) {
//二元运算符
//CTRL+D 复制当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println(a/(double)b);
System.out.println("==================================");
long q = 1234567890L;
int w = 123;
short e = 10;
byte r = 8;
System.out.println(q+w+e+r);//long
System.out.println(w+e+r);//int
System.out.println(e+r);//int
//long以下运算结果都为int，long以上都为最高的那个类型
}
}
public class Demo02 {
public static void main(String[] args) {
//关系运算符 返回的结果为 true/false
int x = 10;
int y = 20;
System.out.println(x > y);//false
System.out.println(x < y);//true
System.out.println(x == y);//false
System.out.println(x != y);//true
// 若 == 两边是引用类型，那么比较的是他们内存地址是否相等
}
}
public class Demo03 {
public static void main(String[] args) {
//++ -- 自增 自减（一元运算符）
int a = 1;
int b = a++;
//a++ a = a + 1 先赋值，再运算a = a + 1
System.out.println(a);
int c = ++a;
//++a a = a + 1 运算完a = a + 1后再赋值
int i1 = 10;
int i2 = 10;
System.out.println(i1++); // i++放在输出语句里面，执行流程：1、先取出i的值10 2、执行输出语句，输出10、执行自增1，i变为11
System.out.println(++i2); // 执行流程：1、先先取出i的值10 2、执行自增1，i变为11，执行输出语句，输出11
byte x = 128;
x++; // ++隐含强制转换，相当于 x = (byte)(x + 1),所以输出结果为-128溢出了
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println("=====================");
//幂运算 2^3 2*2*2 = 8 很多运算，会使用一些工具运算
double pow = Math.pow(2,3);
System.out.println(pow);
}
}
public class Demo04 {
public static void main(String[] args) {
//逻辑运算符：与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a && b));
System.out.println("a || b:"+(a || b));
System.out.println("! (a && b):"+(! (a && b)));
//短路运算
int c = 5;
boolean d = (c < 4) && (c++ <= 10);
System.out.println(d);
System.out.println(c);//说明没执行c++，在判断了c<4为false后就终止了运算
}
}
public class Demo05 {
public static void main(String[] args) {
/*
位运算：二进制编码，对每一位进行运算
& 与 都为1时为1，其余为0，有0则为0
| 或 都为0时为0，其余为1，有1则为1
^ 异或 相同则为0，相反则为1
~ 取反
例：
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
---------------------
<< 左移,<< 运算结果为*2
>> 右移,>> 运算结果为/2
均是值二进制值左移或右移
例：如何最快计算2*8
直接处理二进制数最快,2<<3
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);//2*2^3
System.out.println(3<<1);//3*2^1
}
}
public class Demo06 {
public static void main(String[] args) {
//扩展赋值运算符 +=,-=,*=,/=
int a = 10;
int b = 20;
a+=b;//a = a + b
System.out.println(a);
a-=b;//a = a - b
System.out.println(a);
// 赋值运算符有隐含的强制转换
byte c = 127;
c += 1; //等同于 c = (byte)(c + 1);
System.out.println(c); // c = -128 数据溢出，未报错。
//字符串连接符 +
System.out.println(a+b);
System.out.println(""+a+b);//1020 +左右出现String类型时，自动将后续运算判断成字符串连接符
System.out.println(a+b+"");//30 从左至右运算
System.out.println(a+b+""+a+b);//301020 从左至右运算，在判断+右侧有字符串时，会将后续的+判断为字符串连接符
}
}
public class Demo07 {
public static void main(String[] args) {
// 三元运算符 ? :
// x ? y : z 条件 ? 真 : 假
// 如果x == true，则结果为y，否则为z
int score = 80;
boolean y = score < 60 ? false : true;
String type = score < 60 ? "不及格" : "及格";
System.out.println(y);
System.out.println(type);
}
}
-
运算符优先级
所有的数学运算都认为是从左向右运算的，Java语言中大部分运算符也是从左向右结合的，只有单目运算符、赋值运算符和三目运算符例外，其中，单目运算符、赋值运算符和三目运算符是从右向左结合的，也就是从右向左运算。
乘法和加法是两个可结合的运算，也就是说，这两个运算符左右两边的操作数可以互换位置而不会影响结果。运算符有不同的优先级，所谓优先级就是在表达式运算中的运算顺序。
Java 语言中运算符的优先级共分为 14 级，其中 1 级最高，14 级最低。在同一个表达式中运算符优先级高的先执行。
使用优先级为 1 的小括号可以改变其他运算符的优先级，即如果需要将具有较低优先级的运算符先运算，则可以使用小括号将该运算符和操作符括起来。例如下面的表达式：
(x-y)*z/5在这个表达式中先进行括号内的减法运算，再将结果与 z 相乘，最后将积除以 5 得出结果。整个表达式的顺序按照从左向右执行，比较容易理解。
再来看一个复杂的表达式，如下所示。
--y || ++x && ++z;这个表达式中包含了算术运算符和逻辑运算符。根据表 1 中列出的优先级，可以确定它的执行顺序如下：
- 先计算 y 的自减运算符，即 –y。
- 再计算 x 的自增运算符，即 ++x。
- 接着计算 z 的自增运算符，即 ++z。
- 由于逻辑与比逻辑或的优先级高，这里将 ② 和 ③ 的结果进行逻辑与运算，即 ++x && ++z。
- 最后将 ④ 的结果与 ① 进行逻辑或运算，即 –y||++x&&++z。
如果没有上述对该表达式执行顺序的说明，第一眼看到它时将很难识别优先级。对于这类问题，可以通过添加小括号使表达的顺序更加清晰，而不用去查优先级表。如下所示为改进后的表达式。
(--y)||((++x)&&(++z));例：
int a = 5;
int b = 4;
int c = a++- –b*++a/b– »2%a–;
问 c 的值是多少？
tips：
- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。
- 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用
()来控制表达式的执行顺序。
包机制
-
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
-
包语句的语法格式为：
package pkg[. pkg2[. pkg3...]]; -
一般利用公司域名倒置作为包名。 com.baidu.www
-
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能
import package1[.package2...].(classname|*);
JavaDoc
-
JavaDoc命令是用来生成自己API文档的
-
参数信息
-
@author 作者名
-
@version 版本号
-
@since 指明需要最早使用的JDK版本
-
@param 参数名
-
return 返回值的情况
-
throws 异常抛出情况
-
-
通过控制台生成java文件的文档（Idea可以直接生成）
javadoc -encoding UTF-8 -charset UTF-8 Doc.java #Doc.java是java文件名