变量
变量可以指在计算机存储器里存在值的被命名的存储空间。

变量通常是可被修改的，即可以用来表示可变的状态。这是 Java 的基本概念之一。

程序通过改变变量的值来改变整个程序的状态。为了方便使用变量，所以变量都需要命名，叫做变量名。

在 Java 中，变量需要先声明 (declare) 才能使用。在声明中，说明变量的类型，赋予变量以特别名字，以便在后面的程序中调用它。你可以在程序中的任意位置声明变量，语法格式如下：

数据类型 变量名称;

例如：

int a = 1;

常量
常量代表程序运行过程中不能改变的值。我们也可以把它们理解为特殊的变量，只是它们在程序的运行过程中是不允许改变的。常量的值是不能被修改的。

Java 中的 final 关键字可以用于声明属性（常量），方法和类。当 final 修饰属性时，代表该属性一旦被分配内存空间就必须初始化，它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中，要求常量名必须大写。

语法格式：

final 数据类型 常量名 = 值;

例如：

final double PI = 3.14;

数据类型：

short：	0	2 个字节	-32,768 到 32,767	Short
int	：    0	4 个字节	-2,147,483,648 到 2,147,483,647	Integer
byte	：0	1 个字节	-128 到 127	Byte
char	：空	2 个字节	Unicode 的字符范围：\u0000（即为 0）到 \uffff（即为 65,535）	Character
long	：0L 或 0l	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	Long
float	：0.0F 或 0.0f	4 个字节	32 位 IEEEE-754 单精度范围	Float
double：	0.0 或 0.0D(d)	8 个字节	64 位 IEEE-754 双精度范围	Double
boolean：	false	1 位	true 或 false	Boolean

String
Java 中使用 String 类来定义一个字符串，字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

String 对象的初始化格式有如下两种：

String s0 = "abc";String s1 = new String("abd");

计算字符串长度
length() 方法：

//方法原型
public int length(){
}

调用方法：字符串标识符.length(); 返回一个 int 类型的整数（字符串中字符数，中文字符也是一个字符）。例如：

String s1 = "abc";
String s2 = "Java语言";
int len1 = s1.length();
int len2 = s2.length();

字符串连接

字符串连接有两种方法：使用 +，比如 String s = "Hello " + "World!"。
使用 String 类的 concat() 方法。
代码示例：String s0 = new String("Hello ");
String s1 = "World" + "!";   //+号连接
String s2 = s0.concat(s1); //concat()方法连接
System.out.println(s2);
copy
而且使用 + 进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。charAt() 方法
charAt() 方法的作用是按照索引值（规定字符串中第一个字符的索引值是 0，第二个字符的索引值是 1，依次类推），获得字符串中的指定字符。例如：String s = "abc";
char c = s.charAt(1);
copy
则变量 c 的值是 'b'。字符串常用提取方法
方法	返回值	功能描述
indexOf(char ch)	int	搜索字符 ch 第一次出现的索引
indexOf(String value)	int	搜索字符串 value 第一次出现的索引
lastIndexOf(char ch)	int	搜索字符 ch 最后一次出现的索引
lastIndexOf(String value)	int	搜索字符串 value 最后一次出现的索引
substring(int index)	String	提取从位置索引开始到结束的字符串
substring(int beginindex, int endindex)	String	提取 beginindex 和 endindex 之间的字符串部分
trim()	String	返回一个前后不含任何空格的调用字符串的副本
说明：在字符串中，第一个字符的索引为 0，子字符串包含 beginindex 的字符，但不包含 endindex 的字符
public class StringTest {public static void main(String[] args) {String s = "abcdefabc";System.out.println("字符a第一次出现的位置为"+s.indexOf('a'));System.out.println("字符串bc第一次出现的位置为"+s.indexOf("bc"));System.out.println("字符a最后一次出现的位置为"+s.lastIndexOf('a'));System.out.println("从位置3开始到结束的字符串"+s.substring(3));System.out.println("从位置3开始到6之间的字符串"+s.substring(3,6));}
}

运算符
运算符顾名思义是一种符号，它是连接一个以上的操作符，实现某种功能的运算。

