Java   数据类型和运算符

Java 基础语法

一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

第一个Java程序

下面看一个简单的Java程序，它将打印字符串 Hello World

下面将逐步介绍如何保存、编译以及运行这个程序：

• 打开Notepad，把上面的代码添加进去；
• 把文件名保存为：HelloWorld.java；
• 打开cmd命令窗口，进入目标文件所在的位置，假设是C:\
• 在命令行窗口键入 javac HelloWorld.java  按下enter键编译代码。如果代码没有错误，cmd命令提示符会进入下一行。（假设环境变量都设置好了）。
• 再键入java HelloWorld 按下Enter键就可以运行程序了

你将会在窗口看到 Hello World

C : > javac HelloWorld.java
C : > java HelloWorld 
Hello World

Gif 图演示：

基本语法

编写Java程序时，应注意以下几点：

• 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

Java标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

关于Java标识符，有以下几点需要注意：

• 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 关键字不能用作标识符
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

• 访问控制修饰符 : default, public , protected, private
• 非访问控制修饰符 : final, abstract, strictfp

在后面的章节中我们会深入讨论Java修饰符。

Java变量

Java中主要有如下几种类型的变量

• 局部变量
• 类变量（静态变量）
• 成员变量（非静态变量）

Java数组

数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。

Java枚举

Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。

实例

注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

Java关键字

下面列出了Java保留字。这些保留字不能用于常量、变量、和任何标识符的名称。

Java注释

类似于C/C++，Java也支持单行以及多行注释。注释中的字符将被Java编译器忽略。

Java 空行

空白行，或者有注释的行，Java编译器都会忽略掉。

继承

在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。

接口

在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

Java 源程序与编译型运行区别

如下图所示：

Java 基本数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。

Java 的两大数据类型:

• 内置数据类型
• 引用数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

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）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

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"混淆，不容易分辩。所以最好大写。

float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

double：

• double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
• 浮点数的默认类型为double类型；
• double类型同样不能表示精确的值，如货币；
• 默认值是 0.0d；
• 例子：double d1 = 123.4。

boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

char：

• char类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（即为0）；
• 最大值是 \uffff（即为65,535）；
• char 数据类型可以储存任何字符；
• 例子：char letter = ‘A‘;。

实例

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

编译以上代码输出结果如下所示：

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

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

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

引用类型

• 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。
• 一个引用变量可以用来引用与任何与之兼容的类型。
• 例子：Site site = new Site("Runoob")。

Java常量

常量在程序运行时，不会被修改的量。

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

final double PI = 3.1415927;

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

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

byte a = 68;
char a = ‘A‘

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

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

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

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

"Hello World"
"two\nlines"
"\"This is in quotes\""

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

char a = ‘\u0001‘;
String a = "\u0001";

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

自动类型转换

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

转换从低级到高级。

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

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

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: 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。

强制类型转换

• 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

隐含强制类型转换

• 1. 整数的默认类型是 int。

• 2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

小狗的年龄是: 7

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

$ javac Employee.java 
$ java Employee
名字 : RUNOOB
薪水 : 1000.0

开发人员平均工资:10000.0

1. 
   

   Java 中静态变量和实例变量区别

   • 静态变量属于类，该类不生产对象，通过类名就可以调用静态变量。
   • 实例变量属于该类的对象，必须产生该类对象，才能调用实例变量。

   在程序运行时的区别：

   • 实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
   • 静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

   总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

   例如，对于下面的程序，无论创建多少个实例对象，
   永远都只分配了一个 staticInt 变量，并且每创建一个实例对象，这个 staticInt 就会加 1；但是，每创建一个实例对象，就会分配一个 random，
   即可能分配多个 random ，并且每个 random 的值都只自加了1次。

   public class StaticTest {
   	private static int staticInt = 2;
   	private int random = 2;
   
   	public StaticTest() {
   		staticInt++;
   		random++;
   		System.out.println("staticInt = "+staticInt+"  random = "+random);
   	}
   
   	public static void main(String[] args) {
   		StaticTest test = new StaticTest();
   		StaticTest test2 = new StaticTest();
   	}
   }

   执行以上程序，输出结果为：

   staticInt = 3  random = 3
   staticInt = 4  random = 3

   h七宝

      h七宝

2.    大白小爱

    

   静态变量是用来声明规则的，一旦固定都是用用来引用的，类似社会中的法律，规定好后你只能拿来说。但是也可以改的，通过重新的声明法律就行。

   大白小爱

      大白小爱

