JAVA语言基础（二）_java中9pins是不是标识符-CSDN博客

本文链接：https://blog.csdn.net/weixin_39236183/article/details/80089927

Java关键字

大家回忆一下我们在学习汉语的时候，开始学的是什么？肯定是先学一些单个的字，只有认识了单个的字，然后才能组成词，然后才能慢慢的到句子，然后到文章。

学习同计算机交流跟这个过程是一样的，首先我们得学习一些计算机看得懂的单个的字，那么这些单个字在 Java 里面就是关键字。

1.1、什么是关键字

Java 语言保留的，Java 的开发和运行平台认识，并能正确处理的一些单词。其实就是个约定，就好比我们约定好，我画个勾勾表示去吃饭。那好了，只要我画个勾勾，大家就知道是什么意思，并能够正确执行了。

关键字这个约定在 Java 语言和 Java 的开发和运行平台之间，我们只要按照这个约定使用了某个关键字，Java 的开发和运行平台就能够认识它，并正确地处理。

1.2、Java中有哪些关键字

abstract do implements private throw boolean double import protected throws break else instanceof public transient byte extends int return true case false interface short try catch final long static void char finally native super volatile class float new switch while continue for null synchronized enum default if package this assert

1.3、Java中关键字的基本含义

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C ++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

注：1)这些关键字的具体含义和使用方法，会在后面用到的地方讲述

2)Java 的关键字也是随新的版本发布在不断变动中的，不是一成不变的

3)所有关键字都是小写的

4) goto和const不是Java编程语言中使用的关键字，但是是Java的保留字，也就是说Java保留了它们，但是没有使用它们。true和false 不是关键字，而是 boolean类型直接量

5)表示类的关键字是 class

二、标识符

现在我们已经知道如何表述一个类了，那就是“class”这个关键字，那么属性和方法怎么表达呢？我们是不是需要对每个属性和方法定义一个名字呢，比如：身高、体重等，这就需要标识符了。

2.1、什么是标识符

Java语言中，对于变量，常量，函数，语句块也有名字，我们统统称之为Java标识符。

标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。

2.2、标识符的命名规则及建议

2.2.1 规则

1）首字母只能以字母、下划线、$开头,其后可以跟字母‘下划线、$和数字示例：$abc 、 _ab 、ab123 等都是有效的

2）标识符区分大小写（事实上整个 Java 编程里面都是区分大小写的） abc 和 Abc 是两个不同的标识符

3）标识符不能是关键字

4）标识符长度没有限制

2.2.2 建议

1）如果标识符由多个单词构成，那么从第二个单词开始，首字母大写示例：isText 、 canRunTheCar 等

2）标识符尽量命名的有意义，让人能够望文知意

3）尽量少用带$符号的标识符，主要是习惯问题，大家都不是很习惯使用带$符号的标识符；还有在某些特定的场合，$具有特殊的含义

4）由于Java语言使用Unicode字符集，所以字母包括： v ‘A’-‘Z’和‘a’-‘z’；

5）标识符不应该使用中文，虽然中文标识符也能够正常编译和运行，其原因如上一点讲到的：是把中文当作Unicode字符集中的符号来对待了。

