Java标识符的命名规则

1. 使用Unicode字符集，以字母，下划线“_”,美元符号“$”,后面可以跟字母，下划线，美元符号和数字。
2. 标识符长度不限
3. 大小写敏感
4. 不能使用关键字和保留字

   关键字分类

   Java 语言中有一些具有特殊用途的词被称为关键字。关键字对 Java 的编译器有着特殊的意义，在程序中应用时一定要慎重哦！！

Java 中常用关键字：

• 基本数据类型

  byte,int,short,long,float,double,char,boolean,true,false,null
  

• 程序流程控制

  if,else,switch,case,default,do,while,for,break,continue,return
  

• 错误处理

  try,catch,finally,throw,throws
  

• 类，方法和变量修饰符

  class,interface,extends,implements,new,abstract,final,static,synchronized,
  native,strictfp,transient,volatile,instaceof
  

• 访问控制

  public,protected,private
  

• 包相关

  package,import
  

• 变量引用

  super,this,void
  

  数据类型

  Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。 Java 中有两类数据类型：
  

  常量和变量

  简单的说，我们可以把变量看作是个盒子，可以将钥匙、手机、饮料等物品存放在这个盒子中，也可以在需要的时候换成我们想存放的新物品。
  所谓常量，我们可以理解为是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变。常量是在程序运行中不能变化的的量，语法如下

  final 类型 常量标识符=初始赋值
  

  变量在计算机内部对应一个存储单元，变量可根据需要存入不同的数据。语法如下：

  类型 变量标识符[=初始赋值]
  

  如何命名Java变量

  以下变量的命名都是符合规范的：

  String myname="tom";
  String _love="you";
  Stirng $hobby2="LoL"
  

  1、java变量名不能以数字开头
  2、不能以下划线和美元符号之外的其他特殊符号开头
  3、不能使用java关键字

整型数据

• 整型数据包括整型常量和整型变量。整型数据在机器中用补码表示。
• 二进制补码规则
  • 最高位为符号位，正数的符号为0，负数的符号为是1
  • 正数的补码：与原码相同
  • 负数的补码：符号为为1，其余为为该数绝对值的原码按位取反，然后整个数加1.

整型常量

• 十进制

例如：120

• 八进制

以0开头，例如：0170

• 十六进制

以0x或者0X开头，例如：0X78

注意事项

1. 两个整型相加，结果默认转化为int,赋值给byte或short时会发生类型转化问题。
2. 在选用整数类型，一定要注意数的范围，否则可能由于数的类型选择不当而造成溢出。
3. 对于long类型整数常量，书写是应在数字后加上“l”或“L”,否则默认是int类型.
4. 若表示范围超出了long型，要用java.math.BingInteger类表示。

浮点型数据

浮点型数据包括浮点型常量和浮点型变量

浮点型数据在机器中有两种表示方式：十进制和科学计算法(符号位+尾数+基数(E或e)).例如：浮点数123.45，十进制123.45，科学计算法表示为1.2345E2或1.2345e2。

浮点类型变量分为两种：float型和double型，其数据特点如下表示：

注意事项

• 当使用浮点型常量给浮点型变量赋值时，float型常量后一定要加上f或F。
• float和double只能用来做科学计算或者工程计算，在商业计算等精确计算中，我们要用java.math.BigDecimal.

布尔类型数据

布尔类型常量只有两个值true(真)和false(假)，默认值为false。
布尔类型变量类型为boolean。变量的定义如下：boolean 变量名。

boolean b = true

字符型数据

Java 使用Unicoe字符集，这种字符集每个字符用2个字节即16位表示。字符型数据也有字符型常量和字符型变量。
字符型常量的表示：

1. 用单引号括起来的一个字符，如'b','1'。
2. 用单引号所引的转义字符，如 '\b'。
3. 用int型整数表示。
4. 形如：'\u????'的Unicode形式的字符，其中，'????'应严格按照四个16进制数字进行替换，例如char c = '\u3100'是错误。而char c = '\u2abc'是正确的。

   注意事项

   • 字符型变量只有一种：char类型，它在机器中占16位，其范围为0~65525.
   • 使用是要主要：字符型变量实际上是一个数字，因此他可以赋值给一个数字型变量，例如：float f = 'a';int i = 'a'。

数据类型转换

自动转换

不同的类型数据间的优先关系如下

