Java基础语法

来源：互联网发布：大数据用到的java 编辑：程序博客网时间：2024/06/05 05:41

Java语言基础组成

关键字

定义：被Java语言赋予了特殊含义的单词
特点：关键字中所有字母都为小写

标识符

由26个英文字母大小写，数字，下划线_，美元符号$ 组成。
数字不可以开头。
不可以使用关键字。
严格区分大小写。
Java中的名称规范：
- 包名：多单词组成时所有字母都小写。
  xxxyyyzzz
- 类名接口名：多单词组成时，所有单词的首字母大写。
  XxxYyyZzz
- 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。
  xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接。
  XXX_YYY_ZZZ

注释

对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

常量与变量

常量：
- 常量表示不能改变的数值。
- Java中常量的分类：
  1. 整数常量。
    - 三种表现形式：
      - 十进制：0-9 ，满10进1.
      - 八进制：0-7 ，满8进1. 用0开头表示。
      - 十六进制：0-9，A-F，满16进1. 用0x开头表示。
  2. 小数常量。
  3. 布尔型常量。只有两个数值，true、false。
  4. 字符常量。将一个数字、字母或者符号用单引号( ' ' )标识。
  5. 字符串常量。将一个或者多个字符用双引号标识。
  6. null常量。只有一个数值就是:null.
进制的基本转换
- 十进制与二进制互转
  - 十进制转成二进制：除以2取余数，逆序排列。
  - 二进制转成十进制：乘以2的幂数
- 十进制与八进制互转：先将十进制与二进制互转，再将二进制与八进制互转
- 十进制与十六进制互转：先将十进制与二进制互转，再将二进制与十六进制互转
- 负数的二进制表现形式：
  - 对应的正数二进制取反加1。
  - 一个整数占四个字节，负数的最高位都是1。
变量：
- 概念：在内存中开辟一个空间，该空间有自己的名称（变量名）和类型（数据类型），在该空间内存储不确定的数据。
- 变量的作用范围：一对{}之间有效，但不能违背先定义后使用的原则。
  - 局部变量在进行取值操作前，必须被初始化或进行赋值操作，否则会出现编译错误。
- 定义变量的格式：数据类型变量名 = 初始化值;
- Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间:
  数据类型取值范围byte1个字节short2个字节int4个字节long8个字节float4个字节double8个字节char2个字节
- 整数的默认类型为int，小数的默认类型为double。
- 表达式的数据类型自动提升：
  - 所有的byte型、short型和char的值将被提升到int型。
  - 如果一个操作数是long型，计算结果就是long型；
  - 如果一个操作数是float型，计算结果就是float型；
  - 如果一个操作数是double型，计算结果就是double型。

运算符

算术运算符
- 算数运算符如下图：
- 如果对负数取模，可以把模数负号忽略不记，但被模数如果是负数，负号不能忽略。如：5%-2=1、-5%2=-1。
- 使用“+”连接字符串与非字符串，非字符串会先被转换成字符串，再与其他字符串连接。
转义字符：
- 通过“\”来转变后面字母或者符号的含义\n换行\b退格\r回车\t制表符\"打印双引号\\打印\
- windows中回车由两个字符来表示\r\n
赋值运算符
- 赋值运算符如下图：
- 面试问题：
  - short s = 3;
    s=s+2;
    s+=2;
    上面两句有什么区别？
  - s=s+2;//编译失败，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型。
    s+=2;//编译通过，因为+=运算符在给s赋值时，自动完成强制类型转换。
比较运算符：
- 比较运算符如下图：
- 比较运算符的结果都是boolean型，要么是true，要么是false。
逻辑运算符
- 逻辑运算符如下图：
- 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
- “&”和“&&”的区别：
  - 单&时，左边无论真假，右边都进行运算；
  - 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