例如如下程序是可以正常编译和运行的，但是不建议这么做： public class Test {

public static void main(String[] args) {

String Java测试 = "中文标识符测试";

System.out.println("Java测试=="+Java测试);

}

运行结果：Java测试==中文标识符测试

示例一

下列哪些是正确的标识符：

myVariable

9pins i a+c testing1-2-3 java¨

My Variable

It's

错误的标识符及其原因分析如下： My Variable //含有空格

9pins //首字符为数字 a+c //加号不是字母 testing1-2-3 //减号不是字母

It's //单引号不是字母 java¨ //与号不是字母

示例二

好了，现在来用 Java 代码表示前面抽象出来的人这个类，如下： class Person{ //姓名 name;

//体重 weight;

//身高 height;

}

发现新的问题来了，我们定义的这个 weight 和 height 应该是有单位的，那么在 Java 中怎么表达给 weight 和 height 设置单位呢？这就需要下面讲的数据类型了。

三、数据类型

3.1、数据类型定义

数据类型简单的说就是对数据的分类，对数据各自的特点进行类别的划分，划分的每种数据类型都具有区别于其它类型的特征，每一类数据都有相应的特点和操作功能。例如数字类型的就能够进行加减乘除的操作。

在现实生活中，我们通常会对信息进行分类，从而使得我们能很容易的判断某个数据是表示一个百分数还是一个日期，我们通常是通过判断数字是否带”%”，或者是否是一个我们熟悉的”日期格式”。

类似的在程序中，计算机也需要某种方式来判断某个数字是什么类型的。这通常是需要程序员显示来声明某个数据是什么类型的，Java就是这样的。Java是一种强类型的语言，凡是使用到的变量，在编译之前一定要被显示的声明。

3.2、数据类型分类

Java 里面的数据类型从大的方面分为两类，一是基本数据类型，一是引用类型。

3.2.1基本数据类型：

1）整数型：byte、short、int、long

2）浮点型：float、double

3）字符型：char

4）逻辑型：boolean

3.2.2引用数据类型：

引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。

3.2.3 基本数据类型说明

1）byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；

最小值是 -128（-2^7）；

最大值是 127（2^7-1）；

默认值是 0；

byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数

最小值是 -32768（-2^15）；

最大值是 32767（2^15 - 1）；

2）Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；

默认值是 0；

例子：short s = 1000，short r = -20000。

3）int：

int 数据类型是32位、有符号的以二进制补码表示的整数；

最小值是 -2,147,483,648（-2^31）；

最大值是 2,147,483,647（2^31 - 1）；

一般地整型变量默认为 int 类型；

默认值是 0 ；

例子：int a = 100000, int b = -200000。

4）long：

long 数据类型是 64 位、有符号的以二进制补码表示的整数；

最小值是 -9,223,372,036,854,775,808（-2^63）；

最大值是 9,223,372,036,854,775,807（2^63 -1）；

这种类型主要使用在需要比较大整数的系统上；

默认值是 0L；

例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

5）float：

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；

float 在储存大型浮点数组的时候可节省内存空间；

默认值是 0.0f；

浮点数不能用来表示精确的值，如货币；

例子：float f1 = 234.5f。

6）double：

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；

浮点数的默认类型为double类型；

double类型同样不能表示精确的值，如货币；

默认值是 0.0d；

例子：double d1 = 123.4。

7）boolean：

boolean数据类型表示一位的信息；

只有两个取值：true 和 false；

这种类型只作为一种标志来记录 true/false 情况；

默认值是 false；

例子：boolean one = true。

8）char：

char类型是一个单一的 16 位 Unicode 字符；

最小值是 \u0000（即为0）；

最大值是 \uffff（即为65,535）；

char 数据类型可以储存任何字符；

例子：char letter = 'A';。

3.3、声明和赋值

3.3.1 什么是声明

声明为Java程序实体引入标识符，能够使用这些名字访问到这些实体，声明实体包括：

类名、属性名、方法名、变量名、参数名、接口名等等。其实简单点说就是定义某个东西并对外宣称它

3.3.2 什么是赋值

赋值就是为一个声明的变量或者常量赋予具体的值，也就是赋予值的意思。使用一个等号”=”来表示。

示例：

int a = 5; 这句话的意思就是，声明一个类型为 int 的变量 a，并将它赋值为 5。

3.4、实例

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：

运行结果如下：

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 10³ =3140，3.14E-3 就是 3.14 x 10^-3 =0.00314。

3.5、自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低 ------------------------------------> 高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

1）不能对boolean类型进行类型转换。

2）不能把对象类型转换成不相关类的对象。

3）在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

4）转换过程中可能导致溢出或损失精度，例如：

int i =128;

byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当强制转换为 int 类型值 128 时候就会导致溢出。

5）浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;

(int)-45.89f == -45

3.5.1 自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

实例：

运行结果为：

char自动类型转换为int后的值等于97

char类型和int计算后的值等于66

解析：c1的值为字符'a',查ascii码表可知对应的int类型值为97，'A'对应值为65，所以i2=65+1=66。

3.5.2 强制类型转换

1）条件是转换的数据类型必须是兼容的。

2）格式：(type)value type是要强制类型转换后的数据类型

实例

public class QiangZhiZhuanHuan{

public static void main(String[] args){

int i1 = 123;

byte b = (byte)i1;//强制类型转换为byte

System.out.println("int强制类型转换为byte后的值等于"+b);

}

运行结果：

int强制类型转换为byte后的值等于123

3.6、Java常量

1）常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

2）虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。

例如：

byte a = 68;

char a = 'A'

3）byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：

int decimal = 100;

int octal = 0144;

int hexa = 0x64;

4）和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"

"two\nlines"

"\"This is in quotes\""

5）字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';

String a = "\u0001";

6）Java语言支持一些特殊的转义字符序列

四、JAVA变量类型

在Java语言中，所有的变量在使用前必须声明，例：

int a, b, c; // 声明三个int型整数：a、 b、c

int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值

byte z = 22; // 声明并初始化 z

String s = "runoob"; // 声明并初始化字符串 s

double pi = 3.14159; // 声明了双精度浮点型变量 pi

char x = 'x'; // 声明变量 x 的值是字符 'x'

Java语言支持的变量类型有：

1）类变量：独立于方法之外的变量，用 static 修饰。

2）实例变量：独立于方法之外的变量，不过没有 static 修饰。

3）局部变量：类的方法中的变量。

实例：

public class Variable{

static int allClicks=0; // 类变量

String str="hello world"; // 实例变量

public void method(){

int i =0; // 局部变量

}

4.1、Java局部变量

4.1.1 局部变量声明在方法、构造方法或者语句块中；

4.1.2 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

4.1.3 访问修饰符不能用于局部变量；

4.1.4 局部变量只在声明它的方法、构造方法或者语句块中可见；

4.1.5 局部变量是在栈上分配的。

4.1.6 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例 :

在以下实例中age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中。

package com.runoob.test;

public class Test{

public void pupAge(){

int age = 7;

System.out.println("小狗的年龄是: " + age);

}

public static void main(String args[]){

Test test = new Test();

test.pupAge();

}

以上实例编译运行结果如下:

小狗的年龄是: 7

4.2、Java实例变量

1）实例变量声明在一个类中，但在方法、构造方法和语句块之外；

2）当一个对象被实例化之后，每个实例变量的值就跟着确定；

3）实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

4）实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

5）实例变量可以声明在使用前或者使用后；

6）访问修饰符可以修饰实例变量；

7）实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

8）实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

9）实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

实例：

以上实例运行结果如下：

4.3、Java静态变量

1)类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。

2)无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

3)静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。

4)静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。