低-------------------------------------->高
byte--> short --> int --> long --->float -->double char

自动转换是指编译系统可自动将低优先级数据类型转换为高优先级数据类型。各种数据类型的转换规则如下表：

当然自动类型转换是需要满足特定的条件的：
1、 目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型

int age =19;
char sex = "女";
char result = age + sex;
//int类型不能自动转换成char类型

2、目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了

double avg1 = 75.5;
int avg2=avg1;
//uble类型不能自动转换为int类型

强制转换

高优先级数据要转换成低优先级数据，需要用到强制类型转换，其转换格式如下：
(类型名) (数据或表达式)
例如

int x
short a=(short)x
/*把int型变量x强制转换为short型*/

数组

数组定义

数组是相同类型的数据按照顺序组成的一种复合数据类型，通过数组名加数组下标来使用数组中的数据。下标从0开始。
数组元素的数据类型可以是Java的任何数据类型，例如：基本类型(int、float、double、char等)，类(Class)或接口(interace)等。

数组声明

声明数组就是要确定数组名、维数和元素的数据类型。

• 声明一维数组有两种方式：

类型标识符 数组名[]
类型标识符[] 数组名
例如： int abc[]; int[] abc;

• 声明二维数组也有两种方式

类型标识符 数组名[][]
类型标识符[][] 数组名；
例如：double a[][];double[][] a;

数组的创建

• 创建数据要给出数组长度并分配空间

1. 一维数组的创建格式如下：

   数据名=new 数组标识符[大小]
   

2. 二位数组的创建格式如下：

   数据名=new 数组标识符[大小][大小]
   例如:double a[][];a=new double[10][10]
   

   数组的声明和创建也可以合为一步，如下所示：
   类型标识符 数组名[]=new 类型标识符[大小]
   类型标识符[][]=new 类型标识符[大小][大小];
   例如：double a[][]=new double[10][10]

   数组的初始化和赋值

   数组的初始化有两种方式：
   静态初始化：直接在生命的时候使用初始化表给数据的全部或部分元素赋初值
   例如：int[] a={3,4,5,6};float b[5]={1.0,2.0}
   动态初始化：使用赋值表达式给数组的各个元素赋值。

例如：int a[] = new int[2]
a[0]=1;
a[1]=2

每个数组包含一个成员变量length,它是在初始化是设定的数组大小。我们可以在数组名后加.length来访问该变量。
例如： int a[5]=new int[5];a.length的值为5

数组使用

public class HelloWorld {
   
   
    public static void main(String ards[]) {
   
   
        int a[]= {
   
   101,99,102,98,103,100};
        int max=a[0],min=a[0];
        for(int i=1;i<a.length;i++) {
   
   
            if(a[i]> max)
                max=a[i];
            if (a[i]<min)
                min=a[i];            
        }
        System.out.println("数组a各元素为：");
        for(int i=0;i<a.length;i++) {
   
   
            System.out.print(a[i]+" ");
        }
        System.out.println();
        System.out.println("最大值为："+max);
        System.out.println("最小值为："+min);
    }

}

标准输入输出

标准输出

在Java中，通过System.in和System.out对象分别与键盘和显示器发生联系而完成程序信息的输入和输出。
System.out对象中包括的最常用的方法是：
print()输出一项数据但不换行。
println()输出一项数据后换行。
如果要用一个语句输出多个数据项，则数据项之间要用“+”连接.

例如：
int a = 20;
System.out.print(a+"abc")

标准输出

JAVA使用Scanner类创建一个对象：
Scanner reader =new Scanner(System.in);
然后reader对象调用下列方法(函数)，读取用户在命令行输入的各种数据类型。

nextByte(),nextShort(),nextInt(),nextlong(),nextFloat(),nextDouble(),nextLine()

注意：Scanner类在java.util.*包中，使用时需要提前用import 语句引入该包。

上述方法执行时都会阻塞，等待你在命令行输入数据回车确认。JAVA使用hasNextByte(),hasDouble(),hasNextFloat(),hasNextInt(),hasNextLong(),hasNextShort()等待用户的输入。
例如：从键盘连续输入整型数值，并打印输出，知道输入非整型值为止。

Scanner read = new Scanner(System.in);
while(read.hasNextInt()){
   
   
    System.out.print(read.nextInt())
}

控制语句

Java中语句主要有以下几类：

