Java第二天

big_matster

于 2022-10-11 18:08:15 发布

阅读量202

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/kuxingseng123/article/details/127266240

版权

Java变量的声明和数据类型

关键字

关键字是程序语言的最小单位，是程序语言事先定义的，并且具有特殊意义的一些标识符，在有些语言里也称为保留字。正如我们使用人类的语言一样，一篇文章总是一个个的文字组成，完整的程序就像一篇文章，关键字就是一个个的文字。相比我们人类语言的复杂性,java程序语言的关键字只有53个。具体如下：

访问控制:private protected public

修饰类、方法、属性和变量:abstract class extends final implements interface native new static strictfp synchronized transient volatile enum assert

程序控制:break continue return do while if else for instanceof switch case default

基本类型:boolean byte char double float int long short null true false void

错误处理:try catch throw throws finally

包相关:import package

变量引用:super this

保留字:goto const

有些初学者总是问学习编程需要英文是否要很好。上面这些关键字你还是要记的。也就这么50几个。所以不用担心英文不好就学不会变成。

以上这些关键字就是程序员编写程序时使用的最小单位。其中const和goto虽然在Java中未被使用，但考虑到它们与C++的关联性，所以仍然保留为关键字。

数据类型

我们在编写程序时处理由于数、字符、和浮点类型的对象无法再分为更简单的部分，我们在自然界称为简单数据，到了计算机编程的世界，我们称之为基本数据类型，大多数语言都有定义基本数据类型，这些类型为我们处理信息的最小单位。Java有8种基本类型，分别是：

除了基本数据类型外，为了实际应用的需要，Java还提供了两个用于高精度计算的非基本数据类型的数字类，他们是：

BigInteger——任意大的整数，可用于密码学计算等。

BigDecimal——任意精度的定点实数，可用于精确的货币计算等。

定义变量

数据类型确定要存储在内存中的数据的类型，变量则是存储数据的基本单元 。变量就好比一个杯子，而数据类型就定义了这个杯子的大小和它能装载什么内容。

java是强类型语言，所有的变量都必须先声明才能使用，声明变量时必须指定变量存储信息的类型。变量的声明一般使用名值对的方式，包含变量名和变量值，通过变量名可以引用变量值，也可以修改变量名的值。变量名：引用变量的值、修改变量名的值。

首先，声明一个变量的基本格式：

public static void main(String[] args) {
       int type;
       boolean flag;
       float score;
}

可以看到，我们每一个变量的声明都是以类型说明符（参考上一节的java基本类型）开始，后面你可以自定义一个变量名，然后别忘了以分号结束，表示变量声明结束。类型的定义，约束了变量在存储区里所能表示的数据类型和空间大小。（约束变量在存储区所能表示的数据类型和空间大小）

我们在声明一个变量的时候也可以同时为其赋初值，上面提到变量的声明一般使用名值对的格式，具体格式如下

数据类型变量名 = 数值;

public static void main(String[] args) {
       int box=100;
       int a=300;
       boolean f=true;
}

声明变量并同时赋予初值，我们称之为初始化。注意这里的等号（=）并不是我们以前学习数学时表示相等，而是赋予值的意思。这个时候名为box的这个变量所在的存储区保存的值就是100了。

所在存储区域的赋值就是100啦。

我们可以在同一行同时声明多个同一类型的变量，这样可以简化我们的代码，提高可阅读性，具体格式如下：（提高可读性）

数据类型变量名, 变量名，变量名;

public static void main(String[] args) {
    int a,b,c;
}

上面例子中，同时声明了三个整型变量（a,b,c）,变量和变量之间使用英文逗号(,)隔开。当然我们也是可以想上面介绍的，为变量赋予初始值。如下面这个例子：

public static void main(String[] args) {
  //变量a和变量c分别赋予了初始值。
  int a=100,b,c=20;
}

变量声明后，我们就可以通过变量名引用变量值或者修改变量名所存储的值了。在同一作用域下，变量只能声明一次，但是可以多次的赋值，不断根据程序的需要修改变量原来存储的变量值。具体格式如下：

（引用变量名或者修改变量名所存储的值啦）

同一作用域下，变量只能声明一次，但是可以多次的赋值。

变量名 = 新的数值;