- “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
- 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
位运算符
- 位运算符如下图：
- 位运算是直接对二进制进行运算。
- 位运算符的细节如下图：
- 一个数异或同一个数两次，结果还是这个数。如：7 ^ 4 ^ 4 = 7，这个规律可以作为加密的一个应用，4相当于一个秘钥。
- 移位运算符适用的数据类型：byte，short，int，long，char。
  - 对低于int类型的操作数将先自动转换为int类型再移位。
  - 对于int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数。
    例如：a >> 33和a >> 1的结果是一样的。
    a >> 32的结果还是a。
  - 对于long型整数移位a>>b，系统先将b对64取模，得到的结果才是真正移位的位数。
  - 注意，移位操作不会改变变量本身的值。
    如a >> 1;在一行语句中单独存在毫无意义，因为它没有改变a的值，也没有把它赋给别的变量。
  - <<：相当于乘以2的移动的位数次幂。
  - >>：相当于除以2的移动的位数次幂(该规律只对正数有效)。
  - 利用位运算进行乘除运算的效率是最高的。
- 位运算的应用：
  - 十进制转十六进制：利用&15,>>>4，依次获得从最低位开始的每四位二进制数对应的十六进制数。
  - 十进制转八进制：利用&7,>>>3，依次获得从最低位开始的每三位二进制数对应的八进制数。
三元运算符
- 格式：
  - (条件表达式)?表达式1：表达式2；
  - 如果条件为true，运算后的结果是表达式1；
  - 如果条件为false，运算后的结果是表达式2；

程序流程控制

判断结构：if语句
- if语句的三种格式：
- if语句第二种格式与三元运算符的区别：
  - 三元运算符可以简化if-else代码
  - 三元运算符要求表达式1和表达式2必须为一个可以返回的结果。而if-else语句不要求必须返回结果。
选择结构：switch语句
- switch语句的格式：
- switch语句特点：
  - switch语句选择的类型只有四种：byte，short，int ，char。
  - case之间与default没有顺序。先执行第一个case，没有匹配的case才执行default。
  - 结束switch语句的两种情况：遇到break，执行到switch语句结束。
  - 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
循环结构：while ， do-while ， for语句
- while语句格式：
- do-while语句格式：
- for语句格式：
- do-while语句的特点是条件无论是否满足，循环体至少被执行一次。
- for语句里面的表达式运行的顺序是，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。
- while与for语句可以互换，区别在于for语句的计数器为局部变量，while语句的计数器为成员变量。
- 最简单无限循环格式：
  while(true){}
  for(;;){}//for的条件表达式默认为true
其他流程控制语句：break(跳出)，continue(继续)
- break语句用于选择结构和循环结构。
- continue语句用于循环结构。
- 这个两个语句单独存在下面都不可以有语句，因为执行不到。
- continue语句是结束本次循环继续下次循环。
- break和continue都可以使用循环标记，用于跳出循环。

函数

函数的定义
- 函数就是定义在类中的具有特定功能的一段独立小程序。
- 函数的格式：
  
  返回值类型：函数运行后的结果的数据类型。
  参数类型：是形式参数的数据类型。
  形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
  实际参数：传递给形式参数的具体数值。
  return：用于结束函数。
  返回值：该值会返回给调用者。
函数的特点
- 定义函数可以将功能代码进行封装
- 函数的出现提高了代码的复用性
- 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
- 函数中只能调用函数，不可以在函数内部定义函数。
函数的应用
- 明确要定义的功能最后的结果是什么，即明确函数的返回值类型。
- 明确在定义该功能的过程中，是否需要未知内容参与运算，即明确函数的参数列表。
函数的重载(overload)
- 概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
- 特点：重载只看参数列表。重载的函数返回值类型可以相同也可以不同。
- 好处：方便于阅读，优化了程序设计。

数组

数组的定义
- 概念：同一种类型数据的集合。数组就是一个容器。
- 好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
- 格式：
  1. 元素类型[] 数组名= new 元素类型[元素个数或数组长度];
    示例：int[] arr = new int[5];//arr是数组类型（引用数据类型）
  2. 元素类型[] 数组名= new 元素类型[]{元素，元素，……};//静态初始化
    示例：int[] arr = new int[]{3,5,1,7};
    int[] arr = {3,5,1,7};
