第一章、概述
1.1、java
java语言是美国Sun（Stanford Universlty Network），在1995年推出的高级编程语言。
（1）JAVA语言发展历史
1995年Sun公司发布java 1.0版本
1997年发布java 1.2版本
2000年发布java 1.3版本
2002年发布java 1.4版本
2004年发布java 5版本
2006年发布java 6版本
2009年Oracle公司收购Sun公司，并于2011发布java 7版本。
2014年发布java 8版本
2017年9月发布java 9版本
2018年3月发布java 10版本
第二章、Java语言开发环境
2.1 Java虚拟机——JVM
JVM（Java Vritual Machine）：java虚拟机
跨平台：
PS：JVM处于操作系统与java程序中间位置，负责解释java程序，编译成操作系统能理解的语言，以实现java语言的跨平台性。
2.2 JRE与JDK
JRE（Java Runtime Environment）：java程序运行的环境，包含JVM和运行时所需要的核心类库。
JDK（Java Development Kit）：java程序开发工具包，包含JRE和开发人员使用的工具。
三者之间的关系：JDK ( 编译器等开发工具、JRE（运行类库、JVM）)
第三章、关键字与标识符
3.1、关键字
java语言中，有特殊含义的字符，例如：public、static、protected、private、class…
3.2、标识符
（1）概念
指在程序中，自定义的内容，如类名、方法名、变量名等。
（2）命名规则
①、标识符可以包含英文字母（区分大小写）、数字、$符号和 _(下划线)。
②、不能以数字开头。
③、不能使用关键字。
（3）命名规范
①、大驼峰方式，每个单词首字母大写（类名）。
②、小驼峰方式，首个单词首字母小写，剩余单词首字母大写（变量名、方法名）。
第四章、基本数据类型
（1）基本数据类型
| 序号 | 数据类型 | 位数 | 默认值 | 取值范围 | 举例说明 |
|---|---|---|---|---|---|
| 1 | byte(位) | 8 | 0 | -2^7 - 2^7-1 | byte b = 10; |
| 2 | short(短整数) | 16 | 0 | -2^15 - 2^15-1 | short s = 10; |
| 3 | int(整数) | 32 | 0 | -2^31 - 2^31-1 | int i = 10; |
| 4 | long(长整数) | 64 | 0 | -2^63 - 2^63-1 | long l = 10l; |
| 5 | float(单精度) | 32 | 0.0 | -2^31 - 2^31-1 | float f = 10.0f; |
| 6 | double(双精度) | 64 | 0.0 | -2^63 - 2^63-1 | double d = 10.0d; |
| 7 | char(字符) | 16 | 空 | 0 - 2^16-1 | char c = ‘c’; |
| 8 | boolean(布尔值) | 8 | false | true、false | boolean b = true; |
（2）数据类型默认值
| byte | 0 |
|---|---|
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | ‘u0000’ |
| String (or any object) | null |
| boolean | false |
（3）注意事项
① 、非基本数据类型都是引用数据类型，例如：类、接口、String、数组…
②、浮点型可能只是一个近似值，并非精确的值
③、数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节
④、浮点数默认数据类型是double，如果一定使用float类型，须加后缀F；整数的默认数据类型是int，如果要使用long类型，须加后缀L。
4.1、常量
（1）概念
程序运行期间，值不会改变的量。
（2）声明
//数据类型 常量名称 = 数据；
//两者都是常量，但是第二种声明方法可以更改值。
final String user = "张三";
String user = "张三";
ps：八种基本数据类型都可以是常量
（3）注意事项
①、空字符串常量是两个引号中间内容为空
②、字符常量引号仅有一个字符，没有不行，多也不行。
4.2、变量
（1）概念
程序运行期间，内容可以发生改变的量。
变量名称也称作对象，new的过程叫做实例化对象，会在内存的堆栈开辟空间。
（2）声明方法
1.
数据类型 变量名称；
变量名称 = 数据值；
2.
数据类型 变量名称 = new 数据类型；
（3）注意事项：
①、变量名称不允许重复。
②、对于float与long来说，字母后缀F与L不能丢掉。
③、如果使用byte或者short类型的变量，右侧数据值不能超过左侧数据类型的范围。
④、变量需要赋值后才能使用。
⑤、变量使用不能超过作用域（方法范围内）。
4.3、数据类型转换
Java程序中要求参与计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
（1）自动数据类型转换（隐式）
概念：代码不需要进行特殊处理，自动完成。
特点：数据类型转换，总是向大空间数据类型变换；
public class Demo01Type{
public static void main(String[] args){
System.out.println(1024);//这就是一个int类型
System.out.println(3.14);//这是一个double类型
long num = 100L;
long num2 = 100；
System.out.println(num);
System.out.println(num1);//不会报错，发生了自动类型转换。
}
}
（2）强制数据类型转换
概念：大变量空间向小变量空间进行转换。
public class Demo02Type{
public static void main(String[] args){
int num =100L;//会报错
int num1 =100;//不会报错
int num2 =(int)100L;//不会报错，强制数据类型转换
}
}
（3）注意事项
①、强制类型转换不推荐使用，容易造成整数数据溢出，小数精度损失.
②、byte、short、char三种数据类型都能发生数学运算。
③、byte、short、char三种数据类型在运算时，都会首先被提升为int类型，然后进行运算。
④、boolean类型不能发生数据类型转换。
第五章、常见引用数据类型
5.1、数组（[ ]）
（1）概念：是一种同时存储多个相同数据类型值的容器，且在运行期间其长度不可改变。
（2）数组初始化
①动态初始化
数组类型【】 数组名称 = new 数据类型【数组长度】
②静态初始化
数据类型【】 数组名称 = new 数据类型【】{元素1，元素2，元素3...} //完整静态初始化
数据类型【】 数组名称 = {元素1，元素2，元素3...} //省略静态初始化
③数组动态初始化，数组元素默认为0；
（3）访问数组获取元素
数组名称【索引值】（数组索引值从0开始，到数组长度减一）
String[] array=new String[]{hello,world,11};
System.out.println(array);//输出array数组对象的地址
System.out.println(array[0]);//结果是hello
System.out.println(array[1]);//结果是world
System.out.println(array[2]);//结果是11
（4）访问数组元素进行赋值
String[] array=new String[3];
array[0] = 123;
array[1] = 456;
array[2] = 789;
（5）获取数组长度
String[] array = new String[3];
int len = array.length;//获取数组array长度
5.2、集合（ArrayList）
（1）概念
与数组相同，但是集合长度可以随意改变。
（2）声明格式
ArrayList<String> List = new ArrayList<>();
（3）注意事项
①ArrayList 泛型：集合中所有元素都是类型E。
②泛型只能是引用数据类型，不能是基本类型。
③从JDK1.7开始，右侧的尖括号内可以不写注意内容，但是尖括号本身需要写。
④对于ArrayList直接打印，得到的不是地址而是内容，如果没有值就是 [ ]。
（4）集合内添加数据
list.add（赵丽颖）;
（5）常用方法
①public boolean add（E，e）：向集合内添加元素，参数类型与泛型一致。
②public E get（int index）：从元素中获取元素，参数是索引值。
③public E remove（int index）：删除索引对象的元素。
④public int size（）：获取集合尺寸长度，返回值是元素个数。
5.3、字符串(String)
（1）字符串特点
①Java程序中的所有字符串字面值（如：“abc”）都作为此类的实现。
②字符串内容不可改变，相当于字符串常量。
③字符串效果相当于char[] 字符数组，但是底层原理是byte[] 数组。
④字符串变量是StringBuffer，他的值可以修改。
（2）字符串创建3+1种方式
三种构造方法，一种直接或创建。
public class Demo{
public class void main (String[] args){
//直接引用
String str = 'hello world';
//无参构造方法
String str1 = new string();
System.out.println(str1);
//根据字符数组创建字符串，字符数组即字符串内容
char[] charArray = {'a','b','c'};
String str2 = new String(charArray);
//根据字节数组创建字符串，字节数组即字符串内容
byte[] byteArray = new String(97,98,99);
String str3 = new String(byteArray);
}
}
（3）字符串常量池（涉及内存图）
概念：字符串常量池，即声明字符串对象时未实例化对象，所以以这种方式声明的字符串，都被存储在字符串常量池内。字符串常量池，就是对象内存空间（堆）内的一块区域。
String str = "abc";
str+="def";
//虽然打印str的值是abcdef，但是abc并未改变，只是在字符串常量池中新开辟一个对象，并将地址赋给str。
（4）字符串获取方法
public int length：获取字符串长度
public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取索引位置的单个字符（索引从0开始）。
public int indexOf(String str)：查找参数字符串在文本字符串当中首次出现的索引位置，如果没有返回-1。
String str1 = "hello";
String str2 = "world";
//拼接字符串 str3为helloworld
String str3=str1.concat(str2);
//获取字符索引位置单个字符,str4的内容为l
String str4 =str3.indexOf(4);
//查找字符,str5是6
String str5 = str3.charAt("w");
（5）截取字符串
public String subString(int index)：截取字符串，从索引位置开始，一直到末尾。
public String substring(int begin,int end)：[begin,end),截去字符串，从begin开始，直到end结束。
（6）字符串转换相关方法
public char[] toCharArray()：将当前字符串拆分为字符数组作为返回值。 理解：字符数组，单指一个字符，可能是中文字符，也可能是用文字符。
public byte[] getBytes():获得当前字符串底层的字节数组 理解：字节数组，将字符串以字节为单位取出并使用。
public String replace(Charsequence oldString,charsequence newString): 将所有新出现的老字符，返回替换之后的结果新字符串。
String str = "hello world";
//str1的值是 h,e,l,l,o, ,w,o,r,l,d
String str1 =str.toCharArray();
//str2的值分别是str字符串的每个单个字符对应的ASCII码值
String str2 =str.getBytes();
//str3的值是 h*ll* w*rld
String str3 = str.replace("o","*");
（7）字符串切割
public String[] split(String regex)：按照regex规则，将字符串拆分成若干份。
注意：regex是正则表达式，split的参数也是正则表达式。
String str = "aaa,bbb,ccc";
//array数组内分别是aaa bbb ccc
String[] array = str.split(",");
（8）字符串代码示例
//从输入流中统计各种字符数量。
public class Demo{
public void main (String[] args){
Scanner sc = new Scanner;
System.out.println("请输入字符串");
String input = sc.next();
//四种字符数量的计数器
int countUpper = 0;
int countLower = 0;
int countNumber = 0;
int countOther =0;
char[] charsArray = input.toCharArray();
for(int i=0;i<=charsArray.length;i++){
char ch = charsArray[i];
if("A">=ch && "a"<=ch){
countUper+=1;
}else if('a'<=ch && ch<='z'){
countLower+=1;
}else if(''<=ch && ch<='9){
countNumber+=1;
}else {
countOther+=1;
}
}
Sysem.out.println("大写字母:"+countUpper);
Sysem.out.println("小写字母:"+countLower);
Sysem.out.println("数字："+countNumber);
Sysem.out.println("其他字符：“+countOther);
}
}
第六章、运算符
（1）概念
运算符：进行特定操作的符号。
表达式：用运算符连起来的式子。
6.1、算术运算符
（1）算数运算符表
| 运算符 | 结果 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法 |
| % | 余数 |
| ++ | 自增 |
| += | 加法分配 |
| -= | 减法分配 |
| *= | 乘法分配 |
| /= | 分配分配 |
| %= | 模量分配 |
| – | 自减 |
（2）加号
①、相加。
②、连接作用：字符串用加号连接，代表两个字符串连接到一起。在这里，加号起到连接作用。
（3）自增、自减运算符
①、单独使用时，前++与后++没有区别。
②、混合使用时，前++先执行自加运算，后进行操作；后++先执行操作，后进行自加。
pubnlic class Demo03Operater{
public static void main(String[] args){
int num = 10;
System.out.prinln(num);
//单独使用，前++
++num = 10
System.out.prinln(num);//num输出11
//单独使用，后++
num++
System.out.prinln(num);//num输出也是11
//混合使用,前++
System.out.prinln(++num);//num输出为11
//混合使用，后++
System.out.prinln(num++)；//num输出为10，但是变量num会变成11
}
}
（4）注意事项
①、一旦运算中数据类型不一样，那么结果将会是数据类型范围大的那种。
②、int + double = double + double = double
③、字符串参与计算，会自动装换成int类型再进行计算。
④、赋值运算符：+= 、-= 、*= 、 /= 、 %=
a+=b;//a=a+b
a-=b;//a=a-b
a*=b;//a=a*b
a/=b;//a=a/b
a%=b;//a=a%b
编译器会隐含强制类型转换:
byte num = 30;
num+=num+5;
num=num+5
byte=byte+int
byte=int+int
byte=(byte)int
6.2、逻辑运算符（布尔运算符）
（1）逻辑运算符表
| 运算符 | 结果 |
|---|---|
| & | 逻辑AND |
| | | 逻辑或 |
| ^ | 逻辑异或(异或) |
| || | 短路OR |
| && | 短路AND |
| ! | 逻辑一元NOT |
| &= | AND分配 |
| |= | OR分配 |
| ^= | XOR分配 |
| == | 等于 |
| != | 不等于 |
| ？ : | 三元if-then-else |
①、&&与 || 具有短路效果，如果根据左边条件可以判断最终结果，那么右边代码不再执行，从而节省一定性能。
②、&&与&、||与| 两者效果相同，只是前者具有短路效果。
（2）真值表
| A | B | A | B | A& B | A ^ B | !A |
|---|---|---|---|---|---|
| False | False | False | False | False | True |
| True | False | True | False | True | False |
| False | True | True | False | True | True |
| True | True | True | True | False | False |
6.3、关系运算符(比较运算符)
（1）关系运算符表
| 运算符 | 结果 |
|---|---|
| == | 等于 |
| != | 不等于 |
| > | 大于 |
| < | 小于 |
| >= | 大于或等于 |
| <= | 小于或等于 |
（2）注意事项
①、比较运算符的结果是布尔值
②、如果多次判断，不允许连这写。
8>x>3//写法错误
6.4、三元运算符
（1）使用方式
数据类型 变量名称 = expression1 ? expression2 : expression3
（2）判断顺序
expression1 可以是计算为boolean值的任何表达式，如果expression1 是 true ，那么执行expression2否则执行expression3。
（3）注意事项
①、expression2与expression3同事复合表达式左边的数据类型。
②、三元运算符结果必须被使用（执行处理或赋值）。
6.5、按位运算符
（1）按位运算符表
| 运算符 | 结果 |
|---|---|
| ~ | 按位一元NOT |
| & | 按位AND |
| | | 按位或 |
| ^ | 按位异或 |
| >> | 向右移动 |
| >>> | 右移零填充 |
| << | 向左移动 |
| &= | 按位AND分配 |
| |= | 按位OR分配 |
| ^= | 按位异OR分配 |
| >>= | 右移赋值 |
| >>>= | 右移零填充分配 |
| <<= | 向左移位 |
第七章、流程控制
（1）概述
在程序执行过程中，个语句执行顺序对程序结果又直接影响。
7.1、顺序结构
顺序结构，就是从上向下依序执行语句。
7.1、选择结构
7.1.1、单if语句
（1）标准格式
if(关系表达式){
语句体；
}
7.1.2、标准if else 语句
（1）、标准格式
if(关系表达式){
执行语句；
}else{
执行语句；
}
7.1.3、多分支if语句
if(关系表达式){
执行语句；
}else if(判断条件){
执行语句；
}
...
}else if(关系表达式){
执行语句；
}else{
}
6.1.4、switch语句
（1）、标准格式
swiitch(表达式){
case 常量值:
执行语句；
break;
case 常量值:
执行语句;
break
...
default:
执行语句；
break;
}
（2）、执行顺序
①、首先计算表达式的值
②、然后和case依次比较，一旦匹配成功，就执行相应语句，在执行过程中，遇到break就会结束switch语句。
③、最后如果与所有case不匹配，则则执行default语句，然后结束switch。
（3）、注意事项
①、多个case后面的值不能重复。
②、表达式数据类型只能是：byte、short、char、int；引用数据类型：String、enum（枚举）
③、switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句可以省略。
④、匹配哪一个case就从那个位置向下执行，直到遇到break。
7.3、循环结构
①、建议：凡是次数确定的场景多用用for循环，否则多用while循环。
7.3.1、for循环
（1）标准格式
for(初始化语句①；条件判断②；步进语句④){
循环体③；
}
（2）执行顺序
1234——>234——>234…2
一直到②不满足为止，程序跳出for循环。
7.3.2、while循环
（1）标准格式
while(表达式){
循环体；
}
①、只要满足表达式，程序就会一直执行循环体。
（2）拓展格式
初始化语句;
while(表达式){
循环体；
步进语句;
}
①、初始化语句，类似于循环控制条件，配合步进表达式。
②、while与for循环逻辑流程一样。
7.3.3、do while循环
（1）标准格式
do{
循环体；
}while(条件判断);
①、程序最先执行do后面的循环体一次。
②、然后执行while，如果条件判断为真，重新执行do，否则跳出循环。
（2）拓展格式
初始化语句;
do{
循环体；
}while(条件判断);
7.3.4、三种循环的区别
①、如果条件判断从未被满足，那么for循环和while循环执行0次，do while至少汇执行一次。
②、for循环的变量在小括号定义的，只能在for循环中使用。do while与while初始化语句在循环外定义，所以在循环外也可以使用。
7.3.5、循环控制语句break
（1）用法
①、常用在switch语句，一旦执行，整个switch语句立刻结束。
②、还可以使用在循环语句当中，一旦执行，整个循环立刻结束。
7.3.6、循环控制语句continue
（1）用法
①、一旦执行，立即跳过本次循环，进行下一次循环。
7.4.7、死循环
（1）、标准格式
while（true）{
System.out.println("Hello,World!!")
}
①、这种死循环常用在写线程，使线程在后台一直运行。
7.4.8、循环嵌套
概念：循环嵌套，是指一个循环的循环体是另一个循环，比如for循环里面还有一个for循环，就是循环嵌套。
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