5)静态变量在程序开始时创建，在程序结束时销毁。

6)与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。

7)默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

8)静态变量可以通过：ClassName.VariableName的方式访问。

9)类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例：

以上实例运行结果如下：

开发人员平均工资：10000.0

五、JAVA运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

1）算术运算符

2）关系运算符

3）位运算符

4）逻辑运算符

5）赋值运算符

6）其他运算符

5.1 算术运算符

运算符是用来计算数据的符号。数据可以是常量，也可以是变量。被运算符操作的数我们称为操作数。

（表格中的实例假设整数变量A的值为10，变量B的值为20）

实例：

public class Test {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = 25;

int d = 25;

System.out.println("a + b = " + (a + b) );

System.out.println("a - b = " + (a - b) );

System.out.println("a * b = " + (a * b) );

System.out.println("b / a = " + (b / a) );

System.out.println("b % a = " + (b % a) );

System.out.println("c % a = " + (c % a) );

System.out.println("a++ = " + (a++) );

System.out.println("a-- = " + (a--) );

// 查看 d++ 与 ++d 的不同

System.out.println("d++ = " + (d++) );

System.out.println("++d = " + (++d) );

}

以上实例编译运行结果如下：

a + b = 30

a - b = -10

a * b = 200

b / a = 2

b % a = 0

c % a = 5

a++ = 10

a-- = 11

d++ = 25

++d = 27

5.2 自增自减运算符

5.2.1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

实例：

