java

关键字

特点

• 完全小写的字母

• 在增强版的记事本（notepad++）中有特殊颜色

标识符

• 命名规则

   标识符可以包含：英文字母、0-9数字、$和下划线
  
   标识符不能以数字开头
  
   标识符不能是关键字
  

• 命名规范

   类名规范：首字母大写，后面每个单词首字母大写
  
   变量名规范：首字母小写，后面每个单词首字母大写
  
   方法名规范：同变量名
  

数据类型

基本数据类型(四类八种)

* 整数型：byte short int long

       
* 浮点型：float、double

      
* 字符型：char

      
* 布尔型：boolean

引用数据类型

字符串、数组、类、接口、lambda

• 注意事项

    1、字符串不是基本类型，而是引用类型
  
    2、浮点型可能只是一个近似值，并非精确值
  
    3、数据范围与字节数不一定相关 
    	e.g. float数据范围比long更加广泛，但是float是4字节，long是8字节
  
    4、浮点数中默认类型为double,使用float需要加后缀f
  

数据类型的转换

当数据类型不同时，会发生数据类型的转换

• 自动类型转换（隐式）

   特点：代码不需要特殊处理，自动完成
  
   规则：数据范围从小到大
  
    long num1=100;//发生了自动类型转换
  
    一个等号代表赋值，此处的含义是，将右侧的int型变量，交给左侧的long变量来进行存储
  
    （用long的容器来存储int数据）
  

• 强制类型转换（显式）

   特点：代码需要进行特殊的格式处理，不能自动完成
  
   格式：范围小的类型 范围小的变量名=（范围小的类型）原本范围大的数据
  

• 注意：

  1、强制类型转换一般不推荐使用，因为有可能发生精度损失
    （小数<并不是四舍五入，所有的小数位数均会被舍弃掉>），数据溢出（整数)
  
  2、 byte/short/char均可以进行数学运算，在运算时均会被首先提升为int类型，再进行运算
  
    	byte num1=40;
  
   	byte num2=50;
  
     	byte num3=num1+num2;//byte+byte-->int+int-->int
  3、  boolean类型不能发生数据类型转换
  

数组

定义

数组是一种容器，可以同时存放多个数据值

特点

1、数组是一种引用数据类型

2、数组当中的多个数据，类型必须统一

3、数组长度在程序运行期间不可改变

数组初始化

• 概念：在内存当中创建一个数组，并向其中赋予一些默认值

• 两种常见的初始化方式：

  动态初始化（指定长度）

  格式：数据类型[] 数组名称 = new 数据类型[数组长度];

  解析含义：

  左侧：

        数据类型：数组中保存的数据的统一类型
  
        []：代表是一个数组
  
        数组名称：给数组命名
  

  右侧：

        new：创建数组
  
        数据类型：必须与左侧保持一致
  
        数组长度：数组中最多存放的数据个数，是一个int型数据
  

  静态初始化（指定内容）

  基本格式：数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，…};

  省略格式：数据类型[] 数组名称 = {元素1，元素2，…};

• 注意事项：

  1、静态初始化没有直接指定长度，但是仍然自动推算得到长度

  2、静态初始化标准格式可以拆分成两个步骤

  int[] arraryA;

  arrayA = new int[]{11,21,31};

  3、动态初始化可以拆分为两个步骤

  int[] arraryB;

  arraryB = new int[5];

  4、静态初始化一旦使用省略格式，就不能拆分成为两个步骤了

• 使用建议：

  如果不确定数组中的具体内容，用动态初始化：否则，用静态初始化

数组使用

• 静态初始化数组

  直接打印数组名称，得到的是数组对应的，内存地址哈希值

  访问数组元素的格式：数组名称[索引值]

  索引值，就是一个int数字，代表数组当中元素的编号

  注意：索引值从0开始一直到数组长度减一为止

     可以直接打印数组当中的元素，也可以将数组中的某个元素，赋值交给变量
  

• 动态初始化数组

使用动态初始化数组时，其中的元素会自动拥有一个默认值，规则如下：

如果是整数类型，那么默认为0

如果是浮点类型，那么默认为0.0

如果是字符类型，那么默认为'\u0000'

如果是布尔类型，那么默认为false

如果是引用类型，那么默认为null

注意事项：静态初始化也有默认值，只不过系统自动马上将默认值替换

Java中的内存划分

1、栈（stack）：存放的都是方法中的局部变量，方法的运行一定在栈中

 	      局部变量：方法的参数，或者是方法{}内部的变量

              作用域：一旦超出作用域，立即从栈内存中消失

2、堆（heap）：凡是new出来的东西，都在堆内存中

              堆内存里面的东西都有一个地址值：16进制

              堆内存中存放的数据，都有默认值，规则：

              如果是整数类型，那么默认为0

              如果是浮点类型，那么默认为0.0

              如果是字符类型，那么默认为'\u0000'

              如果是布尔类型，那么默认为false

              如果是引用类型，那么默认为null

3、方法区（method area）：存放.class相关信息，包含方法的信息，主要保存方法信息

4、本地方法栈（native method stack）：与操作系统相关

5、寄存器（pc Register）：与CPU相关

常见问题

• 数组索引越界异常

  如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常（ArraryIndexOutOfBoundsException）

  原因：索引编号写错了

  解决：修改成为正确的索引编号

• 空指针异常

  所有引用类型变量，都可以赋值为一个null值，代表其中什么也没有

  数组必须进行初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常（NullPointerException）

  原因：忘了new

  解决：补上new

获取数组长度

• 格式：数组名称.length

• 数组一旦创建，程序运行期间，长度不可改变

求数组中的最值

public class Max {

   public static void main(String[] args) {

       int[]array={5,15,30,20,10000};

       int max=array[0];

       for (int i=1;i<array.length;i++){

           if(array[i]>max){

               max=array[i];

          }

      }

       System.out.println("最大值"+max);

  }

}

数组元素反转

实质：其实就是对称位置的元素交换

• 通常情况下遍历数组用的是一个索引

  int i=0;

  但是反转需要两个索引

  int min=0;

  int max=array.length-1;

• 交换变量值，借助第三变量

  int a=10;

  int b=20;

  int temp=a;

  a=b;

  b=temp;

• 停止交换：min<max

/*

数组元素的反转

要求：不能使用新数组，就用原来的唯一一个数组

*/

public class Reserve {

   public static void main(String[] args) {

       int[]array = {10,20,30,40,50};

       for(int i=0,j=array.length-1;i<j;i++,j--){

           int temp=array[i];

           array[i]=array[j];

           array[j]=temp;

      }

       for(int m=0;m<array.length;m++){

           System.out.println(array[m]);

      }

  }

}

数组可以作为方法的参数

当调用方法时，向方法传参，传递的其实是数组的地址值

public static void printArray(int[] array){

   for(int i=0;i<array.length;i++){

       System.out.println(array[i]);

  }

}