算术运算符	名称	描述	类型	举例
+	加法	相加运算符两侧的值	双目运算符	a + b 等于 8
-	减法	左操作数减去右操作数	双目运算符	a - b 等于 2
*	乘法	相乘操作符两侧的值	双目运算符	a * b 等于 15
/	除法	左操作数除以右操作数	双目运算符	a / b 等于 1
%	取余	左操作数除右操作数的余数	双目运算符	a % b 等于 2
++	自增	操作数的值增加 1	单目运算符	++i（或 i++） 等于 2
--	自减	操作数的值减少 1	单目运算符	--i（或 i--） 等于 0
其中，自增 (++) 和自减 (--) 运算符有两种写法：前缀（++i,--i）和后缀（i++,i--）。前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算public class ArithmeticOperation {public static void main(String args[]) {int a = 5;int b = 3;int c = 3;int d = 3;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("a % b = " + (a % b));System.out.println("a++ = " + (a++));System.out.println("++a = " + (++a));System.out.println("b-- = " + (b--));System.out.println("--b = " + (--b));System.out.println("c++ = " + (c++));System.out.println("++d = " + (++d));}
}编译运行：
a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4

位运算符
Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。位运算时先转换为二进制，再按位运算。

表格中的例子中，变量 a 的值为 60（二进制：00111100），变量 b 的值为 13（二进制：00001101）：

位运算符	名称	描述	举例
&	按位与	如果相对应位都是 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
public class BitOperation {public static void main(String args[]) {int a = 60;int b = 13;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 = " + (~a));System.out.println("a << 2 = " + (a << 2));System.out.println("a >> 2 = " + (a >> 2));System.out.println("a >>> 2 = " + (a >>> 2));}
}编译运行：
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

逻辑运算符
逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。
表格中的例子中，假设布尔变量 a 为真（true），变量 b 为假（true）：

逻辑运算符	名称	描述	类型	举例
&& 或 &	与	当且仅当两个操作数都为真，条件才为真	双目运算符	(a && b) 或 (a & b) 为假
|| 或 |	或	两个操作数任何一个为真，条件为真	双目运算符	（a || b) 或 (a | b) 为真
!	非	用来反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将得到假	单目运算符	（!a）为假
^	异或	如果两个操作数逻辑相同，则结果为假，否则为真	双目运算符	(a ^ b) 为真
&& 与 || 是具有短路性质，当按优先级顺序计算到当前表达式时，表达式的结果可以确定整个表达式的结果时，便不会继续向后进行判断和计算，而直接返回结果。例如：当使用 && 逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。在计算表达式 (a | b) && (a & a) 时，首先计算 a | b 得到了 false，因为之后是 &&，任何值与 false 进行与操作都是 false，所以可以不用再计算下去，而直接返回 a | b 的结果 false。
public class LogicOperation {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 = " + (!a));System.out.println("a ^ b = " + (a ^ b));}
}
编译运行：
a && b = false
a || b = true
!a = false
a ^ b = true

关系运算符
关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。
表格中的例子中，假设变量 a 为 3，变量 b 为 5：

比较运算符	名称	描述	举例
==	等于	判断两个操作数的值是否相等，如果相等则条件为真	(a == b） 为 false
!=	不等于	判断两个操作数的值是否相等，如果值不相等则条件为真	(a != b) 为 true
>	大于	判断左操作数的值是否大于右操作数的值，如果是那么条件为真	(a > b) 为 false
<	小于	判断左操作数的值是否小于右操作数的值，如果是那么条件为真	(a < b) 为 true
>=	大于等于	判断左操作数的值是否大于或等于右操作数的值，如果是那么条件为真	(a >= b) 为 false
<=	小于等于	判断左操作数的值是否小于或等于右操作数的值，如果是那么条件为真	(a <= b) 为 true
除了上表列出的二元运算符，Java 还有唯一的一个三目运算符 ?: 。语法格式：布尔表达式 ？表达式 1 : 表达式 2;运算过程：如果布尔表达式的值为 true，则返回表达式 1的值，否则返回表达式 2的值。
public class RelationalOperation {public static void main(String args[]) {int a = 3;int b = 5;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("a >= b = " + (a >= b));System.out.println("a <= b = " + (a <= b));System.out.println("a > b ? a : b = " + (a > b ? a : b));}
}
copy
编译运行：
a == b = false
a != b = true
a > b = false
a < b = true
a >= b = false
a <= b = true
a > b ? a : b = 5
强调：
== 和 != 适用于所有的基本数据类型，其他关系运算符不适用于 boolean，因为 boolean 值只有 true 和 false，比较没有任何意义。
== 和 != 也适用于所有对象，可以比较对象的引用是否相同。
引用：Java 中一切都是对象，但操作的标识符实际是对象的一个引用。

运算符优先级
运算符的优先级是帮助我们在一个表达式中如何对于不同的运算符和相同的运算符，进行正确的运算顺序。
运算符的优先级不需要特别地去记忆它，比较复杂的表达式一般使用圆括号 () 分开，提高可读性。
通常优先级由高到低顺序是;
1.增量和减量
2.算术运算符
3.比较运算符
4.逻辑运算符
5.赋值运算符