public class selfAddMinus{

public static void main(String[] args){

int a = 3;//定义一个变量；

int b = ++a;//自增运算

int c = 3;

int d = --c;//自减运算

System.out.println("进行自增运算后的值等于"+b);

System.out.println("进行自减运算后的值等于"+d);

}

运行结果为：

进行自增运算后的值等于4

进行自减运算后的值等于2

解析：

int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4

int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2

5.2.2 前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。

5.2.3 后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算

实例：

public class selfAddMinus{

public static void main(String[] args){

int a = 5;//定义一个变量；

int b = 5;

int x = 2*++a;

int y = 2*b++;

System.out.println("自增运算符前缀运算后a="+a+",x="+x);

System.out.println("自增运算符后缀运算后b="+b+",y="+y);

}

运行结果为：

自增运算符前缀运算后a=6，x=12

自增运算符后缀运算后b=6，y=10

5.3 关系运算符

表格中的实例整数变量A的值为10，变量B的值为20

实例：

下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {

public static void main(String[] args) {

int a = 10;

int b = 20;

System.out.println("a == b = " + (a == b) );

System.out.println("a != b = " + (a != b) );

System.out.println("a > b = " + (a > b) );

System.out.println("a < b = " + (a < b) );

System.out.println("b >= a = " + (b >= a) );

System.out.println("b <= a = " + (b <= a) );

}

以上实例运算结果如下：

a == b = false

a != b = true

a > b = false

a < b = true

b >= a = true

b <= a = false

5.4 位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100

B = 0000 1101

-----------------

A&b = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A= 1100 0011

下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13：

实例：

public class Test {

public static void main(String[] args) {

int a = 60; /* 60 = 0011 1100 */

int b = 13; /* 13 = 0000 1101 */

int c = 0;

c = a & b; /* 12 = 0000 1100 */

System.out.println("a & b = " + c );

c = a | b; /* 61 = 0011 1101 */

System.out.println("a | b = " + c );

c = a ^ b; /* 49 = 0011 0001 */

System.out.println("a ^ b = " + c );

c = ~a; /*-61 = 1100 0011 */

System.out.println("~a = " + c );

c = a << 2; /* 240 = 1111 0000 */

System.out.println("a << 2 = " + c );

c = a >> 2; /* 15 = 1111 */

System.out.println("a >> 2 = " + c );

c = a >>> 2; /* 15 = 0000 1111 */

System.out.println("a >>> 2 = " + c );

}

以上实例编译运行结果如下：

a & b = 12

a | b = 61

a ^ b = 49

~a = -61

a << 2 = 240

a >> 2 = 15

a >>> 2 = 15

5.5 逻辑运算符

逻辑运算符，它是用于布尔值进行运算的，运算的最终结果为布尔值true或false。下表中假设布尔变量A为真，B为假：

实例：

public class Test {

public static void main(String[] args) {

boolean a = true;

boolean b = false;

System.out.println("a && b = " + (a&&b));

System.out.println("a || b = " + (a||b) );

System.out.println("!(a && b) = " + !(a && b));

}

以上实例运行结果如下：

a && b = false

a || b = true

!(a && b) = true

5.5.1 短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

实例：

public class LuoJi{

public static void main(String[] args){

int a = 5;//定义一个变量；

boolean b = (a<4)&&(a++<10);

System.out.println("使用短路逻辑运算符的结果为"+b);

System.out.println("a的结果为"+a);

}

以上实例运行结果：

使用短路逻辑运算符的结果为false

a的结果为5

解析：该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

5.5 赋值运算符

赋值运算符就是为变量赋值的符号，赋值运算符的使用看下图：

实例：

public class Test {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = 0;

c = a + b;

System.out.println("c = a + b = " + c );

c += a ;

System.out.println("c += a = " + c );

c -= a ;

System.out.println("c -= a = " + c );

c *= a ;

System.out.println("c *= a = " + c );

a = 10;

c = 15;

c /= a ;

System.out.println("c /= a = " + c );

a = 10;

c = 15;

c %= a ;

System.out.println("c %= a = " + c );

c <<= 2 ;

System.out.println("c <<= 2 = " + c );

c >>= 2 ;

System.out.println("c >>= 2 = " + c );

c >>= 2 ;

System.out.println("c >>= a = " + c );

c &= a ;

System.out.println("c &= 2 = " + c );

c ^= a ;

System.out.println("c ^= a = " + c );

c |= a ;

System.out.println("c |= a = " + c );

}

以上实例运行结果如下：

c = a + b = 30

c += a = 40

c -= a = 30

c *= a = 300

c /= a = 1

c %= a = 5

c <<= 2 = 20

c >>= 2 = 5

c >>= 2 = 1

c &= a = 0

c ^= a = 10

c |= a = 10

5. 6条件运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

实例：

public class Test {

public static void main(String[] args){

int a , b;

a = 10;

// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30

b = (a == 1) ? 20 : 30;

System.out.println( "Value of b is : " + b );

// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30

b = (a == 10) ? 20 : 30;

System.out.println( "Value of b is : " + b );

}

以上实例运行结果如下：

Value of b is : 30

Value of b is : 20

5. 7 instanceof运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

String name = "James";

boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真。

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

实例：

class Vehicle {}

public class Car extends Vehicle {

public static void main(String[] args){

Vehicle a = new Car();

boolean result = a instanceof Car;

System.out.println( result);

}

以上实例运行结果如下：

true

5. 8 Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。