关键字
定义：被Java赋予特殊含义的英文单词。
特点：都是小写的英文单词。
标识符
·在程序中自定义的一些名称
·由26个英文字母大小写，数字：0-9，符合：_$组成
·定义合法标识符规则：1、数字不可以开头；2、不可以使用关键字
·Java中严格区分大小写
·注意：在起名字时，为了提高阅读性，要尽量起有意义的名字。
注释
·定义：用于注解说明解释程序的文字就是注释。
·作用：提高代码的阅读性，以及对程序进行调试
·Java中的注释格式：
1）单行注释——格式：//注释文字
2）多行注释——格式：/*注释文字*/
3）文档注释——格式：/**注释文字*/
·对于单行和多行注释，被注释的文字，不会被JVM（Java虚拟机）解析执行。
·对于文档注释，是Java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
·注释是一个程序员必须要具有的良好编程习惯。
·初学者编写程序可以养成习惯：先写注释再写代码。
·将自己的思想通过注释先整理出来，再用代码去体现。
·因为代码仅仅是思想的一种体现形式而已。
·注释的应用，例如：
常量和变量
（一）、常量：表示不能改变的数值
·Java中常量的分类：
1、整数常量：所有整数
2、小数常量：所有小数
3、布尔型（boolean）常量：较为特有，只有两个数值，true false。
4、字符常量：将一个数字字母或者符号用单引号（‘’）标识。
5、字符串常量：将一个或者多个字符用双引号（“”）标识。
6、null常量：只有一个数值就是null。
·对于整数：有四种表现形式。
1、二进制：0，1，满2进1
2、八进制：0-7，满8进1，用0开头表示
3、十进制：0-9，满10进1
4、十六进制：0-9，A-F，满16进1，用0x开头表示
（二）、变量：内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化
1、为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用
2、使用变量注意：变量的作用范围，初始化值
3、定义变量的格式：数据类型 变量名 = 初始化值;，比如 int a = 1; 格式是固定的，记住格式，以不变应万变。
用一个例子演示一下变量的运算：
上面说到了数据类型，那么数据类型有哪些呢？
Java 语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
进制
1、进制的转换，十进制转换成二进制，比如十进制的9转成二进制
2、那么二进制怎么转成十进制呢？用二进制的1001转成十进制，看看是不是9
我们十进制转二进制是除2的操作，那么二进制转十进制就是反过来，乘2的操作，所以
——方法一：1001：1 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 8 + 0 + 0 + 1 = 9，很显然二进制1001表示成十进制就是9
——方法二：二进制每一位从右往左分别对应的是1 2 4 8 16 32 ..... 其实就是对应方法一里的2的次方：2^0 2^1 2^2 2^3..... ， 1 * 8 + 0 * 4 + 0 * 2 + 1 * 1 = 9
二进制转换成八进制：比如，10101110转成八进制
——先把10101110以3位为一段分成3段，因为三个二进制位为一个八进制位，前面不够补0 --> 010 101 110 --> 每一段对应一个数字，用上面的方法计算即可得：2 5 6 那么转成八进制就是0256.
二进制转成十六进制：比如，10101110转成十六进制
——把10101110以四位一段分开，因为四个二进制位为一个十六进制位，就是1010 1110，用上面的方法计算就是10 14，那么计算的结果就是0xAE
负数的二进制表现形式
——对应的整数二进制取反+1 ： 比如，求-6的二进制表现形式
首先，计算出6的二进制为：0000-0110 （用一个8位表示）
然后，对0000-0110进行取反：1111-1001（实际就是0变1，1变0）
最后，对1111-1001 进行 +1 操作，得1111-1010，那么1111-1010就是十进制-6的表现形式
类型提升和强制转换
1、自动类型提升（也叫隐式类型转换）：只有类型一致的才可做运算，类型不同，内存就不同，那么Java中有自动类型提升来处理类型不同的运算，但是前提都是数值。
2、强制类型转换（也叫显示类型转换）：在不同类型数值做运算的时候，运算结果由于自动类型提升的原因，用内存小的变量接收结果，但由于结果内存大于用于接收的变量内存时，可以使用强制类型转换，但是要慎用，因为用得不准确，会损失精度。
所有的byte型、short型和char型的值都被提升到int型；
如果有一个操作数是long型，计算结果就是long型；
如果有一个操作数是float型，计算结果就是float型；
如果有一个操作数是double型，计算结果就是double型。
System.out.print('a'+1);这个语句输出的结果是：98，因为char和int运算结果提升为int型的。
运算符
1、算术运算符：
+（加） -（减） *（乘） /（除） %（取余，模运算） +（连接符） ++（自增，在原有数据基础上+1，再赋给原有数值） --（自减）
2、赋值运算符：
+= -= *= /= %=
3、比较运算符：
==（相等于） !=（不等于） <（小于） >（大于） <=（小于等于） >=（大于等于） instanceof（检查是不是类的对象）
例子：System.out.print(3==2);//结果是false，因为事实上3用于不等于2，所以是false，比较运算符的结果要么是true，要么是false
4、逻辑运算符：
用于连接多个boolean类型的表达式。
&（与）的运算规律：只要运算的两边只有有一个false，结果就肯定是false；只有两边都为true，结果就是true；
| （或）的运算规律：只要运算的两边只有有一个true，结果就肯定是true；只有两边都为false，结果才是false；
^（异或）的运算规律：两边符号如果相同，那么结果就是false；如果两边不同，结果就是true；
! （非），就是判断事物的另一面，运算规律：!true = false ; !false = true; !!true = true;；
&&（双与）：和&运算结果一样的，但是过程有点区别。只要一为false，后边的就不再执行，比如x = 1; x > 2 && x < 5 ; 当判断了1 > 2 时 为false，那么 x < 5 就不执行了。
| | （双或）：和 | 运算结果一样的，但是过程有点区别。只要一为true，后边的就不再执行，比如x = 1; x < 5 || x > 2; 当判断了1 < 5 时 为true，那么 x < 5 就不执行了。
5、位运算符：
6、三元运算符：
顾名思义，有三个元素符号参与运算，二话不说，直接上例子代码：int x = 3 > 1 ? 6 : 8;首先判断3 > 1是否为true，如果是true，那么x = 6 , 否则x = 8；
程序的流程控制
1、if语句的三种格式：
判断结构
2、switch语句
就是选择结构体，如果有符合switch(表达式)里的表达式的结果的，就执行对应的case里的语句，如果没有那就执行default的里边默认的执行语句。
建议：虽然在靠近结束的大花括号的可以不添加break；，但是我觉得添加会更好，因为在阅读性上有一点点优势，此外，break；的添加根据自己程序的逻辑需求。
if和switch的应用：
if：1、对具体的值进行判断。
2、对区间判断。
3、对运算结果是boolean类型的表达式进行判断。
switch：
1、对具体的值进行判断。
2、值的个数通常是固定的。
注意：对于几个固定的值判断，建议使用switch语句，因为switch语句将具体的答案都加载进内存。效率相对高一点。
3、循环结构
代表语句：while , do while , for
while语句格式：
while(条件表达式){
执行语句;
}
do while语句格式：
do{
执行语句;
}while(条件表达式);
do while特点：无论条件是否满足，循环体至少执行一次。
for语句格式：
for(初始化表达式; 循环条件表达式; 循环后的操作表达式)｛
执行语句;（循环体）
｝
注：
a，for里边的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。
b，while和for可以互换，区别在于for为了循环定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
c，最简单无限循环格式：while(true)，for(;;)，无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
注：什么时候使用循环结构呢？
当对某些代码执行很多次时，使用循环结构完成。
当对一个条件进行一次判断时，用if语句；当对一个条件进行多次判断时，可以使用while语句。
注意：
在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。
循环通常情况下，需要定义条件，需要控制次数。
函数
- 什么是函数？
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。 - 函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1,参数类型 形式参数2,……）
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算后的结果，该结果会返回给调用者。
特殊情况：功能没有具体的返回值。这时return的后面直接用分号结束。返回值类型怎么体现的呢？因为没有具体值，所以不可以写具体的数据类型。在Java中只能用一个关键字来表示这种情况，关键字是：void。
- 例子:
public class FunctionDemo
{
public static void main(String[] args)
{
//求1 + 2 + 3 + 4 + 5 的和
int sum = sum(1 , 5);
System.out.println("区间[1, 5]的和为："+sum);
myHello();//调用输出Hello World方法
}
/**
* 方法1，用于求区间[a,b]的和
* 参数a 左闭区间 参数b 右闭区间
* return 区间的和 sum
*/
public static int sum(int a,int b)
{
//用于累计和
int sum = 0;
//循环累加区间里的每一个元素，直到b为止
while(a <= b)
{
sum += a;
a++;
}
return sum;//将结果和返回，并结束函数
}
/**
* 方法2，用于输出"Hello World"
* 方法是可以无参数传入的
* 也可以无返回值，那就要用void表示返回值类型
*/
public static void myHello()
{
System.out.println("Hello World!");
//return; 可省略不写
}
}
函数的特点：
- 定义函数可以将功能代码进行封装
- 便于对该功能进行复用
- 函数只有被调用才会被执行
- 函数的出现提高了代码的复用性
- 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中return语句如果在最后一行可以省略不写。
- 注意：函数中只能调用函数，不可以在函数内部定义函数；定义函数时，函数的结果应该返回给调用者，交由调用者处理。
4.函数的重载：
- 重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
- 重载的特点：与返回值类型无关，只看参数列表。
- 重载的好处：方便于阅读，优化了程序设计。
- 重载的示例：
//返回两个整数的和 int add(int x, int y) { return x + y; } //返回三个整数的和 int add(int x, int y, int z) { return x + y + z; } //返回两个小数的和 double add(double x, double y) { return x + y; }
数组
数组的定义
- 概念：同一种类型数据的集合。其实数组就是一个容器。
- 数组的好处：可以自动给数组中的元素0开始编号，方便操作这些元素。
- 格式1：数据类型[ ] 数组名字 = new 数据类型[元素个数或者数组长度]；示例：int [ ] arr = new int [5];
- 格式2：元素类型[ ] 数组名字 = new 数据类型[ ]{元素，元素，......}；示例：int [ ] arr = new int[ ]{3, 5, 7, 1}; 或者 int [ ] arr = new {3, 5, 1, 7};
JVM的内存的划分
- 寄存器
- 本地方法区
- 方法区
- 栈内存：1、存储的都是局部变量；2、而且变量所属的作用域一旦结束，该变量就自动释放。
- 堆内存：存储的是数组和对象（其实数组就是对象），凡是new建立都在堆中。 特点：1、每一个实体都有首地址值；2、堆内存中的每一个变量都有默认的初始化值，根据类型的不同而不同。整数是0，小数是0.0或者0.0f，boolean false ， char ‘\u0000’；3、垃圾回收机制。
注意常见错误：
class ArrayDemo
{
public static void main(String[] args)
{
int[] arr = new int[3];
// System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
//当访问到数组中不存在的角标时，就会发生该异常。
arr = null;
System.out.println(arr[0]);//NullPointerException
//当引用型变量没有任何实体指向时，还在用其操作实体。就会发生该异常。
}
}
数组的遍历
数组的基本动作就是存和储，核心思想就是对角标的操作。
例子，获取数组长度，输出每一个元素，以及获取最值：
class ArrayDemo
{
public static void main(String[] args)
{
int arr[] = {12, 523, 6, 12, 6, 7, 1234};
//打印数组arr的元素个数（长度）
System.out.println("lenght："+ arr.length);
//遍历输出数组的每一个元素
for(int i = 0; i < arr.length ; i++)
{
System.out.println("arr[" + i + "] = " + arr[i] + ";");
}
/* 获取数组中的最大值和最小值
* min用于记录在数组前i个中的最小值，max是最大值
* min和max，一开始初始化为数组中的第一个元素
*/
int min = arr[0] , max = arr[0];
for(int i = 1; i < arr.length ; i++)
{
//发现有比min还小的，那就更新min
if(min > arr[i])
min = arr[i];
//发现有比max还大的，那就更新max
if(max < arr[i])
max = arr[i];
}
System.out.println("arr数组中最大值max="+max);
System.out.println("arr数组中最小值min="+min);
}
}
数组的排序
数组元素查找
二分查找：
//给定有序的数组arr，以及查找的元素
public static int halfSearch(int[] arr, int key)
{
int min = 0;
int max = arr.length - 1;
int mid = (min + max) / 2;
while(arr[mid] != key)
{
// 要找的数在角标mid的左边
if(arr[mid] > key)
max = mid - 1;
// 要找的数在角标mid的右边
else if(arr[mid] < key)
min = mid + 1;
// 不能再折半了，数组里没有这个数
if(max < min)
return -1;
// 继续折半
mid = (max + min) / 2;
}
return mid;
}
数组中的数组
格式1：int[ ][ ] arr = new int[3][2];
- 定义l名称为arr的二维数组
- 二维数组中有3个一维数组
- 每一个一维数组中有2个元素
- 一维数组的名称分别为arr[0],arr[1],arr[2]
- 给第一个一维数组1角标为赋值为78的写法是：arr[0][1] = 78；
格式2：int[ ][ ] arr = new int[3][ ];
- 二维数组中有3个一维数组
- 每个一维数组都是默认初始化值null
- 可以对这个三个一维数组分别进行初始化
- arr[0] = new int[3];
- arr[1] = new int[1];
- arr[2] = new int[2];
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