数组的内存分配
- Java将内存分为五个区域：栈内存，堆内存，方法区，本地方法区，寄存器。
  - 栈内存：用于存储局部变量，包括函数中定义的一些基本类型的变量和对象的引用变量。当数据使用完，所占空间会自动释放。
  - 堆内存：用于存储有new创建的对象和数组，包括对象的成员变量。当数据使用完，会在不确定的时间内被垃圾回收器回收。
  - 方法区：用于存储被加载的类信息、静态变量和常量。
  - 堆内存中的元素都有默认初始化值：
    元素类型默认初始化值int0double0.0float0.0fbooleanfalse引用类型null
  - 垃圾回收机制：
    - 栈内存中的垃圾会自动释放。局部变量在程序运行到其作用域之外后被释放。
    - 堆内存中的垃圾会由虚拟机不定时进行垃圾回收。数组和对象在没有引用变量指向它时，会变为垃圾，并在随后一个不确定的时间被回收。因此，java程序比较占内存。
    - 对象被当成垃圾从内存中释放前（不是对象变成垃圾前），会调用Object类的finallize()方法启用垃圾回收器。垃圾回收器的启用不由程序员控制，也无规律可循，甚至有可能到程序终止都没有启动的机会，因此它不是一个可靠的机制，我们无法保证每个对象的finallize()方法最终都会被调用。
    - System.gc()方法可以强制启动垃圾回收器来回收垃圾。程序在调用该方法时，JVM会根据需要在单独的线程中自动执行回收过程。
- 数组内存结构如下图：
数组操作常见问题：
- ArrayIndexOutOfBoundsException：数组越界异常。访问到了数组中的不存在的角标时发生。
- NullPointerException：空指针异常。当引用没有任何指向，且被用于操作实体时发生。
- 注意：以上两个异常，编译时不会报错，运行时才会报错，都属于RuntimeException

数组常见操作

遍历：

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,5,8,45,56,79,35};printArray(arr);}//定义功能，用于打印数组中的元素，元素间用逗号隔开public static void printArray(int[] arr){//遍历数组for (int i = 0; i < arr.length; i++) {//如果不是最后一个元素，在元素后面打印一个逗号//否则在元素后面打印回车换行if (i != arr.length - 1) {System.out.print(arr[i] + ",");} else {System.out.println(arr[i]);}}}}

打印结果：

获取最值(最大值，最小值)：

方法一：定义临时变量存储最大值和最小值

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,5,8,45,56,79,35};int max = getMax(arr);int min = getMin(arr);System.out.println("max = " + max);System.out.println("min = " + min);}//获取数组中的最大值public static int getMax(int[] arr){int max = arr[0];//数组中的最大值for (int i = 1; i < arr.length; i++) {if (max < arr[i]) {max = arr[i];}}return max;}//获取数组中的最小值public static int getMin(int[] arr){int min = arr[0];//数组中的最小值for (int i = 1; i < arr.length; i++) {if (min > arr[i]) {min = arr[i];}}return min;}}

打印结果：

方法二：定义临时变量存储最大值和最小值的下标

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,5,8,45,56,79,35};int max = getMax(arr);int min = getMin(arr);System.out.println("max = " + max);System.out.println("min = " + min);}//获取数组中的最大值public static int getMax(int[] arr){int max = 0;//数组中的最大值的下标for (int i = 1; i < arr.length; i++) {if (arr[max] < arr[i]) {max = i;}}return arr[max];}//获取数组中的最小值public static int getMin(int[] arr){int min = 0;//数组中的最小值的下标for (int i = 1; i < arr.length; i++) {if (arr[min] > arr[i]) {min = i;}}return arr[min];}}

打印结果：

排序：

选择排序

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,8,5,45,56,79,35};printArray(arr);//打印排序前的数组selectSort(arr);printArray(arr);//打印排序后的数组}//选择排序方法//定义嵌套循环，内循环结束一次，i所在下标位上的最值出现一次public static void selectSort(int[] arr){//确定arr[i]元素排序后对应的值for (int i = 0; i < arr.length - 1; i++) {//arr[i]依次和后面的arr[j]进行比较//如果arr[i] > arr[j]，则交换两个元素的位置//内循环结束后，arr[i]的值小于所有后面元素的值for (int j = i + 1; j < arr.length; j++) {if (arr[i] > arr[j]) {swap(arr, i, j);}}}}//交换数组中指定元素的位置public static void swap(int[] arr, int a,int b){int temp;temp = arr[a];arr[a] = arr[b];arr[b] = temp;}//打印数组中的元素public static void printArray(int[] arr){System.out.print("[");for (int i = 0; i < arr.length; i++) {if (i != arr.length - 1) {System.out.print(arr[i] + ",");} else {System.out.println(arr[i] + "]");}}}}

