关键字
指赋予特殊含义，具有专门用途的单词，如class、int、static、void等。
标志符
就是给类、接口、方法、变量等起的名字。
组成规则：a～z、A～Z、0～9、$、_ 不能以数字开头，不可以使用关键字。
（必须以字母、下划线、或$符号开头，不能用数字开头）
命名规则：
a.包名：多单词组成时，所有字母小写，使用点号连接，如aaa.bbb.ccc
b.类名或接口名：大驼峰式，如AaaBbbCcc
c.变量名或方法名：小驼峰式，如aaaBbbCcc
d.常量名：多单词组成时所有字母大写，使用下划线连接，如AAA_BBB_CCC
常量：
常量就是不变的数据量，执行过程中值不变。
数据类型：
Java语言是强类型语言。
基本数据类型：
整数（byte、short、int、long）
小数（float、double）
字符（char）
布尔（boolean）
引用数据类型：
强大的数据类型，基于基本数据类型创建。
整数不同进制表示法：
a.十进制：正常数字，如12，25
b.二进制：以0b（0B）开头，如0b1011、0B1001
c.十六进制：以0x（0X）开头，由0～9和A～F组成，如0x23A2、0xa、0x10
d.八进制：以0开头，如01、0721
字符和字符串简单区别：
字符：字符必须使用' '（单引号）括起来，并且必须包含且只能包含一个字符
字符串：字符串是一种引用类型，必须使用""（双引号）括起来，其中可以包含0～N哥字符
基本类型（4类8种）：
| 四类 | 八种 | 字节数 | 数据表示范围 |
|---|---|---|---|
| 整型 | byte | 1 | -128～127 |
| 整型 | short | 2 | -32768～32767 |
| 整型 | int | 4 | |
| 整型 | long | 8 | |
| 浮点型 | float | 4 | |
| 浮点型 | double | 8 | |
| 字符型 | char | 2 | 表示一个字符，如'a'、'A' |
| 布尔型 | boolean | 1 | 只有两个值true和false |
java中默认的整数类型是int
java中默认的浮点类型是double
数据类型转换（两种方式）：
自动类型转换：范围小的数据类型转换成范围大的数据类型
double d = 100;
或
int i = 100;
double d2 = i;
强制类型转换：范围大的数据类型转换成范围小的数据类型
int i = (int) 6.718;
或
double d = 3.14;
int i2 = (int)d;
Scanner类
Scanner类是引用数据类型的一种，Scanner使用步骤如下：
//创建Scanner引用类型的变量
Scanner sc = new Scanner(System.in);
//获取数字
int n = sc.nextInt();
//获取字符串
String str = sc.next();
随机数类Random
用来产生随机数的类Random，也是引用数据类型，使用如下：
//创建Random类的实例
Random r = new Random();
//得到0～100(不包含100)范围内的随机整数
int i = r.nextInt(100);
//得到0.0~1.0(不包含1.0)范围内的随机小数
double d = r.nextDouble()
最简单的无限循环：
while(ture){} 或 for(;;){}
跳转语句（break、continue）
1、break
break用在switch条件语句中时，作用是终止某个case并跳出switch；
break用在循环语句中时，作用是跳出循环语句，执行后面的代码；
2、标记
当break出现在嵌套循环中的内存循环时，它只能跳出内层循环。如果想使用break语句跳出外层循环则 需要对外层循环添加标记。
itcast:
for (int i = 0; i <= 9; i++) { //外层循环
for (int j = 0; j <= i; j++) { //内层循环
if (i > 4) {
break itcast; //跳出外层循环
}
}
}
3、continue
continue语句在循环语句总，作用是：终止本次循环，执行下一次循环。
Switch
当条件判断较多时，可以用switch语句来实现。例子如下：
int weeek = 5;
switch (week) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
default:
System.out.println("其他工作日和周末");
break;
}
在jdk1.7之后，switch语句中的表达式为byte、short、char、int、enum、String类型。
在switch语句中，如果多个case条件后面的执行语句是一样的，则该执行语句只需写一次即可，例子如下：
int week = 2;
switch (week) {
case1:
case2:
case3:
case4:
case5:
Sytem.out.println("今天是工作日");
break;
case6:
case7:
System.println("今天是休息日");
break;
}
JVM内存划分
JVM对自己的内存划分为5个区域：
a：寄存器：内存和cpu之间；
b：本地方法栈：jvm调用了系统中的功能；
c：方法区和数据共享区：运行时期class文件进入的地方；
d：方法栈：所有的方法运行的时候进入内存；
e：堆：存储的是容器和对象；
数组
数组变量保存的是数组在内存中的地址；数组初始化3种方式：
1.动态初始化 int[] arr = new int[3]
2.静态初始化 int[] arr = new int[]{1, 2, 3}
3.静态初始化（简便，推荐） int[] arr = {1, 2, 3}
二维数组
定义二维数组的三种方式：
1、int[][] arr = new int[3][4]
2、int[][] arr = new int[3][] 这种方式和第一种方式类似，只是内层数组的长度不确定。
3、int[][] arr = {{1,3}, {3,4,5,6}, {7,8.9}}
方法
方法的语法格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2, .....){
执行语句
......
return 返回值;
}
方法的重载
Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。
例如以下三个方法互为重载关系：
public static int add(int x, int y){}
public static int add(int x, int y, int z){}
public static int add(double x, double y){}
-
重载方法参数必须不同：参数个数不同、参数类型不同、参数顺序不同；（满足其一）
-
重载只与方法名和参数类型相关，和返回值无关：
如
void method(int x)和int method(int y)不是方法重载，不能同时存在 -
重载与具体变量标识符无关：
如
method(int x)和method(int y)不是方法重载，不能同时存在
参数传递
-
方法参数是基本类型时，传递的是值；形参的改变，不会影响实际参数的值；
-
方法参数是引用类型时，传递的是内存地址值；形参的改变会影响实际参数的值
引用数据类型--类
- java中的数据类型分为：基本类型和引用类型；
- 引用类型的分类：
- Java为我们提供好的类，如Scanner、Random等；
- 我们自己创建的类，按照类的定义标准，类中包含方法和属性；
自定义类的内存图
对象内存图.JPG
类中的属性，跟随容器进入到内存，属性进入内存，赋予默认值；
两个引用类型变量内存图
两个引用变量内存图.JPG
创建引用类型的变量，只要new了，内存中就会开辟一个新的内存空间，内存中将有自己的属性;
ArrayList创建变量的步骤
//数据类型<集合存储的数据类型> 变量名 = new 数据类型<集合存储的数据类型>();
ArrayList<String> array = new ArrayList<String>();
ArrayList<Integer> array = new ArrayList<Integer>();
//集合存储的数据类型：要将数据存储到集合的容器中;存储引用类型，不存储基本类型
//创建集合引用变量的时候，必须要指定好存储的类型是什么
ArrayList的常见方法
add(param) 向集合中添加元素
ArrayList<String> array = new ArrayList<String>();
array.add("abc");
get(int index) 取出集合中的元素
String a = array.get(0);
size() 返回集合的长度，集合存储元素的个数
int size = array.size();
ArrayList的补充方法
add(int index, param) 将元素添加到指定的索引上
ArrayList<Integer> array = new ArrayList<Integer>();
array.add(2, 7);
set(int index, param) 对指定索引上的元素进行修改
array.set(0, 10);
remove(int index) 删除指定索引上的元素
array.remove(4);
clear() 清空集合中的所有元素
array.clear();
ASCII编码编码表
计算机中，所有的数据在存储和运算时都要使用二进制数表示。
对应ASCII编码十进制：
0～9：对应48～57；A～Z对应65～90；a～z对应97～122；
char类型的存储
- short：占两个字节，是有符号数据，取值范围-32768~32767
- char：占两个字节，是无符号数据，取值范围0~65536
- int：占4个字节
1、char转成int类型的时候，类型自动提示，char数据类型，会查询编码表，得到整数；
2、int转成char类型的时候，强制转换，会查询编码表；
3、char存储汉字，查询unicode编码表
4、char可以和int计算，提示为int类型，内存中寸两个字节
数组逆序
public static void reverse(int[] array) {
for(int min = 0, max = array.length - 1; min < max; min++, max--) {
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
}
选择排序
//数组中的每个元素都进行比较
public static void selectSor(int[] array) {
//外循环，控制的是一共比较了多少次
for (int i = 0; i < array.length - 1; i++) {
//内循环，控制的是每次比较了多少个元素
for (int j = i; j < array.length - 1; j++) {
if (array[j + 1] < array[i]) {
int temp = array[i];
array[i] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
冒泡排序
//数组中的相邻元素进行比较
public static void bubbleSor(int[] array) {
//数组循环的圈数为数组长度-1
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j + 1] < array[j]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
数组的折半查找(二分查找)
/**
* 1.定义三个变量 min mid max
* 2.循环条件 min <= max
* 3.goal > arr[mid] min = mid + 1
* goal < arr[mid] max = mid - 1
* goal == arr[mid] find
* 4.循环结束，无法折半，元素没有找到
*/
public static int binarySearch(int[] array, int goal) {
int min = 0;
int max = array.length - 1;
int mid = 0;
while (min <= max) {
mid = (min + max) / 2;
if (goal < array[mid]) {
max = mid + 1;
} else if (goal > array[mid]) {
min = mid + 1;
} else {
System.out.println("find the goal, the goal index is: " + mid);
return mid;
}
}
System.out.println("the goal is not in the array");
return -1;
}
网友评论