java基础语法-扩展

Java基础法语持续发布中，欢迎大家提出建议

Java基础语法

• 1. java命名规范
  • 1.1. 标识符命名规范
    • 1.数字0-9、字母A-Z、下划线_、$ 2.数字不能开头 3.不能是关键字（保留字） goto const 作为保留字 true false main 不是关键字 *Java 严格区分大小写
  • 1.2. 对象名命名规范
    • 项目名、包名： 全部小写、多单词组成，所有字母小写 类名、接口名：（驼峰命名法）构造方法 多单词组成，首字母全部大写 变量(属性)名、函数(方法)名： 多单词组成时，第一个单词首字母小 写，之后首字母大写 常量名： 所有字母大写中间用下划线_隔开
• 2. Java注释规范
  • 1. 注释规范
    • 1./** 文档注释 */--类前注释 2./* 多行注释 */--函数之前注释 3.//单行注释 --代码注释
  • 2. 类、属性、方法
    • 1.类注释 /** 在每个类前面必须加上类注释，注释模板如下： Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd. FileName: Test.java 类的详细说明 @author 类创建者姓名 @Date 创建日期 @version 1.00 */ 2.方法注释 /** 类方法的详细使用说明 * @param 参数1 参数1的使用说明 @return 返回结果的说明 @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明 */ 3.属性注释 在每个属性前面必须加上属性注释，注释模板如下： /** 提示信息 */ private String strMsg = null;
• 3. 关键字
  • 3.1. 定义数据类型
    • Java 八大基本数据类型 byte short int long float double char Boolean void
  • 3.2. 定义逻辑判断
    • true false (0 1) null
  • 3.3. 定义流程控制
    • 分支：if else 条件：switch case default 循环：while do for 跳转：break continue return
  • 3.4. 定义访问权限
    • private protected public default
  • 3.5. 定义类、函数、变量
    • abstract final static class extends implements interface
  • 3.6. 定义实例
    • new this super instanced instanceof (实例)
  • 3.7. 定义异常
    • try catch finally throw throws
  • 3.8. 其他
    • 1.包 package import 2.其他 同步：synchronizof synchronized 本地的：native 严格的：strictfp 短暂的：transient 易变的：volatile 断言：assert 3.保留字 goto const