引用该变量名的值就更简单了，直接使用变量名即可。如下面这个例子：

public static void main(String[] args) {
      //声明变量a，并同时赋初始化值是100；
      int a=100;
      //引用变量a,这时候输出的是变量所存储的值，应该是100
      System.out.println(a);
      //为赋值200
      a=200;
      //再次引用变量a,输出的也是变量所存储的值，但这时候应该是200了
      System.out.println(a);
}

会自己直接使用变量名，引用变量值。

上面的示例综合讲述了变量的声明，赋初始化值，应用和重写赋值等常用的语句，这里要重点说明的是，我们可以在程序运行时为变量多次赋值，但是每一次赋值都会覆盖该变量之前的变量值。这个例子看上去非常简单，但是要好好理解，这里理解复杂程序的关键基础，有着举足轻重的作用。

变量的命名规范

Java语言中，变量命名要符合一定规则。标识符是赋予变量、类或方法的名称。标识符可从一个字母、下划线(_)或美元符号($)开始，随后也可跟数字。标识符是大小写区别对待的并且未规定最大长度。

有效标识符如下：

identifier ， userName ，User_name ， _sys_varl ，$change

无效标识符如下：

123abc ， abc￥5 ，abc ert ， add34）

java的变量命名还有很多约定俗成的习惯，虽然你不按照这样的命名习惯也不会出现语法错误，不过为了提高程序的可读性，我们建议你还是使用下面的这几个习惯。

会自己慢慢的训练编程思维，慢慢的掌握编程框架及其标识符命名规则。

基本数据类型的变量

整型变量：短整型、整形、长整型。

上一节中我们介绍了描述整型的三个符号：短整型（short）、整型（int）和长整型（long），它们都可以定义整型变量，但是由于分配的内存空间不同，所能表示的数据的长度也不同。

分配内存空间不同，所表示的数据长度不同。

定义并初始化一个整形变量；

      int a=100;

那么变量a最大只能表示2147483647。如果赋值超过这个数，程序会报错，我们要根据实际需要使用不同的整型类型。下面我们重新给a赋值

      a=2147483647;

这个数据比较大，对我们而言比较难以看清，JDK 7之后整型数据我们可以使用以下这种方式赋值

       a=2_147_483_647;

另外我们定义整型时一般使用十进制表示，java也提供了定义为八进制和十六进制来表示：

八进制就是只能表示：0 1 2 3 4 5 6 7 ，

注意：八进制必须以0开头。如：

0123 045 098 046

十六进制：

0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

注意：以十六进制表示时，需以0x或0X开头，如：

0x8a 0Xff 0X9A 0x12

还有就是对长整型的初始化和赋值时要主意，一般我们定义一个整数时默认都是整型，为了表示长整型我们需要在整数的后面加一个英文字符'L'或者'l',由于英文字符'l'和数字‘1’比较类似，所以我们习惯使用大写字母'L'。

如：

long a=9L;

long b=156L;// 长整型必须以L做结尾

浮点型

浮点数类型有float(32位)和double（64位）两种类型，分别叫做单精度浮点数和双精度浮点数，表示浮点数时，要在后面加上f(F)或者d(D)，用指数表示也可以。注意：由于小数常量的默认类型为double型，所以float类型的后面一定要加f(F),用以区分。初始化和赋值时除了支持一般的小数的写法外，也支持科学记数法。如以下例子都是可以的。

float a=2.4f;

float b=2e3f,

double c=3.6d;

double d=3.44;

float e=5.022e+23f

上面这些定义都是合法的。

布尔类型

布尔类型比较特殊，它的值只有两种：true和false。布尔类型一般用于条件判断。与C语言不同，C语言可使用整数0表示false，而非0表示true，但是在java中不可以这样，表示布尔型只能使用true和false，例子如下：

boolean flag=true;

boolean f=false; JAVA中表示布尔类型的只有true or false

字符常量

字符常量是由英文字母、数字、转义序列、特殊字符等的字符所表示，它的值就是字符本身，在java中使用单引号“’”表示，每个字符占用两个字节。如：

'a' '8' '\t' '\u0027'

可以使用全球统一编码(Unicode),码值加上\u来表示对应的字符, 采用Unicode的目的是为了覆盖全球各种各种语言使用的不同的语言标记，分为UTF-8和UTF-16。

