一、标识符
1、定义
用来标识变量名、符号常量名、函数名、数组名、文件名、类名、对象名等，按一定的规则命名的符号。
2、命令规则：
- 以英文字母、下划线、美元符“$”作为首字母；
- Java语言使用Unicode字符集，包括A~Z，a~z以及序号大于0xC0的所有字符；
- 标识符区分字母大小写；
- 标识符的字符数目没有限制，但为了便于阅读和记忆，不宜太长。
3、命令方式
Camel（驼峰命名法）
- 除第一个单词之外，其他单词首字母大写，如：dataBaseUser；
- Java的方法使用这种命名，C#的字段使用这种命名法。
Pascal（帕斯卡命名法）
- 所有单词首字母大写，如：DataBaseUser；
- Java的类使用这种命名法，C#的类和方法使用这种命名法。
匈牙利命名法
基本原则是，变量名=属性+类型+对象描述，其中每一对象的名称都要求有明确含义，可以取对象名字全称或名字的一部分。如：dbUser
二、变量
1、变量的概述
内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。变量其实就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。
2、变量的命名
遵循标识符的命名规则，可以中文命名，但不建议，建议:"见名知意"，"驼峰命名法"。
3、变量的声明
int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型的变量，名为b,c,d4、变量的初始化
声明的同时初始化
int a = 250; //声明整型变量a并赋值为250先声明后初始化
int a; //声明整型变量a
a = 250; //给变量a赋值为2505、变量的使用
对变量操作就是对它所存的那个数的操作
int a = 5;
int b = a+10; //取出a的值5，加10后，再赋 值给b
System.out.println(b); //输出变量b的值15
System.out.println("b"); //b，双引号中的原样输出
a = a+10; //取出a的值5，加10后，再赋值给a
System.out.println(a); //输出变量a的值15变量的操作必须与数据类型匹配
int a = 3.14; //编译错误，数据类型不匹配变量在用之前必须声明并初始化
System.out.println(m); //编译错误，m未声明
int m;System.out.println(m); //编译错误，m未初始化三、数据类型
1、整数类型
字节型（byte）
- 1个字节，取值范围在-128~127之间，默认值为0；
byte a = 20;
byte b = -129;//编译错误
byte c = 128;//编译错误短型（short）
- 2个字节，取值范围在-32768~32767之间，默认值为0；
short a = 20;
short b = -32769;//编译错误
short c = 32768;//编译错误标准型（int）
- 4个字节，取值范围在-2147483648~2147483647之间，默认值为0；
- 整数直接量默认为int型，但不能超出范围，超范围则编译错误；
- 两个整数相除，结果还是整数，小数位无条件舍弃；
- 整数运算时若超出范围，则发生溢出，溢出是需要避免的。
int a = 20;
int = -2147483649;//编译错误
int = 2147483648;//编译错误
int d = 30 / 5;
int e = 2147483646 + 5;//编译错误长型（long）
- 8个字节，取值范围在-2^63~2^63 -1之间，默认值为0L；
- 长整型直接量需在数字后加L或l；
- 运算时若有可能溢出，建议在第1个数字后加L；
- 超过long的范围的数使用BigInteger，BigInteger范围是无穷大。
2、浮点类型
单精度（float）
- 4个字节，取值范围在-3.40282347E+38~3.40282347E+38之间，默认值为0.0f；
双精度（double）
- 8个字节，默认值为0.0D
浮点数直接量默认为double型，若想表示float，需在数字后加f或F；double数据在参与运算时，有可能会出现舍入误差，所以精确运算场合一般使用BigDecimal。
3、字符类型（char）
- 2个字节，取值范围在\u0000~\uFFFF之间，默认值为\u0000；
- 采用Unicode编码格式，每个字符都对应一个码,表现形式是字符char，但实质上是码int,ASCII('a'--97 'A'--65 '0'--48)
- 字符直接量必须放在单引号中，有且仅有一个；
- 特殊字符需通过\来转义。
4、布尔类型（Boolean）
- 1个字节， 只能存储true或false，默认值为false；
5、类型转换
基本类型从小到大依次为: byte,short,int（char）,long,float,double ；
两种方式
- 自动类型转换:从小类型到大类型；
- 强制类型转换:从大类型到小类型， 语法: (要转换为的类型)变量；
- 强转有可能会溢出或丢失精度。
两点规则
- 整数直接量可以直接赋值给byte,short,char，但不能超出范围；
- byte,short,char型数据参与运算时， 先一律转换为int再运算。
四、运算符
1、算术运算符：+，-，*，/，%，++，--
两个操作数全是byte类型，short类型或char类型，表达式结果都为int类型
在Java中，对取模运算符%来说，其操作数可以是浮点数
2、赋值运算符：=，+=，-=，*=，/=，%=
3、关系运算符：>，<，>=，<=，==，!=
4、逻辑运算符：&&，||，!
5、位运算符：>>，<<，>>>，&，|，^，~
6、三目/条件运算符：?数1：数2
7、其他运算符
字符串连接运算符：+
分量运算符：.
下标运算符：[]
实例运算符：instanceof
内存分配运算符：new
强制类型转换运算符：（类型）
方法调用运算符：（）
五、基础结构
1、顺序结构
2、分支机构
2.1、if(表达式) {语句体}
int a = 12;
if(a / 2 == 0) {
System.out.println("a是一个偶数");
}2.2、if(表达式) {语句体}else{语句体}
int a = 12;
if(a / 2 == 0) {
System.out.println("a是一个偶数");
} else {
System.out.println("a是一个奇数");
}注意：else子句不能单独作为语句使用，它必须和if子句配对使用
2.3、if(表达式) {语句体}else if(表达式) {语句体}else if(表达式) {语句体}
注意：else总是与离它最近的if配对使用
2.4、switch(表达式) { case 值1:语句体1；break；case 值2:语句体2；break；…default:语句体n+1;break;}
注意：
- 多个case后面的数值不可以重复；
- 表达式的取值是有限定 的：byte，short，int，char；
- 在JDK7之后，表达式的取值也可以是String类型；
- switch语句格式灵活，前后顺序可以颠倒，break语句可以省略。
3、循环结构
3.1、循环描述
- 循环是程序设计语言中反复执行某些代码的一种计算机处理过程， 是一组相同或相似语句被有规律的重复性执行。
3.2、循环要素
- 循环变量的初始化；
- 循环的条件：循环得以继续执行下去的条件，常常以循环次数的方式体现；
- 循环体：被反复执行的相同或相似的语句；
- 步进语句：每次循环之后进行的扫尾工作，每次循环结束之后都要执行一次
3.3、循环格式
while语句
- 通常用于循环次数不确定的情况，也可以用于循环次数确定的情况
do-while语句
- 如果循环要素的1和3相同时，用do{}while（boolean表达式）；在循环最后判断是否结束的循环。
for语句
- 通常用于循环次数确定的情况，也可以根据循环结束条件完成循环次数不确定的情况
注意：for中定义的用于控制次数的循环变量，只在for中有效，for结束则循环变量被释放（回收）
3.4、循环替换
- while(布尔表达式){} 等价于 for(;布尔表达式;){}
- while(true){} 等价于 for(;;)
- while(true){} +break 等价于 do{} while(布尔表达式)；
- for(;;) +break 等价于 do{} while(布尔表达式)；
3.5、循环问题
3.6、跳转语句
break语句
- 最常用与switch语句中，通过break语句退出switch语句；
- 也可以用于退出循环，执行循环语句后面的语句；
- break语句的另一个作用就是提供“标签化中断”语句，格式为：break BlockLabel；
continue语句
- 跳出本次循环，执行下一次循环
return语句
- 从当前方法中退出，返回到调用该方法的语句处，执行后面的语句
六、方法入门
1、方法的概述
定义
定义在类中的具有特定功能的一段独立小程序。
格式
修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，...) {
方法体;
return返回值;
}
2、方法的特点
- 定义函数可以将功能代码进行封装；
- 便于对该功能进行复用；
- 函数的出现提高了代码的复用性。
3、方法使用
- 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写，或者写上return;
- 函数中只能调用函数，不可以在函数内部定义函数。否则，编译时期就会报错；
- 定义函数时，函数的结果应该返回给调用者，交由调用者处理。
4、方法的重载
概念
- 在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
好处
- 方便于阅读，优化了程序设计。
注意
- 重载与返回值类型和参数名称无关，只看参数列表；
- java是严谨性语言，如果函数调用出现不确定性，会编译失败
5、递归操作
递归概述
递归：方法定义中调用方法本身的现象
注意事项
- 要有出口，否则就是死递归；
- 次数不能太多，否则就内存溢出；
- 构造方法不能递归使用。
递归实现步骤
- 递归方法；
- 递归的出口条件；
- 递归的规律。
经典案例：斐波那契数列
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
public static int fib(int n) {
if (n == 1 || n == 2) {
return 1;
} else {
return fib(n - 1) + fib(n - 2);
}
}6、注意事项
- 方法不能嵌套；
- 方法没有前后顺序；
- 方法调用后才会执行；
- return的返回值必须和方法的返回值类型一致。
七、数组入门
1、数组的概述
相同数据类型元素的集合，是一种数据类型（引用类型）
好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
2、数组的特点
- 数组是一种引用类型；
- 数组中的多个数据类型必须统一；
- 数组的长度在程序运行期间不可改变。
3、数组的定义
int[] arr = new int[5]
int arr[] = new int[5]4、数组的初始化
动态初始化
int[] arr = new int[5]静态初始化
int[] arr = new int[]{1,3,5,7,9};省略格式静态初始化
int[] arr = {1,3,5,7,9};5、数组的使用
5.1、数组的访问
通过（数组名.length）可以获取数组的长度
int[] arr = new int[6];
System.out.println(arr.length); //6通过下标/索引来访问数组中的元素（下标从0开始，最大到元素个数-1）
int[] arr = new arr[3];
arr[3] = 100;//数组下标越界异常5.2、数组的遍历
int[] arr = new arr[5]{1,3,5,7,9};
for(int i =0;i<arr.length;i++){
System.out.println(arr[i]);
}5.3、数组的复制
System.arraycopy(Object src, int srcPos, Object dest,int destPos, int length )：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。灵活度好,效率高。
说明：
src：源数组
srcPos：源数组中的起始位置
dest：目标数组
destPos : 目标数组中的起始位置
length：要复制的数组元素的数量
int[ ] a = { 10 ,20 ,30 ,40 ,50 };
int[ ] a1 = new int[ 6 ] ;
System.arraycopy( a , 1 , a1 , 0 , 4 );
结果：20,30,40,50Arrays.copyOf(int[] original, int newLength)：复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。灵活度不高，效率低。
说明：
original - 要复制的数组
newLength - 要返回的副本的长度
--生成的新数组是原始数组的副本；
--newLength小于源数组，则进行截取；（自己通过代码演示效果）；
--newLength大于源数组，则用0或 null进行填充(扩容：指创建一个更大的新数组并将原有数组的内容复制到其中。)；
int [ ] a = { 10,20,30,40,50 } ;
a = Arrays . copyOf ( a, a.length+1 );5.4、数组的排序
选择排序
- 首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。
- 经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数第二小的元素。
- 依次类推，直到最后一个元素。
public static void selectSort(int[] arr){
for(int i = 0; i < arr.length - 1; i++){
for(int j = i + 1; j < arr.length; j++){
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}冒泡排序
- 首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
- 经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
- 第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
- 依照此方式，一直到只有第一和第二个元素互相比较而结束。
public static void bubbleSort(int[] arr){
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1; j++) {
if (arr[j] < arr[j + 1]) {
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
}
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