• 分支语句：if-else，switch
• 循环语句：while,do-while,for
• 跳转语句：break,continue,return

  if流程控制语句

  if语句有以下3中基本结构：
  1、if结构：

  格式如下:
  if (逻辑表达式) {
       
       
  语句组
  }
  

  
  2、if-else结构：

if(逻辑表达式) {
   
   
    语句组1
 }else {
   
   
    语句组2
}

3、嵌套if-else结构

if(逻辑表达式1){
   
   
    语句组1
}else if (逻辑表达式2) {
   
   
    语句组2
}....
else (逻辑表达式n){
   
   
    语句组n
}

switch语句

switch结构：

switch (表达式) {
   
   
    case 常量1: 语句组1
                [break]
    case 常量2: 语句组2
                [break]
    ......
     case 常量n: 语句组n
                [break]  
     [default: 语句组n+1]

}

注意：

• 表达式的返回值类型必须是这几种类型之一：byte,short，int和char,其他类型都不允许。
• case子句中的常量表达式n必须是常量，而且所以的case子句中的值应是不同的。
• 语句块不需要用{}括起来。
• default子句是可选的。
• break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行(当多个不同的case值要执行相同操作，这时可以不同break)
• 可以使用if...else结构实现switch的所有功能，但是switch结构更加精简。

循环语句

循环结构的执行流程为：反复执行同一段代码，直到满足结束条件。循环语句一般包括初始化，循环体，迭代和判断四部分。
Java提供了一些三种循环结构：

1. while循环
2. do...while循环
3. for循环

   while循环

   while循环的执行流程为：首先判断是否满足条件，若满足则执行循环体，如此重复，直到不满足条件。
   格式如下：

   [循环变量初始化]
   while(逻辑表达式)
   {
        
        
    循环体;
    循环控制变量;
   }
   

   执行过程：
   1、判断 while 后面的条件是否成立( true / false )
   2、 当条件成立时，执行循环内的操作代码 ，然后重复执行< 1 >、< 2 >， 直到循环条件不成立为止。
   特点：先判断，后执行

例1：

int i=1;
while( i <= 100) {
   
   
    System.out.println("这是一个测试");
    i++;
}

do...while循环

do...while循环(又称“直到型循环”)的执行流程为：首先执行循环体，然后计算机逻辑表达式，若结果为true,则继续执行循环体，直到逻辑表达式的值为false为止。
格式如下：

[循环变量初始化]
do {
   
   
    循环体;
    循环变量控制
}while(逻辑表达式)

执行过程：
1、先执行一遍循环操作，然后判断循环条件是否成立。
2、 如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止。
特点： 先执行，后判断

由此可见，do...while 语句保证循环至少被执行一次！
例2：

public class HelloWorld {
   
   
    public static void main(String[] args) {
   
   

        int sum = 0; // 保存 1-50 之间偶数的和

        int num = 2; // 代表 1-50 之间的偶数

        do {
   
   
            //实现累加求和
            sum+=num；
            num = num + 2; // 每执行一次将数值加2，以进行下次循环条件判断

        } while (  num<=50  ); // 满足数值在 1-50 之间时重复执行循环

        System.out.println(" 50以内的偶数之和为：" + sum );
    }
}

for循环

for循环的执行流程为：首先执行初始化操作，然后判断终止条件是否满足，如果满足，则执行循环体中的语句，最后执行迭代部分。完成一次循环后，重新判断终止条件。
格式如：

for(初始值表达式;逻辑表达式;迭代表达式){
   
   
    循环体
    }

注意：

• 在初始值表达式中可以申明作用域为该for循环的变量。
• 逻辑表达式为空时，相当于真值为true。
• 初始表达、逻辑表达式以及迭代表达式部分都可以为空语句(但分号不能省),三者均为空的时候，相当于一个无线循环。
• 初始表达式和迭代表达式部分都可以用逗号语句执行多个操作。
• 如果循环变量在for中定义，变量的作用范围仅限于循环体内。
• for循环和while循环部分情况可以相互转换。

执行过程：

1. 执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次
2. 进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环
3. 执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断
4. 依次重新执行< 2 >、< 3 >、< 4 >，直到退出循环

特点：相比 while 和 do...while 语句结构更加简洁易读。
例子：