覆盖全球各种语言，使用不同的语言标记。分为utf-8和utf-16.

字符串常量

字符串是自然界描述信息很常用的一种形式，因此使用非常频繁。Java中使用用双引号括起来进行标示，如：

"Hello World"

"123"

"Welcome \nXXX"

使用字符串时需要注意，我们存储信息时会带上一些特殊的方便人类阅读的格式标记，比如回车换行显示、或者直接想标示一个双引号，这是就需要使用转义字符的机制来实现，因此转义字符的目的是在字符串中标示一些特殊的标记信息，格式使用一个\开头，形如：

\r表示接受键盘输入，相当于按下了回车键；

\n表示换行；

\t表示制表符，相当于tab键；

\b表示退格键，相当于Back Space；

\'表示单引号，\"是双引号；

\\表示一个斜杠“\”。

比如上面的"Welcome \n XXX",它的运行结果是：

Welcome

XXX

特殊的null值

null字面量：用null表示，表示为空，注意在逻辑上来说：0不是空。null值在定义对象赋初值时使用。

变量的作用域变量的分类

与C语言不同，java的所有的变量都必须在类中声明，不允许有变量不在类中声明的，当然变量也是是有具体的使用范围的，这种范围就是变量的作用域。声明在class的根语句块的变量是具有全局作用域，就是在本程序内部任意位置都访问得到，被称作全局变量。局部变量会覆盖全局变量。如下面这个例子：

当然有类的全局变量，和方法中的全局变量。

public class Tt {
   int i = 100;// 类的全局变量
   public void test() {
      System.out.println("访问的是全局变量i=" + i);
      int i = 50;// main方法中的全局变量,覆盖全局变量
      System.out.println("访问的是局部变量i=" + i);
   }
   public static void main(String[] args) {
      Tt tt=new Tt();
      tt.test();
   }
}

我们声明了一个全局变量i，这个变量i的作用域在整个类中都可以访问，然后我们定义了一个普通方法test，在这个方法体中，我们也可以访问全局变量i，但是如果我在这个方法里也声明了一个同名的变量i，也就是局部变量，那么局部变量i会覆盖覆盖全局变量i，所以第一个i输出的是100，而第二个i输出的时50，你可以在main方法中调用这个方法测试一下。

常量

常量就是在程序运行中不变的值，使用final关键字进行声明。

final double rate = 3.1415926;

在java中也可以用public static final修饰一个自定义字面量，或者使用枚举类型也可以表示一组字面量，枚举类型我们后面章节讨论。final关键字和public关键字我们也会在后面再讲解：

修饰一个自定义字面量与

使用枚举类型表示一组字面量。

public static final String ONEEDUNAME=”java and android 自学网”;//定义一个字符串常量

Java表达式和运算符

算术运算符

和我们小学学得算术运算一样，不过这里要注意，整数的除法如果结果有小数，那么会自动的截断小数部分，例如以下这个例子：

int x = 10;
int y = 6;
int result=x/y;
System.out.println(result);

其结果是1，不会带有小数部分，也就是整数运算后的到的结果也是整数，不会自动变成浮点数。

上面所具的例子都是表示二元运算符，也就是说有两个运算参数，其中“+”和“-”两个符也可以表示一元运算符，分别表示正数和负数这些运算符也可以组合成为一个复杂的运算式子，如下面这个例子：

int x = 10,y = 6,a = 20,b = 2;
int result=-x/y+a-b+a%x+-a;
System.out.println(result);

运算的优先级和我们平时的数学算法一样，基本按照从左到右的计算，其中+和-具有相同的优先级，它们的优先级比*，/和%的运算低，但是*，/和%的运算优先级别又比一元运算符的+和-要低。与我们的数学算式一样，算术表达式也支持使用小括号更改计算的优先级，如下面这个例子:

int x = 10,y = 6,a = 20,b = 2;
int result=(x+y)*a+(a-b)*x;
System.out.println(result);

上面示例会先计算小括号的x+y和a-b两个式子，然后在按照先先乘除后加减，从左到右的计算顺序。有关优先级的详细讲解我们在后面的章节中讲解。

赋值运算符