3.    stinkaroo

    

   java 实例变量在整个类内部是可访问的，而不管实例变量声明在类的哪个位置。

   import java.io.*;
   
   public class Employee{
   
   	public Employee (String empName){
   		name = empName;
   	}
   	
   	public void setSalary(double empSal){
   		salary = empSal;
   	}
   	
   	public void printEmp(){
   		System.out.println("name:" + name);
   		System.out.println("salary:" + salary);
   	}
   	
   	public static void main(String args[]){
   		Employee empOne = new Employee("RUNOOB");
   		empOne.setSalary(1000);
   		empOne.printEmp();
   		System.out.println(empOne.salary);
   	}
   	public String name;
   	private double salary;
   }

   比如在上面代码中，尽管实例变量声明在类的尾部，在之前方法中仍可访问。

    

   Java 运算符

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

   • 算术运算符
   • 关系运算符
   • 位运算符
   • 逻辑运算符
   • 赋值运算符
   • 其他运算符

   算术运算符

   算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

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

   操作符	描述	例子
   +	加法 - 相加运算符两侧的值	A + B 等于 30
   -	减法 - 左操作数减去右操作数	A – B 等于 -10
   *	乘法 - 相乘操作符两侧的值	A * B等于200
   /	除法 - 左操作数除以右操作数	B / A等于2
   ％	取模 - 左操作数除右操作数的余数	B%A等于0
   ++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
   --	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

   实例

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

   实例

   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

   自增自减运算符

   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

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

   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

   ---

   关系运算符

   下表为Java支持的关系运算符

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

   运算符	描述	例子
   ==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假(非真)。
   !=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
   >	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）非真。
   <	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
   > =	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
   <=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

   实例

   下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.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

   ---

   位运算符

   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：

   操作符	描述	例子
   ＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
   |	如果相对应位都是0，则结果为0，否则为1	（A | B）得到61，即 0011 1101
   ^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
   ?	按位补运算符翻转操作数的每一位，即0变成1，1变成0。	（?A）得到-61，即1100 0011
   <<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
   >>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
   >>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

   实例

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

   Test.java 文件代码：

   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 >> 15
   a >>> 15

   ---

   逻辑运算符

   下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

   操作符	描述	例子
   &&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
   | |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
   ！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

   实例

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

   实例

   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

   短路逻辑运算符

   当使用与逻辑运算符时，在两个操作数都为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。

   ---

   赋值运算符

   下面是Java语言支持的赋值运算符：

   操作符	描述	例子
   =	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
   + =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
   - =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C -  A
   * =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
   / =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A等价于C = C / A
   （％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
   << =	左移位赋值运算符	C << = 2等价于C = C << 2
   >> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
   ＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
   ^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
   | =	按位或赋值操作符	C | = 2等价于C = C | 2

   实例

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

   Test.java 文件代码：

   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

   ---

   条件运算符（?:）

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

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

   实例

   Test.java 文件代码：

   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

   ---

   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

   ---

   Java运算符优先级

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

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

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

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

   类别	操作符	关联性
   后缀	() [] . (点操作符)	左到右
   一元	+ + - ！?	从右到左
   乘性	* /％	左到右
   加性	+ -	左到右
   移位	>> >>>  <<	左到右
   关系	>> = << =	左到右
   相等	==  !=	左到右
   按位与	＆	左到右
   按位异或	^	左到右
   按位或	|	左到右
   逻辑与	&&	左到右
   逻辑或	| |	左到右
   条件	？：	从右到左
   赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
   逗号	，	左到右

    

   笔记列表

   在判断一个实例引用的类型时，使用的是实际类型，而不是声明的类型。在下面的代码中，

   Vehicle v2 = new Car();	// v2 是 Car 类型

   v2 是 Car 类型，而不是 Vehicle 类型。

   class Vehicle {}
   
   public class Car extends Vehicle {
       public static void main(String args[]){
   		Car c1 = new Car();
   
   		Vehicle v2 = new Car();	// v2 是 Car 类型
   		Vehicle v3 = new Vehicle();
   
   		//Car 是 Vehicle类型, Vehicle 不是 Car 类型
   		boolean result1 =  c1 instanceof Vehicle;	// true
   		boolean result2 =  v2 instanceof Car;		// true
   		boolean result3 =  v2 instanceof Vehicle;	// true
   		boolean result4 =  v3 instanceof Car;	  	// false
   
   		System.out.println(result1);
   		System.out.println(result2);
   		System.out.println(result3);
   		System.out.println(result4);
      }
   }

Started with 0 instances
Created 500 instances

1.  

   JAVA 的类有 2 种访问权限: public、默认。

   而方法和变量有 4 种：public、默认、protected、private。

   其中默认访问权限和 protected 很相似，有着细微的差别。

   • public 意味着任何地方的其他类都能访问。
   • 默认则是同一个包的类可以访问。
   • protected 表示同一个包的类可以访问，其他的包的该类的子类也可以访问。
   • private 表示只有自己类能访问。

    

2. 整个世界都打包成一块，同时划分为四个层次: 联合国（public）【其他包】、国家（protected）【继承子孙】、洲际（default）【同一包】、个人（private）【当前类】。

   联合国制定规则所有人都可以用，国家制定的只有在国家内可以用，各联邦洲因地制宜有制定当地民法，个人制定的就给个人使用。

Java 数据类型和运算符