基础知识：
java编译运行过程:
java源文件(.java)，经过编译，编译为java字节码文件(.class)，然后通过JVM来加载.class并运行.class文件
不同系统有不同的JVM，但对.class是一样的
java可以实现跨平台
一次编程到处运行
JDK:java开发工具包
JRE:java运行环境
JVM:java虚拟机
JRE=JVM+java系统类库
JDK=JRE+编译、运行等开发环境
运行的最小环境为JRE
开发的最小环境为JDK
IDE:集成开发环境，eclipse是JAVA最主流的IDE
eclipse为IBM公司的，开源的
变量：
变量是一个代词，指代内存中的数据 变量是可以改变的量---指代不同的数据
变量必须先声明，再使用
语法: 数据类型 变量名;
int a;
可以一条语句声明多个同类型变量
eg: int a,b,c;
int a=1,b,c=2;
变量的命名:
规定:
1)只能包含字母、数字、_、$，并且不能以数字开头
2)严格区分大小写
3)不能使用关键字(java已经用了的字)
建议:
1)不建议中文命名变量
2)最好"见名知意"
3)驼峰命名法:第一个单词首字母小写，其余单词首字母大写
变量的初始化:
java语法规定:变量在使用前必须初始化
初始化两种方式:
1)声明同时初始化
int a=5;
2)先声明再初始化
int b;
b=8;
变量的使用:
1)必须与数据类型匹配
eg: int a=2.5; //错误，类型不匹配
数据类型：
int:
1)整型，占4个字节，范围-21个多亿到21个多亿
2)整数直接量(25,250,2500...)，默认为int类型
3)两个整数相除，结果为整数(无条件舍去小数位)
int型变量只占4字节
long:
1)长整型，占8个字节，范围特别大(足够用)
2)long型直接量，在数字后面加l或L
eg: long a = 35L;
int a=10000000000; //错误
long a = 10000000000; //错误
long a = 10000000000L;//正确
float:
1)单精度浮点型，占用4字节。
2)float型直接量直接在浮点数后加f或者F
double:
1)双精度浮点型，占8个字节。
2)浮点型直接量（1.1，1.0，……）默认为double
char:
1)字符型。占用一个字节
2) 赋值是用单引号（''）括起来
3) 字符型变量只接受一个字符。
eg： char c = 'a';
char c ='ab' //错误。
boolean：
1) 布尔型变量，属于int的子集。
2)只有两个值 true 和 false。
3)一切非0值代表true其余代表false。
各个类型之间的转换： 变量 = （需要转换的类型）变量
eg int a = 10;
long l = (long)a;
逻辑运算符：
&&:两边都为真，则为真
||:有一边为真，都为真
!:非真则假，非假则真
Java中的HelloWorld：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Java中main方法为程序的入口。
Java中输出语句为：System.out.println();
Java接收用户输入:
import java.util.Scanner; //1.导入Scanner包
public class HelloWorld {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in); //2.创建Scanner对象
System.out.println("请输入你的年龄：");
int age=scan.nextInt(); //3.等待用户输入一个int型变量。
System.out.println("请输入你的身高：");
double height = scan.nextDouble();//等待用户输入一个double变量
boolean b1 = age>=18 && age<=50;//判断年龄是否在18-50之间。
System.out.println(b1); //true
}
接受用户输入主要分为3步：
1）import java.util.Scanner; //导入Scanner包
2）Scanner scan = new Scanner(System.in); //创建一个scanner对象。
3）int age=scan.nextInt(); //3等待用户输入。
运算符：
表格中的实例假设整数变量A的值为10，变量B的值为20：
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
| / | 除法 - 左操作数除以右操作数 | B / A等于2 |
| ％ | 取模 - 左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21（区别详见下文） |
| -- | 自减: 操作数的值减少1 | B-- 或 --B 等于 19（区别详见下文） |
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println("a + b = " + (a + b) );
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a * b) );
System.out.println("b / a = " + (b / a) );
System.out.println("b % a = " + (b % a) );
System.out.println("c % a = " + (c % a) );
System.out.println("a++ = " + (a++) );
System.out.println("a-- = " + (a--) );
// 查看 d++ 与 ++d 的不同
System.out.println("d++ = " + (d++) );
System.out.println("++d = " + (++d) );
}
}
结果如下：
a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5 a++ = 10 a-- = 11 d++ = 25 ++d = 27
自增自减运算符
1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
public class selfAddMinus{
public static void main(String[] args){
int a = 3;//定义一个变量；
int b = ++a;//自增运算
int c = 3;
int d = --c;//自减运算
System.out.println("进行自增运算后的值等于"+b);
System.out.println("进行自减运算后的值等于"+d);
}
}
运行结果为：
进行自增运算后的值等于4 进行自减运算后的值等于2
解析：
-
int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
-
int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2
2、前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
3、后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 实例：
实例
public class selfAddMinus{
public static void main(String[] args){
int a = 5;//定义一个变量；
int b = 5;
int x = 2*++a;
int y = 2*b++;
System.out.println("自增运算符前缀运算后a="+a+",x="+x);
System.out.println("自增运算符后缀运算后b="+b+",y="+y);
}
}
运行结果为：
自增运算符前缀运算后a=6，x=12 自增运算符后缀运算后b=6，y=10
关系运算符
下表为Java支持的关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假(非真)。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）非真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：
A = 0011 1100 B = 0000 1101 ----------------- A&b = 0000 1100 A | B = 0011 1101 A ^ B = 0011 0001 ~A= 1100 0011
下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13：
| 操作符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 如果相对应位都是0，则结果为0，否则为1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真。 |
赋值运算符
下面是Java语言支持的赋值运算符：
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A等价于C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
三目运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false
public class Test {
public static void main(String[] args){
int a , b;
a = 10;
// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;
System.out.println( "Value of b is : " + b );
// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
b = (a == 10) ? 20 : 30;
System.out.println( "Value of b is : " + b );
}
}
以上实例编译运行结果如下：
Value of b is : 30 Value of b is : 20
运算符优先级：
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
| 类别 | 操作符 | 关联性 |
|---|---|---|
| 后缀 | () [] . (点操作符) | 左到右 |
| 一元 | + + - ！〜 | 从右到左 |
| 乘性 | * /％ | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 关系 | >> = << = | 左到右 |
| 相等 | == != | 左到右 |
| 按位与 | ＆ | 左到右 |
| 按位异或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 逻辑与 | && | 左到右 |
| 逻辑或 | | | | 左到右 |
| 条件 | ？： | 从右到左 |
| 赋值 | = + = - = * = / =％= >> = << =＆= ^ = | = | 从右到左 |
| 逗号 | ， | 左到右 |
分支结构：
if 语句的用语法如下：
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。
if...else语句
if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
if...else if...else 语句
if 语句后面可以跟 elseif…else 语句，这种语句可以检测到多种可能的情况。
使用 if，else if，else 语句的时候，需要注意下面几点：
- if 语句至多有 1 个 else 语句，else 语句在所有的 elseif 语句之后。
- if 语句可以有若干个 elseif 语句，它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
嵌套的 if…else 语句
嵌套的else只与最近的if相配对。
switch 语句
switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
语法
switch 语法格式如下：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch 语句有如下规则：
-
switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串类型了，同时 case 标签必须为字符串常量或字面量。
-
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
-
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
-
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
-
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
-
switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
循环语句：
循环三要素:
1.循环变量初始化
2.循环条件(以循环变量为条件)
3.循环变量的改变(向着循环结束变)
循环变量:在循环过程中改变的那个量
int count=1; //跑的圈数---计数
count<=3 //条件------------跑
count++; //改变计数
count=1 true 跑
count=2 true 跑
count=3 true 跑
count=4 false
while 循环
while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
//循环内容
}
do…while 循环
对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。
for循环
虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for(初始化; 布尔表达式; 更新) {
//代码语句
}
关于 for 循环有以下几点说明：
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}
以上实例编译运行结果如下：
10,20,30,40,50, James,Larry,Tom,Lacy,
break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
嵌套循环执行过程:
外层循环走一次，内层循环走所有次
建议:
循环层数越少越好
break:
只能跳出一层循环
数组：
1.数组可以装一组数，必须类型相同
2.数组按线性顺序，一个跟一个
3.数组也是一种数据类型
4.数组new之后，数组中的每个元素都有一个默认值
整数:0 浮点数:0.0 boolean:false
1)数组的定义:
int[] arr = new int[4]; //每个数都是0
2)数组的初始化
int[] arr; //声明数组
arr = new int[4]; //初始化
int[] arr = {1,5,8,3}; //只能声明同时初始化
int[] arr = new int[]{1,5,8,3};
int[] arr;
arr = {1,5,8,3}; //错误
3)数组的访问:通过下标
下标从0开始
int[] arr = new int[4]; System.out.println(arr.length);//数组的长度4 arr[0] = 55;//给arr中的第1个数赋值为55 arr[4] = 99; //错误，数组越界，最大到3 System.out.println(arr[2]);//输出第3个数
遍历数组：
//遍历数组
int[] arr = {1,8,5,3};
for(int i=0;i<arr.length;i++){ //正序
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){ //倒序
System.out.println(arr[i]);
}
int[] arr = {2,9,6,1,56,67,234,45,7657,234};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
声明一个整型数组名为a，可以存储4个整数
int[] a = new int[4];
double[] s = new double[4];
String[] ns = new String[10];
数组的.length：
int[] arr = new int[5];
int i = arr.length; //5
数组
1)定义
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[5];
2)初始化
int[] arr = new int[3]; //默认值为0
int[] arr = {2,4,7};
int[] arr = new int[]{2,4,7};
3)访问:通过下标/索引
int len = arr.length; //长度
int num = arr[0]; //取第1个元素
int num = arr[arr.length-1];//取最后1个元素
arr[0] = 88; //赋值
System.out.println(arr[0]); //取值
4)复制
//从a的第1个元素开始
//复制到a1中，从第3个元素开始
//一共复制4个元素
System.arraycopy(a,0,a1,2,4);
//将a数组复制到b数组，b有6个元素
int[] b = Arrays.copyOf(a,6);
//给a数组扩容
a = Arrays.copyOf(a,a.length+1);
5)排序
Arrays.sort(arr); //升序
dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法
注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
方法（函数，过程）：
方法：也叫函数、过程。
1）用于封装一段特定的逻辑功能。
2）尽可能独立。 （一个方法只干一件事）
3）可以在程序中反复调用。
4）避免了代码的冗余。便于的代码的维护，有利于团队协作开发。
方法的定义：五要素
1）修饰词
2）返回值类型：
-可以有返回值也可以没有返回值。没有返回值写void，有返回值写特定的返回值类型。
-方法执行完后需要用到方法中的某个数据 ----需要返回值。
-通过return语句返回，return语句的作用在于结束方法并将数据返回。
3）方法名：见名知意。
4）参数列表：在调用时传递给方法 ，需要被方法处理的数据
-可以有参数，也可以无参数。 ----有参更灵活。
-在调用时，会将实际的参数值传递给方法的参数 变量，必须保证传递参数的类型和个数符合方法的声明
5）方法体：放在一对大括号内。
修饰词 返回值类型 方法名(参数列表){
方法体
}
当方法需要返回结果时，设计特定返回值类型
不需要结果时，返回值类型为void
返回结果通过return关键字