在程序中“=”的意义与我们平时的数学计算的式子不同，他表示赋值的意思，就是把赋值表达式中右边的计算结果赋值左边的变量中。如下面这里例子都是赋值运算：

int x=5； //用专业的说法是把右边5的值赋值给左边的int变量x
int y=x=6; // y和x都赋值6；
int a;
a=100+200;

在赋值运算时，经常会出现左边的变量重复出现在赋值表达式的右边，如：

int a=100;
a=a+200;

赋值运算符的计算顺序都是从右边开始计算，也就是会先计算a+200的值，然后才会赋值给a，所以上面的例子会先取得a变量的值100，然后再加上200，最后把300的结果赋值给a变量，这时候a变量的值就是300。（赋值运算从右边开始大）

由于像上面这样的运算在程序中常常会出现，为了提高编译的效率和书写代码的简易，java提供了一些相应的运算符号如：

+= -= *= /= %= >>= <<= &= ^= |=

有些运算符，我们在后面的章节中才会介绍，这些自操作赋值运算符是一种对编码简化的写法。有时运算比较复杂是为保证编码的可读性也可不用这种缩写的语法。像上面的列子：

a=a+200;

等价于以下这几种形式：

a+=200;

归纳一下也就是，如果expr1和expr2分别代码两个表达式，op代表运算符号，那么：

expr1=(expr1) op (expr2)

等价于

expr1 op= expr2;

注意第一个表达式，有时候括号是不可缺少的，比如以下这个例子：

自增1自减1：

我们要实现一个数的自增1或者自减1，目前可以有以下两种方法：

a=a+1或者a+=1；

a=a-1或者a-=1；

但是由于在编写程序时自增1或者自减1用得非常频繁，java语言提供了两个专门用于变量的自增1和自减1的特殊运算符，其中++是自增1运算符号，可以使操作数自增1，--是自减1运算符号，可以使操作数自减1。比如下面这个例子就是自增1：

int i=1;
i++;
System.out.println(i);//结果是2

需要特别留意的是++和--运算符可以前置、后置，都是合法的语句，如a++和++a都是合法的，上面这两种写法其最终的结果都是是变量a的值加1了，但是它们之间也是有区别的，其区别是：表达是++a会先将a的值自增1，然后在使用变量a。而表达式a++是先使用了a的值，然后再让a的值自增1。也就是说在一些表达式，使用a++和使用++a得到的结果时不一样的。例如：

比较运算符

比较运算符也称为关系运算符，用于测试两个操作数之间的关系。使用关系运算符表达式的最终结果为 boolean 型，也就是其结果只有两个true和false。具体运算符号如下表所示

由上表所示，我们判断两个数是否相等使用两个等号（==），它与（!=）具有相同的优先级。比>、<、>=、<=的优先级要高，但是算术运算符的优先级比关系运算符高，也就是说i<a+100和i<(a+100)等结果都是一样。不同数据类型之间也可以进行比较，它们会被自动转换为相同的类型后再比较，如以下例子：

int x = 10;
float y=10.9f;
char a='0';
System.out.println(x>y);
System.out.println(a>x);

逻辑运算符

1、与运算

与运算符号有&和&&两个，表示必须两个条件都为true时，结果才能返回true。如：

(1>2)&&(1>3) (1>2)&&(3>1) (2>1)&&(1>3) (2>1)&&(3>1)

其对应比较运算过程就是

false&&false false&&true true&&false true&&true

也就是最后的结果就是前面三个的返回都是false，只有最后一个是true。

2、或运算

或运算符号有|和||两个，表示两个条件只要有一个满足为true，最后结果返回true。还是以上面例子说明如：

(1>2)&&(1>3) (1>2)&&(3>1) (2>1)&&(1>3) (2>1)&&(3>1)

其对应比较运算过程就是

false&&false false&&true true&&false true&&true

也就是最后的结果就是第一个返回为false，后面三个返回都是true。

3、取反运算符

取反运算符只有一个!,它是单元运算符，这个比较简单，如果是true就返回false，false就返回true，如下面的示例：

!(1>2) !(2>1)

其对应比较运算过程就是

!false !true

所以第一个返回是true，第二个返回是false。

4、组合的逻辑运算符