• 4. 数据结构
  • 4.1. 常量
    • 常量：表示不能改变的值 --修饰符(final) 整数常量，所有整数。 小数常量。所有小数。 布尔型常量。较为特有，只有两个数值。true false。 字符常量。将一个数字字母或者符号用单引号（‘’）标识。 字符串常量。将一个或者多个字符用双引号("")标识。 null常量。只有一个数值就是：null. 格式： final 常量类型 常量标识符=常量值; 1.整数常量的四种表达 二进制0-1D 十进制0-9 B 八进制0-7 用0开头 十六进制0-9 A-F 用0x(H)开头 2.负数 2.1负数的二进制表达 原码=》反码=》补码 取反加1--负数的最高位是1 *展示数字的二进制 integer.toBinaryString(-6); .toBinaryString--到二元字符串 2.2负数求余 负数求余数时，首先忽略余数，然后根据被模数的符号决定结果正负。--前面的决定符号
  • 4.2. 变量
    • 变量的概念： ·内存中存在一个存储区城 ·该区城有自己的名称（变量名）和类型（数据类型）：基本类型和引用类型。 ·该区城的数据可以在同一类型范围内不断变化、多次使用。 简言之：名称+数据类型+数据可变。 为什么使用变量？ ·用来不断的存放同一类型的常量，并可以重复用使用变量。 ·方便内存调用，不同的数据长度使用不同的变量类型。 ·内存地址与变量名对应。 变量的定义： 1.格式 数据类型 变量名=初始化值； 2.注意事项 · 先声明--再定义--然后使用 *可以连续声明 · 变量的作用范围（一对括号之间有效） · 初始化值
  • 4.3. 常变量、字符常量
    • 常变量：具有变量的特征的存在一个以变量名命名的存储单元，但是存储单元中的内容不允许变化。--常量命名，内容不变，优化调用（命名空间） const float pi = 3.1415;//常变量 符号常量：是使用一个字符串代替程序中出现的一个标识符，是编译时把所有的符号常量都替换成制定的字符串，它没有类型，在内存中也不存在以符号常量命名的存储单元。在其作用域内其值不能改变和赋值。--编译替换，作用域不变。 #define Pi 3.1415//符号常量--*编译转换，便于修改 二者的性质不同，#define是预编译指令，在预编译后，符号常量就就不存在了（全部置换成3.1415），对符号常量的名字是不分配储存单元的。而常变量要占用存储单元，有变量值，该值不能改变。
  • 4.4. 基本数据类型(8)
    • 4.4.1. 整型(byte、short、int、long)
      • 数值型：默认值0 byte 字节型 1个字节 -128~127 short 短整型 2个字节 -2^15~2^15-1—32768^32767 int(默认) 整型 4个字节 -2^31~2^31-1 2…（10）手机号存不下 long 长整型 8字节 -2^63~2^63-1 --数字后+L 获取最大值 和最小值 int max= Integer.MAX_VALUE; int min= Integer.MIN_VALUE;
    • 4.4.2. 浮点型(float、double)
      • 浮点型：默认值 0.0 float 单精度浮点型 4字节 6、7位有效数字--数字后加f或F说明数据类型 double(默认) 双精度浮点型 8字节 15位有效数字（D-可省）
    • 4.4.3. 字符型(char)
      • 字符型：默认值 ' \u0000' ' ' char 单引号 '' 2个字节 ASCII码表 a --97 A--65
    • 4.4.4. Boolean
      • Boolean布尔类型：默认 false (true|false)
    • 默认初始值
  • 4.5. 引用数据类型(4)
    • 4.5.1. 类
    • 4.5.2. 接口
    • 4.5.3. 数组
    • 4.5.4. 枚举
    • 对象
      • {对象Object} 类 class（String） 接口interface 数组[ ] 枚举{.,.,.} 引用数据类型输出的结果为内存地址：[I@ffffff;--四位四六进制数 引用数据类型默认值为：对应；
  • 4.6. 转换
    • 4.6.1. 进制转换
      • 进制转换：进制 数码 基数 位权 1.低位-->高位：2(111),10 数码*位权，相加 1*2(0)+1*2(1)+1*2(2)=7 --位权：进制（第几位-1） 2.高位-->低位：10(7.7),2 整数部分除基数取余(到0)倒置 111 小数部分乘基取整 1011001100最后4位循环 结果111.1011001100 代码表示： 1.低位-->高位：10->16 system.out.println(Integer.toHexString()); 2.高位-->低位 StringBuffer sb=new StringBuffer(); while(num>0){ sb.append(num%2); num=num%2; }System.out.print(sb.reverse());--倒叙输出数值
    • 4.6.2. 类型转换(三类两型)
      • 4.6.2.1. 1.基本数据类型之间的转换
        • 基本数据之间隐式转换： 小-->大 byte>short>int>long>float>double 基本数据之间强制转换（丢失精度）： 大-->小 b=(byte)(b+2); 数字转化特例： short a=4;--1 a+=4;--2 a=a+4;--3--编译失败 12是一步运算3是两步运算
      • 4.6.2.2. 2.字符串与其他数据类型之间的转换
      • 4.6.2.3. 3.引用类型之间的转换
        • 类类型转换(子父类之间)： Animal a=new Dog();//向上转型 Cat cat= (Cat)animal;//向下转型(强)
      • 三类
      • 4.6.2.4. 强制类型转换
      • 4.6.2.5. 隐式类型转换
      • 两型
  • 4.7. 正则表达式
    • 正则表达式：是一组公式,描述了一种字符串匹配的格式。--描述字符串格式的一组公式。 正则表达式通常被用于判断语句中,用来检查某一字符串是否满足某一格式。我们可以调用 String 中的 matches( String regex); 方法,判断字符串是否匹配给定的正则表达式,返回布尔值 例如：str.matches("[a-z]"); 字符串是否是小写字母a-z中的某一个字母 正则表达式元字符： 正则表达式是含有些具有特殊意义字符的字符串,这些特殊字符称为正则表达式的元字符。例如,“\\d”表示数字0~9中的任何一个,“\\d”就是元字符。 正则表达式限定符： ？ 0或1次 * 0或多次 + 一次或多次 {n} n次 {n,} 至少n次 {n,m }n至m次 常用表达式： []--任意字符 [^456]:除456之外 [a-zA-Z]:任意英文字母 [a-e[g-z]]:a~e或g~z任一（并运算） [a-o&&[def]]:def（交运算） [a-d&&[^bc]]:ad（差运算） (ab)|(13)|(50):任一
• 5. 运算符
  • 算术运算符： + - * / %(基本) ++ --(自增) 赋值运算符： += -= *= /= = 自增运算符： a++ 先用后加(a ++) ++a 先加后用+(1+a) 比较运算符： = != ==(地址) equals(内容) //计较的结果是Boolean值 逻辑运算符： &"与" |"或" ^（逻辑异或：同假异真） (短路逻辑运算符先比较前面，前面能决定，后面不比较) && "与" || "或" ! "非" 逻辑运算符一般用于比较Boolean值 位运算符： 位逻辑运算： A&B：有0为0 A|B：为1为1 A^B：相同为0，不同为1 ~B：取反 数字间位运算： n1*2^n2 变大为n2为位移的位数，左边最高位丢弃，右边补齐0 2 >>右移 n1/2^n2 变小为n2为位移的位数 按照最高位补，负数补1，正数补0 >>>无符号右移，最高位补0 & "0假" | "1真" ^ 同0，不同1 ~ 取反-反码 三元运算符： Boolean（表达式） ？ [true] ：[false]
  • 5.1. 算数运算符
  • 5.2. 赋值运算符
  • 5.3. 自增运算符
  • 5.4. 比较运算符
  • 5.5. 逻辑运算符
  • 5.6. 位运算符
  • 5.7. 三元运算符
  • 5.8. 其他
    • 5.8.1. 字符串连接“+”
    • 5.8.2. 转义字符
  • 5.9. 运算符优先级
    • 1 ()、[]、{}从左向右 2 !、+、-、~、++、--从右向左 3 *、/、%从左向右 4 +、-从左向右 5 «、»、>>>从左向右 6、>=、instanceof从左向右 7 ==、!=从左向右 8 &从左向右 9 ^从左向右 10 |从左向右 11 &&从左向右 12 ||从左向右 13 ?:从右向左 14 =、+=、—=、*=、/=、&=、\|=、^=、~=、«=、»=、>>>=从右向左 比较运算符出现的java问题： String A="abc"; String B="abc"; String C=new String("abc"); String D=new String("abc"); A==B C==D 首先分析“==”比较的是值，A和B不是由对象创建的，地址取决于引号内的内容，所以A==B， C和D的值都是由对象创建，值存在于对象之中，比较的是内存中的地址，所以C≠D。 总结：一般对于对象，比较值是否相等的时候，都是通过覆写equals方法和hash方法来比较的。 思考：（java中的值存在于常量池之中） JDK1.6之前常量池存在于方法区之中， JDK1.7 及之后版本的 JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池， JDK1.8开始，取消了Java方法区，取而代之的是位于直接内存的元空间（metaSpace）。
• 6. 流程控制
  • 6.1. 语句与表达式
    • 表达式：由变量、操作符和方法调用组成，表达式的返回执类型由表达式中的元素（如操作符和变量决定）。 表达式可以组合成一个更复杂的表达式。 语句：java中的语句是一个完整的执行单元，以分号“;”结尾，能构成以下语句： 1.赋值语句 2.变量的自增自减 3.方法的引用 4.对象的创建 *注意：一行内只写一个语句。 语句类型： 表达式语句、控制流语句、声明语句； 声明语句如下： double aValue = 8933.234; 赋值表达式语句： aValue = 8933.234; 控制流语句： 自增语句（使用++） aValue++; 方法调用语句 Object.method; 创建对象语句 Bicycle myBike = new Bicycle();
    • 6.1.1. 跳转语句
      • break；跳出循环 continue；跳出本次循环 return；结束语句
  • 6.2. 选择结构
    • 6.2.1. 分支语句(if)
      • 语法： if（条件表达式） *--如果只有一条语句可以省略大括号 { 语句； }else[{}] if（条件表达式）{ 语句； }
    • 6.2.2. 条件语句(switch)
      • 条件语句语法：多选一 switch（表达式）{ //（表达式结果）byte short int char case n1：语句1；break; //首先匹配 case 对应常量 case n2: 语句2； //从匹配值之后继续向下执行，否则执行默认 ... default : 语句 n； //不管位置如何，先执行 case--最后执行 default }--结束的标志：遇到 break 或者“}” continue;//强制退出当前循环，在 switch 中和 break 效果相同。 一般不在 switch 中使用，除非 switch 在循环之中。
  • 6.3. 循环结构
    • 6.3.1. while语句
      • while 循环语法： while（条件表达式）{ 执行语句； }--先判断，再执行。
    • 6.3.2. do while语句
      • do while 语句语法： do（ 执行语句； ）while（条件表达式）; do while 特点是条件无论是否满足，循环体至少被执行一次。
    • 6.3.3. for语句(for-each)
      • for 循环语句语法： for（初始化表达式①：循环条件表达式②⑤：循环后的操作表达式④）{ 执行语句③； //return 0;方法结束，也可以跳出循环。 } 初始化表达式：int a=1； for-each： for-each在数组中使用的比较多 格式： for(类型 变量名:要遍历的数组){ 语句序列; System.out.println(变量名); } 比较： 一维数组： public class ForEach{ public static void main(String[] args) { int[] a = {1,2,3,4,5,6,7,8}; int i; for(i=0;i System.out.printf(a[i]+"\t"); } // for_each 循环 for(int b:a){ System.out.printf(b+"\t"); } // for_each 循环字符串 String[] s = {"norse","mouse","ear"}; for(String b:s){ System.out.printf(b+"\t"); } } } 二维数组： intb[][]= new int[][]{{1,1,1},{2,3,1},{4,5,6}}; for(int[] cells: b){ for (int num cells){ System. out. println(num) } } for (int i =0; i for (int num b[i]){ System. out. println(num); } }
• 7. 函数
  • 7.1. 函数定义/格式
    • 函数（方法）概念： 函数就是定义在类中的具有特定功能的一段独立小程序。 好处：提高了代码的复用性和可维护性。 函数的格式： 修饰符 返回值类型 函数名（参数类型形式参数1，参数类型形式参数2，…）{ 执行语句； return 返回值； } 函数的特点： 1.定义函数可以将功能代码进行封装便于对该功能进行复用 2.函数只有被调用才会被执行 3.函数的出现提高了代码的复用性 4.对于函数没有具体返回值的情况，返回值类型用关键字 void 表示，那么该函数中的 return 语句如果在最后一行可以省略不写。 5.注意：函数中只能调用函数，不可以在函数内部定义函数。 6.定义函数时，函数的结果应该返回给调用者，交由调用者处理。 7.void 的函数不能被输出。
  • 7.2. 函数中的各种属性
    • 函数中的各种属性： 返回值类型：函数运行后的结果的数据类型。 参数类型：是形式参数的数据类型。 形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。形参没有默认值。 实际参数：传递给形式参数的具体数值。 return：用于结束函数。返回值：该值会返回给调用者。 默认初始值为0 好处：提高了代码的复用性和可维护性 *注意：对于基本数据类型，参数值的级别不能高于该参数的级别。int--float（x） double--float(√)
  • 7.3. 函数的调用
    • 方法调用的三种情景： ·直接用方法名调用 add(a); ·赋值调用，结果赋值给变量 int a =1+ add(b); ·在语句中调用 eg：println（方法名） 函数调用的三种方式： 函数名调用、对象调用、类名调用（静态方法）
    • 7.3.1. 方法重载(overload)
      • 重载的概念： 在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。*--载入的方法不同 特点： 函数名相同，参数列表不同（参数的个数，函数的类型）与返回值无关。 好处： 方便阅读，优化了程序设计。 示例： //返回两个整数的和 int add(int x,int y){(return x+y;} //返回三个整数的和 int add(int x,int y){(return x+y+z;} //返回两个小数的和 double add(double x,double y){return x+y;} 使用： 当定义的功能相同，但参与运算的未知内容不同。 那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。
• 8. 数组
  • 8.1. 数组声明、定义(静态/动态)
    • 数组的概念： 数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。 简言之：数组的操作就是对下标的控制。 //一组数据类型相同且有序的数据集合。 数组的特点： 一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。 有序性：数组中的元素是有序的，通过下标访问。 不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。 数组的声明： 数组类型[] 数组标识符; 数组类型 数组标识符[]; 数组的定义： 格式1： 元素类型[] 数组名=new 元素类型[元素个数或数组长度]; //动态初始化，包含 n 个元素，只定义数组长度。 实例：int[] arr=new int[5]; 格式2： 元素类型[] 数组名=new 元素类型[]{元素，元素，......};--静态初始化，数组和元素同时赋值，系统默认长度。 实例int[] arr=new int[]{3,5,1,7};--声明+定义+初始化 简化方式：int[] arr={3,5,1,7}; 格式3： int a[]=null;int a[]; --先声明 a=new int[num]{}; --再定义（使用时定义） a=new[]{value1,value2,...};--初始化 注意： 1.下标从0开始，容易越界--编译不会出错，运行时出错--语法错误 2.引用值默认为空 arr=null;，元素值默认值0 arr[1]=0;。 3.空指针异常NullPointerException
  • 8.2. 数组在内存中的表现形式
    • 数组在内存中的存储： 1.main方法进入方法栈 2.创建数组，jvm 在堆内存中开辟空间，存储数组 3.数组的内存地址以十六进制表示 4.jvm将数组的地址赋值给引用性变量数组 两个数组变量指向一个数组 int [] arr2=arr; 数组在内存中的表现形式： eg：int[] arr=new int[4]; a[0]=1;a[1]=2;a[2]=3;a[3]=4; 栈内存 arr --0x0012--堆内存的物理地址 堆内存--数组中元素具体的值 new int[4];--在堆中创建长度为4的数组 --arr[0];--数组中具体的值,1 --arr[1];--2 --arr[2];--3 --arr[3];--4
  • 8.3. 数组的操作
    • 8.3.1. 遍历
      • 数组的遍历： 一维数组： int arr[]=new int[3]; for(int i=0;i System.out.println(a); } 结果：[I@de6ed--哈希值十六进制数组的地址 System.out.println(a[i]); 结果：0; 二维数组： int a[i][j]; for(int i=0;i for(int j=0;j System.out.println(a[i][j]); } }
    • 8.3.2. 比较
      • 如果数值出现负数，容易出现错误 定义int max=0;--0不是元素值，是下标 用下标代替元素值进行比较 获取double也可以，用重载形式定义函数 Boolean 类型的默认值是 false
    • 8.3.3. 查找
      • 查找第一个数 if(arr[x]==key)return x; return -1;--找不到返回-1 有序数组--折半查找--取中间值与其比较 halfSearch(); 1.以key为中心； 2.以数组中元素为中心 mid=（min+max）/2
    • 8.3.4. 排序
      • Arrays.Sort(arr);--局限：只有升序排列
    • 8.3.5. 替换
      • 复制： 完全复制： 两个数组变量指向一个数组 int [] arr2=arr; 部分复制： int[] arr = {1,2,3,4,5}; int[] brr = new int[10] for(inti=0;i brr[4+i]=ar[2+i];//下标的操作 } 填充： 填充:Arrays.fill(arr,int value);--数组和填充的值 批量替换： Arrays.fill(arr,int fromIndex,int toIndex,int value);--填充的第一个索引(包括)，填充的最后一个索引(不包括)
    • 8.3.6. 排序
      • 选择排序/冒泡排序/快速排序/插入排序 /希尔排序 直接选择排序： 从第一个和后边依次比较，小的放在第一位。然后第二位和后边依次比较。。。（最大的放在最后） 比较次数 n +(n-1)+(n-2)...3++2+1 -1 冒泡排序： 相邻的两个元素进行排序，从第一位与第二次比较，第二位与第三位比较...，如果符合条件进行换位，1>2,2>3,3>4...最大值在最后一位 n +(n-1)+(n-2)...3++2+1 -1 快速排序： 选择一个分界值（平均数），将数组分为两半。 最优：an = a[(n-1/2)]+a[(n-1/2)] + n - 1 最差：1+2+3……+ n-1 = n(n-1)/2 插入排序：(少量元素) 把n个元素的数列分成有序（前）和无序（后）的两部分,每次处理就是将无序的数列中第一个元素与有序数列的元素从后到前比较，找到插入位置，将该元素插入到有序数列的适当的最终的位置上（稳定排序）。 最快排序方式：希尔排序 堆中排序效率低，记录下标，在栈中比较效率高 Arrays.sort(arr); 无论什么什么排序都需要换位置，可以封装成一个函数
      • 8.3.6.1. 选择排序/冒泡排序/快速排序/插入排序 /希尔排序
  • 8.4. 二维数组
    • 概念： 二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。 arr是二维数组 arr[0] arr[1] 是一维数组 arr[0][0]是数据 例1： int[][] arr=new int[3][2]; =》int[int[2]、int[2]、int[2]] --3个二维数组 ·定义了名称为axx的二维数组 ·二维数组中有3个一维数组 ·每一个一维数组中有2个元素 ·一维数组的名称分别为arr[0]，arx[1]，axx[2] ·给第一个一维数组1脚标位赋值为78写法是：arr[0][1]=78； 例2： int[][] arr=new int[3][]；只分配了二维数组空间，一维数组默认初始化--null ·二维数组中有3个一维数组 ·每个一维数组都是默认初始化值nu11 ·arr[0][0]为空指针异常 ·可以对这个三个一维数组分别进行初始化 axx[0]=new int[3]； arr[1]=new int[1]； axx[2]=new int[2]； 数组中的数组，把内部的数组的地址给外部数组 打印数组长度 (a.length);//多少行 (a[i].length);//第i行有多少列