java是一种强类型语言，每个变量都必须声明其类型
java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域
每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束
type varName [=value] [{,verName[=value]}];
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量
public class five{
public static void main(String[] args){
int a=1,b=2,c=3;//不推荐这样，缺乏程序可读性
}
}
变量作用域
类变量
实例变量
局部变量
public class five{
Static int aacc = 0;//类变量，静态的，static
String str = “Hello，World”；//实例变量；从属于对象，不需要大括号，如果不自行初始化，这个类型的默认值1、0.0，布尔值默认是flase
public void methoo(){
int i = 0;//局部变量，两个大括号内有效，必须声明和初始化值
}
}
初始化后不能再改变值，不会变动的值
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
常量名一般使用大写字符
final 常量名=值
final 都变了=PI = 3.14
变量的命名规范
所用的变量、方法’、类名：见名知意
类成员变量：首字母大小写和驼峰原则
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线
类名：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则
算术运算符：+，-，*，/，%（模运算，即取余运算），++（自增）， --（自减）
赋值运算符=
关系运算符：>,<,>=,<=,==,!=（不等于），instanceof
逻辑运算符：&&（与）,||（或）,!（非）
位运算符：&，|，^，~，>>,<<,>>>
条件运算符？:
扩展赋值运算符：+=，-=，*=，/=
package operator;
?
public class one {
public static void main(String[] args) {
//二元运算符
//Ctrl+D 复制当前行到下一行
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b);//结果是0.5，需要转换
}
}
package operator;
?
public class two {
public static void main(String[] args) {
long a = 1212123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d);//Long
System.out.println(b+c+d);//int
System.out.println(c+d);//int
//有long参与时结果自动为long类型，double同理
//没long参与结果默认为int类型
}
}
package operator;
?
public class four {
public static void main(String[] args) {
//++ -- 自增 自减 一元运算符
int a = 3;
int b = a++;//执行完这行代码后，先给b赋值，再自增
//a++ a = a + 1
System.out.println(a);//结果4
int c = ++a;//执行完这行代码后，先自增，再给c赋值
System.out.println(a);//结果5
System.out.println(b);//结果3
System.out.println(c);//结果5
}
}
b = a++ ，先给b赋a的值，再把a加1，完整执行完后b=3，a=4
package operator;
?
public class three {
public static void main(String[] args) {
//关系运算符返回的结果：正确/错误 （布尔值）
int a = 10;
int b = 20;
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
//==========================================
//取余，又叫模运算
int c = 21;
System.out.println(c%a);//c/a=21/10=2......1
}
}
逻辑运算符
package operator;
?
public class five {
public static void main(String[] args) {
//逻辑运算符
//与 或 非
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量有一个为真，则结果才为true
System.out.println("!(a && b):"+!(a&&b));//如果是真，则变为假，如果是假，则变为真
//短路运算
}
}
//位运算
/*
A = 0011 1100
B = 0000 1101
?
A&B = 0000 1100（A且B为1，输出1）
A|B = 0011 1101（A或B为1，输出1）
A^B = 0011 0001（不同为1）
~B = 1111 0010（与B相反）
?
<< *2
>> /2
直接作用于底层，效率高
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);//结果为16
}
}
public class one {
public static void main(String[] args) {
//扩展运算符
int a = 1;
int b = 2;
a+=b;//a=a+b
a-=b;//a=a-b
System.out.println(a);
}
}
//字符串连接符：运算中有字符串，数字也被当做字符串，所以1+2=12
//但如果数字在前，字符串在后，那么数字依旧会正常运算
int c = 1;
int d = 2;
System.out.println(""+c+d);//结果是12
System.out.println(c+d+"");//结果是3
}
}
public class two {
public static void main(String[] args) {
//三元运算符
// x ? y : z
//如果x=true，则结果为y，否则结果为z
?
int score = 80;
String type = score<60 ?"不及格":"及格";
System.out.println(type);
}
}
| 运算符 | 结合性 |
|---|---|
| [ ] . ( ) (方法调用) | 从左向右 |
| ! ~ ++ -- +(一元运算) -(一元运算) | 从右向左 |
| * / % | 从左向右 |
| + - | 从左向右 |
| << >> >>> | 从左向右 |
| < <= > >= instanceof | 从左向右 |
| == != | 从左向右 |
| & | 从左向右 |
| ^ | 从左向右 |
| | | 从左向右 |
| && | 从左向右 |
| || | 从左向右 |
| ?: | 从右向左 |
| = | 从右向左 |
优先级与求值顺序无关。如a+b && bc，虽然优先级最高，但这个表达式求值顺序是从左到右。
优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。
相同优先级中，按结合性进行结合。大多数运算符结合性是从左到右，只有三个优先级是从右至左结合的，它们是
基本的优先级需要记住：
指针最优，单目运算优于双目运算。如正负号。
先算术运算，后移位运算，最后位运算。请特别注意：1 << 3 + 2 & 7等价于 (1 << (3 + 2))&7.
逻辑运算最后结合。
运算符
运算符是一种特殊的函数，它们具有一个或多个操作数并返回相应的值。操作数是被运算符用作输入的值，通常是字面值、变量或表达式。运算符可以是一元、二元或三元的，一元运算符有1个操作数，二元运算符有2个操作数，三元运算符有3个操作数。
结合性
当一个运算对象两侧的运算符优先级别相同时，则按运算符的结合性来确定表达式的运算顺序。关于结合性的概念在其他高级语言中是没有的，这是
原文：https://www.cnblogs.com/qianshui0404/p/14380060.html