打印结果：

冒泡排序

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,8,5,45,56,79,35};printArray(arr);//打印排序前的数组bubbleSort(arr);printArray(arr);//打印排序后的数组}//冒泡排序方法//定义嵌套循环，内循环结束一次，(arr.length - i - 1)所在下标位上的最值出现一次public static void bubbleSort(int[] arr){//控制循环次数，每循环一次，(arr.length - i - 1)所在下标位上出现最大值for (int i = 0; i < arr.length - 1; i++) {//从0下标位开始依次比较相邻的两个元素//如果arr[j] > arr[j + 1]，交换两个元素的位置//内循环结束后，arr[j + 1]的值大于所有前面元素的值for (int j = 0; j < arr.length - i - 1; j++) {if (arr[j] > arr[j + 1]) {swap(arr, j, j + 1);}}}}//交换数组中指定元素的位置public static void swap(int[] arr, int a,int b){int temp;temp = arr[a];arr[a] = arr[b];arr[b] = temp;}//打印数组中的元素public static void printArray(int[] arr){System.out.print("[");for (int i = 0; i < arr.length; i++) {if (i != arr.length - 1) {System.out.print(arr[i] + ",");} else {System.out.println(arr[i] + "]");}}}}

打印结果：

以上两种的运行效率不是很高，实际开发中可以选择Arrays.sort方法进行排序。

折半查找(二分查找)：前提条件是数组为有序数组。

方法一：

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,5,8,35,45,56,79};System.out.println("index = " + halfSearch(arr, 8));System.out.println("index = " + halfSearch(arr, 60));}//折半查找，返回对应的数组下标，如果没有匹配的元素，则返回-1public static int halfSearch(int[] arr, int key){int min = 0;//下标范围最小值int max = arr.length - 1;//下标范围最大值int mid = (min + max)/2;//用于折半的下标中间值//如果key与当前arr[mid]对应元素不相等，循环折半查找while (key != arr[mid]) {//如果key比中间值小，下标范围最大值应移至中间下标左侧if (key < arr[mid]) {max = mid - 1;} //如果key比中间值大，下标范围最小值应移至中间下标右侧else {min = mid + 1;}//如果下标范围最大值小于下标范围最小值//说明数组中没有与key匹配的元素，返回-1if (max < min) {return -1;}//重新计算用于折半的下标中间值mid = (min + max)/2;}return mid;}}

打印结果：

方法二：

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,5,8,35,45,56,79};System.out.println("index = " + halfSearch(arr, 8));System.out.println("index = " + halfSearch(arr, 60));}public static int halfSearch(int[] arr, int key){int min = 0;//下标范围最小值int max = arr.length - 1;//下标范围最大值int mid;//用于折半的下标中间值//如果下标范围最小值不大于下标范围最大值，循环折半查找while (min <= max) {mid = (min + max)/2;//计算当前的下标中间值//如果key比中间值小，下标范围最大值应移至中间下标左侧if (key < arr[mid]) {max = mid - 1;} //如果key比中间值大，下标范围最小值应移至中间下标右侧else if(key > arr[mid]){min = mid + 1;}//如果key等于中间值，则返回中间值的下标else{return mid;}}return -1;//没有匹配的元素}}

打印结果：

练习：有一个有序的数组，想要将一个元素插入到该数组中，且保证该数组还是有序的。

package cn.itcast.heima;public class Test {public static void main(String[] args) {int[] arr = {3,5,8,35,45,56,79};System.out.println("index = " + getIndex(arr, 8));System.out.println("index = " + getIndex(arr, 80));}public static int getIndex(int[] arr, int key){int min = 0;int max = arr.length - 1;int mid;while (min <= max) {mid = (min + max)/2;if (key < arr[mid]) {max = mid - 1;}else if(key > arr[mid]){min = mid + 1;}else{return mid;}}return min;//数组中没有与key匹配的元素，将key插入min下标的位置}}

打印结果：

二维数组：
- 格式1：int[][] arr = new int[3][2];
- 格式2：int[][] arr = new int[3][];//每个一维数组都是默认初始化值null
- 格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
- 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。