逻辑符可以组合使用,并结合上面比较运算符，形成一个复杂的条件判断，比如下面这个判断是否是闰年的条件判断式，闰年的判断条件是，如果此年份是4的陪数，但不是100的陪数，那么就是闰年，如果是100的陪数，还要是400的倍数才是闰年，实现代码如下：

      int year=2008;
   boolean result=year%4==0&&year%100!= 0||year % 400 == 0;

、 &和&&、|和||的区别

参与运算的都是boolean布尔类型，在上表中的逻辑运算符&和&&、|和||的示例中，结果的都是一样的，但是在运算时却有区别。&&和||有一些比较特殊的属性，其运算的顺序是从左至右进行判断的，但是对&&而言如果在判断时得到的结果是false时，那么后面的计算就不会继续，对||而言，如果在判断时得到的结果是true，那么后面的计算也不会继续，这种机制称之为阻断判断或者短路判断，在有些情况之下，这种机制可以提高程序运行的效率。

条件运算符

java的条件运算符是三元运算符，也就是说有三个参数参与运算，其功能是对表达式条件进行判断，根据判断结果是true或者false两种情况赋予赋予不同的返回值,其语法如下：

表达式?值1:值2;

int a=2;
int b=1;
int c=(a>b)?3:4;
System.out.println(c);

位运算符

位运算符在java的企业应用中使用的频率并不高，但是在一些追求效率和编写底层应用时，还是会用到位运算符，前面介绍的各种运算都是基本都是以字节作为最基本位进行运算的，而位运算符是以位(bit)作为运算单位的，所以要弄明白位运算符，必须要知道二进制表示法。

int a=1;//int 是 32 位取最后的8位是 00000001按位位与运算符"&"就是实现参与运算的两个数对应的二进制位数执行与的操作。如果两个二进位均为1时，结果位才为1，否则就为0。前面介绍过，计算机都是采用补码的方式运行的，所以参与运算的数都是补码方式进行的。如下面所示例子：1、按位与

按位或

按位异或

总结：会自己根据程序的需要，将java给其搞明白，全部都将其给搞明白都行啦的样子与打算。

Java运算符优先级

运算符优先级

在一系列复杂的运算符中，优先级较高的运算符总是先被运算，然后才按照优先级的高低依次完成所有计算，在前面的章节中我们也简单了提到了一些运算符的优先顺序，其中优先级最高的是小括号括号：”(...)”,多个括号分割运算表达式会让一个复杂的表达式变得更具有可读性。其他的运算符按照优先级别的高低排序分别是：自加/减运算符、算术运算符、比较运算符、逻辑运算符、赋值运算符。具体请参考下表：

当两个运算符拥有同样优先级时跟代数的四则运算一样，从左到右依次执行表达式。当要表示一个比较复杂的运算表达式时，最好多使用小括号，可以使用表达式更加清晰，对于一些比较复杂的，尽量可以分开多个步骤，这样虽然可能会降低效率，但是可以提高代码的可读性。比如下面这个例子：

类型转换

我们在写运算符时，经常会碰到一个运算符中包含好几个不同数据类型的参数，这就涉及到数据类型的转换。java有两种类型的转换，分别是自动类型转换和强制类型转换。

1、自动类型转换

一般而言，java编译器还是比较智能的，对不同数据类型的参数，会自动转换类型，为了不至于数据的丢失，一般是较窄的数据类型转换为较宽的数据类型。也就是说如果一个short类型和一个int类型相加，那么结果就会自动转换为int类型，因为int比short数位要宽，再有如果int类型和float类型相加，那么结果是float类型，因为浮点型比整型所能表示的数据要宽。另外我们也可以把一个较窄的数据类型直接赋值给一个较宽的数据类型。总结一下，在赋值或者计算时，只要满足以下条件，就会发生自动类型转换：

（1）两种类型兼容；

（2）目标类型大于源类型；

例如：

（1）byte、char和 short 型值可提升为 int 型。如果一个操作数为 long 型，则整个表达式结果为 long 型

（2）如果一个操作数为 float 型，则整个表达式结果为 float 型。而如果一个操作数为 double 型，则整个表达式结果为 double 型

2、强制类型转换