public class HelloWorld {
   
   
    public static void main(String[] args) {
   
   
        int sum = 0; // 保存不能被3整除的数之和

        // 循环变量 i 初始值为 1 ,每执行一次对变量加 1，只要小于等于 100 就重复执行循环
        for (int i = 1;   i<=100;  i++  ) {
   
   

            // 变量 i 与 3 进行求模（取余），如果不等于 0 ，则表示不能被 3 整除
            if (i % 3 != 0) {
   
    
                sum = sum + i; // 累加求和
            }
        }

        System.out.println("1到100之间不能被3整除的数之和为：" + sum);
    }
}

跳转语句

Java语言提供了4中跳转语句：break，continue、return和throw。
跳转语句的功能是改变程序的执行流程。

break语句

break语句的作用是退出switch语句和循环语句，并从紧接着该语句的下一条语句开始执行。
break语句通常有以下不带标号和带标号的两种形式：
break;
break lab;
其中：break是关键字；lab是用户自定义的标号；

注意：
break语句用在switch语句中，其作用强制退出switch结构，执行switch结构后的语句。
break语句用作单层循环结构的循环体中，其作用是强制退出循环结构。若程序中有内外两重循环，而break语句写在内循环中，则执行break语句只能退出内循环。
break lab语句用在循环语句中，必须在外循环入口语句的前方协商lab标号，可以使程序流程退出标号所指明的外循环。

例子：

public class HelloWorld {
   
   
    public static void main(String[] args) {
   
   

        // 保存累加值
        int sum = 0;

        // 从1循环到10
        for (int i = 1; i <= 10; i++) {
   
   

            // 每次循环时累加求和
            sum = sum + i;

            // 判断累加值是否大于20，如果满足条件则退出循环
            if (  sum > 20  ) {
   
   

                System.out.print("当前的累加值为:" + sum);

                //退出循环
                break;

            }
        }
    }
}

continue语句

continue语句的作用是跳过循环体内的continue语句后面还没有执行的语句，回到循环体的开始处重新执行下一轮循环。
continue邮件同城有下述不带标号和带标号的两种形式：
continue；
continue lab；
其中，continue 是关键字，lab为标号。

注意：
continue语句也称为循环的短路语句。用在循环结构中，使程序执行到continue语句时回到循环的入口处，执行下一次循环，二使循环体内写在continue语句后面的语句不执行。
当程序嵌套的多层循环时，为从内循环跳到外循环，可使用带标号的continue lab语句。此时应在外循环的入口语句前加上标号。

例子：

//打印1-100奇数
        for(int i=1;i<=100;i++) {
   
   
            if(i%2==0)
            continue;
            System.out.print(i);
        }


//
public class HelloWorld {
   
   
    public static void main(String[] args) {
   
   

        int sum = 0; // 保存累加值

        for (int i = 1; i <= 10; i++) {
   
   

            // 如果i为奇数,结束本次循环，进行下一次循环
            if (   i % 2 !=0     ) {
   
   
                continue;
            }

            sum = sum + i;
        }

        System.out.print("1到10之间的所有偶数的和为：" + sum);
    }
}

return语句

return语句从当前方法中退出，返回到调用该方法的语句处，并从紧跟该语句的下一条语句继续程序的执行。
返回语句有两种格式：
return expression；
return；
return语句通常用在一个方法体的最后，否则会产生编译错误，除非用在if-else语句中。

运算符

对各种类型数据进行加工的过程称为运算，表示各种不同运算的符号称为运算符，参与运算的数据称为操作数。

运算符分类

1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 移位运算符和位运算符
5. 赋值运算符和条件运算
6. 运算符的优先级

按功能分类

按操作数目分类

• 一元运算符
• 二元运算符
• 三元运算符

算术运算符

算术运算符如下表所示：

其中，++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果是不同滴
例1：

int a=5;
int b=++a;//让a先执行自增，然后再将值赋给变量b;
System.out.println("a："+a);
System.out.println("b："+b);
/*
*a:6
*b:6
*/

例2：

int a=5;
int b=a++;//将a值赋给变量b，然后再执行自增;
System.out.println("a："+a);
System.out.println("b："+b);
/*
*a:6
*b:5
*/

一定要注意哦！自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量！例如 5++ 、 8-- 等写法都是错误滴！

关系运算符

关系运算符如下表所示

逻辑运算符

逻辑运算符主要用于进行逻辑运算。Java 中常用的逻辑运算符如下表所示：