强制转换用于显式类型转换。但是强制类型转换需要小心使用，因为如果被转换的值的数据类型大于其目标类型，就会丢失部分信息。类型强制转换使程序将变量视为某种类型，尽管此变量中包含的是另一类型的数据，其具体格式如下：

float a = 346.756565f;
int b = (int) a + 10;       // 将 c 转换为整型
System.out.println(b);

条件判断

java语言和C 语言类似，主要包括三种基本的控制流结构：

1. 程序顺序执行

2. 程序的判断结构

3. 程序的循环结构

如果把前面所学习的关键字理解成java语言的词汇量的话，那么结构化程序设计就是java语言所谓的”语法”了，这种跟计算机沟通的语言很简单。

前面章节中我们提过，java是以分号(;)作为一个语句的结束的，与换行符没有关系，任何一句表达式后面都必须带有一个分号(;)，这样才算正常结束，否则会报语法错误，例如：

int a=100;
System.out.println(a);

以上都成为单条语句，而把多个语句放到一个形如 “{...代码...}”这样代码块中，成为语句块，就是以左大括号“｛”开始，以右大括号结束“｝”的代码我们成为语句块，左右大括号必须成对出现，语句块可以互相嵌套。语句块可以作为一个整体，类似把多个语句块组合成为一个语句块。我们在代码中可以任意使用包含多个语句成为一段语句块,有时也称为程序块。但是在一些情况下，大括号是不可缺少的，比如定义一个类的时候，或者定义一个普通方法时，后面就必须要使用大括号，包住一段语句块。例如以下的：

public class Abc {//这个是必须的
   public static void main(String[] args) {//这个是必须的
      float a = 346.756565f;
      //这个大括号可以删除
      {
         int b = (int) a + 10; // 将 a 转换为整型
         System.out.println(b);
      }
   }
}

下面我们讲到的条件判断和循环判断的语法是会大量使用到程序块。

判断逻辑是我们生活中最常见的逻辑判断，计算机来执行跟人类思维也是极为类似的：如果[条件成立]就怎样做，否则就那样做。可以这么说，计算机最擅长的就是判断true/false了。

一、if-else 语句

if语句是最常见的判断语句，通过对条件(conditional)的判断觉得程序的走向。其基本格式如下：

if(条件表达式)

语句1

else

语句2

在执行该判断语句前，都是先执行了条件表达式的语句，条件表达式的返回结果必须是布尔值(boolean)，根据条件表达式的返回，如果是true，那么就执行语句1的内容，如果是false就执行else后面的语句2。如下面这个例子：

int  i=1;
if(i>10)
  System.out.println(i+"大于10");
else
  System.out.println(i+"不大于10");

先定义了整型i并赋值1，然后在执行if里面的条件判断式i是否大于10，返回的结果是false，所以执行的是else后面的语句。

在上面的格式中， else是可选部分，所以最简单的条件判断式如下：

if(条件表达式)

语句1

int  i=1;
if(i>10)
   System.out.println(i+"大于10")

由于条件判断是false，所以这个程序不会输出任何内容。也正是因为else是可选部分，在嵌套使用的时候就会出现理解上的问题，有时候我们面对下面这个例子的时候就会感觉不清晰了。

int i = 1;
if (i > 10)
   if (i < 5)
       System.out.println(i + "小于5");
   else
       System.out.println(i + "不大于10");

else是对应那一个if呢？java是与最近一个if配对的。程序员在写代码时，适当的缩进代码也可以提高代码的可读性，当然我们有更好的解决办法。

if和else后面可以跟着语句，当然也可以跟着语句块，其格式如下：

if(条件表达式){

语句块1

}else{

语句块2

}

if (i > 10) {
    if (i < 5) {
        System.out.println(i + "小于5");
    } else {
        System.out.println(i + "不大于10");
   }
}

二、else-if 语句

有时候条件判断不止两个，可能就需要使用else-if语句了，其语法格式如下：

if(条件表达式)

语句1

else if(条件表达式)

语句2

else if(条件表达式)

语句3

else if(条件表达式)

语句4

...

else

语句

这样的语句在我们以后的编程中会经常用到，判断的过程是从上往下的判断条件表达式，如果第一个返回的是false就会判断第二个，依次类推，但是如果其中一个返回了true，那么就会执行后面的语句，然后整个else-if语句就会退出，后面如果还有else-if语句也不会在去判断执行的了。我们常常也会在最后面添加一个else语句，当然这也是可选的，这样的效果就是如果上面的所有的if判断都是false，那么就会执行else后面的语句。像上面的if-else一样，后面也是可以跟着语句块的，为了增强程序的可读性，我们后面也常常会使用语句块。格式如下：

if(条件1){

条件1==true时执行的逻辑

}else if(条件2){

条件2==true时执行的逻辑

}else if(条件n){

条件n==true时执行的逻辑

}else{

以上条件均不满足而执行的默认的逻辑

}

int uage = 17;
if (uage < 18) {
   System.out.println("Sorry,请关注学业!");
} else {
   System.out.println("欢迎登陆！");
}

int result=85;//成绩  
if(result>90){
  System.out.println("优秀");
}else if(result>80){
  System.out.println("良好");
}else if(result>60){
  System.out.println("合格");
}else{
  System.out.println("不合格");
}

import java.util.Scanner;
 public class Tt {
   public static void main(String[] args) {
      int num0;//第一个数
      int num1;//第二个数
      int type;//计算类型
 
      System.out.print("*"请输入num0: "*");
      Scanner scr = new Scanner(System.in);
      num0 = scr.nextInt();//程序会在此等待用户的输入
 
      System.out.print("*"请输入num1: "*");
      scr = new Scanner(System.in);
      num1 = scr.nextInt();
System.out.print("*"请输入计算类型(0表示加 ; 1表示减 ; 2表示乘  ; 3表示除): "*");
      scr = new Scanner(System.in);
      type = scr.nextInt();
 
if (type == 0) {
      System.out.println(num0 + "*"+"*" + num1 + "*" ="*" + (num0 + num1));
   } else if (type == 1) {
      System.out.println(num0 + "*"-"*" + num1 + "*" ="*" + (num0 - num1));
   } else if (type == 2) {
      System.out.println(num0 + "*"*"*" + num1 + "*" ="*" + (num0 * num1));
   } else if (type == 3) {
         // 除法，使用嵌套的if语句判定除数不能为0
       if (num1 == 0) {
          System.out.println("*"除数不能为0"*");
      } else {
          System.out.println(num0+"*"/"*"num1+ "*" ="*" + (num0 / num1));
      }
 
   } else {
   // 非法输入
     System.out.println("*"您的输入有误!计算类型只能是[0,1,2,3]"*");
   }
   }
}

三、switch选择语句

switch语句是另一种判断语句的写法，这种语句在选择时是对case子句的值进行相等测试，其功能性其实和if判断语句一样，仅仅只是书写的方式不同，两者之间可以互通，语法上面没有if语句简介。其具体的语法格式如下：

switch(被判断的变量)

{

case 条件1:

执行条件1的逻辑

break;

case 条件2:

执行条件1的逻辑

break;

case n:

执行条件n的逻辑

break;

default:

以上条件均不满足而执行的默认的逻辑

}

switch后面的只是被判断的变量，当与case后面的条件相等是，那么case后面的语句就会执行，最后面的default是可选项，可根据你的业务逻辑需要决定是否添加，功能类似else语句，就是上面所有的case条件都不满足时就会执行default后面的语句。

值得注意的是，在JDK 7以前参加被判断的变量的类型只可以是int, byte, char, short等数据类型，但是在JDK 7以后，被判断的变量的类型被增强支持对字符串String的判断。如果你还是使用JDK 6就要特别注意这一点了。

一般来说，switch与case成功匹配，还会继续顺序执行以后所有的程序代码，因此一般都要在判断成功后面添加break语句跳出判断语句块。有关break关键字的详细说明我们会在后面的章节中说明。

看看这个例子：已知变量int month=1，使用switch判断语句，如果month等于1就输出"一月"，等于2就输出"二月"，如此类推。实现代码如下：

int month=4; 
switch(month){
      case 1:
         System.out.println("一月");
         break;
      case 2:
         System.out.println("二月");
         break;
      case 3:
         System.out.println("三月");
         break;
      case 4:
         System.out.println("四月");
         break;
           //...中间的5~12用户自己补充。
      default:
         System.out.println("month只能是1~12");