由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
低------------------------------------------------>高
byte,short,char -> int -> long -> float -> double//小数的优先级一定大于整数
运算中，不同类型的数据先转换为同一类型，然后进行运算。
强制类型转换
l 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出，格外要注意。（什么叫做逆转换呢？比如我们byte b = 9;int i = b;（这两行属于正常的隐式转换数据类型，它是自动的）。但是我们反过来讲，比如int k =7;byte b0 = k;这样就不行了，不能把int类型转换为byte类型，不能自动转换，如果我们要强制转换呢？例如int k = 7;byte b0 = (byte)k;（这个就是强制转换数据类型，它是手动的，强制的转换数据类型要用英文的小括号()括起来）。）
l 通常，字符串不能之间转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
? 如：String a = “43”;int i = lnteger.parselnt(a);
? boolean类型不可以转换为其它的数据类型。
自动类型转换
自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
低------------------------------------------------>高
byte,short,char -> int -> long -> float -> double
例如byte转换成int（byte b = 2;int x = b;输出System.out.print(x);输出结果为2）；假如你想大转小，int转换成byte，例：int i = 0;byte b = i；这样是错误的，异常的，这种异常叫做编译期异常，只有在Javac的时候可以发现。
l 有多种数据类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。（例如int I = 1;short s = 2;byte b = 3;然后i + s + b;//问题，他们相加最后得到的数字6是一个什么声明类型呢？在计算过程中i、s、b这三个变量会做数据类型的转化吗？答案是会，转化为最大的int：int x = i + s +b；）在计算过程中，整数类型是int的范围最大，所以s和b都分别先转换成int类型然后进行加的运算，最终的结果是int类型的数据。（char是字符为什么也能参加运算呢？比如char c = ‘a’;byte b0 = 2;int k = c + bo;输出结果是99，这明明是个字符，为什么可以和数字相加？原因是ASCII码：“上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。”实际上我们char定义的英文字符都是有一个数字的，所以我们用char类型的数据在与数字进行数学运算的时候，它是转化为相对应的ASCII码的值然后再进行的计算）
l Byte,short,char之间不会相互转换，它们三者在计算时首先转换为int类型。
l 当把任何基本数据的值和字符串值进行连接运算时(+)，基本类型的值将自动转换为字符串类型。（例如我们先建立一个String str = “abc”；int i = 1;然后System.out.println(str + i);输出它，结果为abc1，实际上把1也定义为字符了，他们不会相加，不论加多少个都是一样的。）
注意：当这个有一系列的+的运算的时候，如果某个部分其中含有字符串，那么这个字符串前面挨着的+开始一直往后都是要按照字符串拼接计算去看
public class Dome04 {
public static void main(String[] args){
int i = 128;
byte b = (byte)i;//内存溢出
//我们再转化的途中尽量要避免这种内存溢出的情况，因为内存溢出，你也不知道变成什么，以及超过它大小了
System.out.println(i);
System.out.println(b);
//强制转换 (类型)变量名 高-->低
//byte b = (byte)i;这种加()里面输入类型的称为强制转化
?
//自动转换 低-->高
int i1 = 128;
double b1 = i1;
//我们由低转到高的时候不用加任何东西它也不会报错
System.out.println(i1);
System.out.println(b1);
?
?
/*注意点
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转化到低容量的时候，需要强制转化，反之完全不用动
4.转换的时候可能存在内存溢出或者精度问题!
*/
?
System.out.println("==========================================");
System.out.println((int)23.7); //23
System.out.println((int)-45.89f); //-45
?
?
System.out.println("==========================================");
char c = ‘a‘;
int d = c + 1;
System.out.println(d);
System.out.println((char)d);
?
}
}
public class Dome05 {
public static void main(String[] args){
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money * years;//-1474836480，计算的时候溢出了
long total2 = money * years;//-1474836480，默认是int，计算完之后才把money * years转换成long类型，转换之前已经存在问题了
System.out.println(total);
System.out.println(total2);
?
long total3 = money * ((long)years);//20000000000,先把一个数转换为long
System.out.println(total3);
}
}
数字类型的运算规则：
1、 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后在进行计算。数字类型的从小到大分别是byte、short、int、long、float、double。
2、 数据类型的运算中，多个相同类型变量参与的运算，变量要先转换成相对应的数据类型的默认类型（比如连个byte类型的变量相加，会先把两个byte类型的变量转换成默认的int类型之后再计算，得到的结果是int类型）。这种情况适用于变量的数据类型的容量比默认类型的容量小，（比如byte，short，都比int小）
3、 byte，short，char之间不会相互转换，它们三者在计算时首先转换为int类型。
变量是什么：就是可以变化的量！
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
type varName [=value] [{,varName[=value]}];
//数据类型 变量名=值；可以使用逗号隔开来声明多个同类型变量。（不建议在一行里面定义多个值，这样看起来很麻烦）
public class Demo06 {
public static void main(String[] args){
//int a,b,c;
//int a = 1, b = 2, c = 3;//这样写不好
//尽量写成以下这样,有利于程序可读性
int a = 1;
int b = 2;
int c = 3;
?
String name = "LengGuang";
char x = ‘x‘;
double pi = 3.14;
}
}
注意事项
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量名是一条完整的语句，因此每一个声明都必须以分号结束。
类变量
实例变量
局部变量
public class Variable{
static int allClicks = 0; //类实例
String str = "hello world"; //实例变量
public void method(){
int i = 0; //局部变量
}
}
public class Demo07 {
?
//类变量 static
static double salary = 2000;
?
?
//属性：变量
?
//实例变量：从属于对象（也可以说它从属于这个类(Demo07)）；在实例变量中，如果不自行初始化，将使用这个类型的默认值
//所有数值类型初始化都是0或者0.0
//布尔值：默认是false
//除了基本类型，其余的默认值都是null
String name;
int age;
?
//main方法
public static void main(String[] agrs){
?
//局部变量：必须声明和初始化值(只在自己在的方法内可以用)
int i = 10;
System.out.println(i);
?
//变量类型 变量名字 = new Demo07();
Demo07 demo07 = new Demo07();
System.out.println(demo07.age);
System.out.println(demo07.name);
?
//类变量 static
System.out.println(salary);
?
}
?
//其他方法
public void add(){
?
}
}
变量的概念：
>内存中的一个存储区域
>该区域有自己的名称（变量名）和类型（数据结构）
>Java中每个变量必须先声明，后使用
>该区域的数据可以在同一类型范围内不断变化
使用变量注意：
>变量的作用域：一对{}之间有效
>初始化值
定义变量的格式：数据类型 变量名 = 初始化值（第一次给变量赋值就是初始化值）
Java中变量的定义：数据类型 变量名 = 变量的值，例如：int i = 1
变量是通过使用变量名来访问这块区域的
注意：声明变量过程中的这个=，不是数学意义上的=，在Java编程中代表赋值（赋予变量值）
常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名 = 值;
final double PI = 3.14;
常量名一般使用大写字符
public class Demo08 {
?
//修饰符，不存在区分先后顺序
//static final double PI = 3.14;
final static double PI = 3.14;
?
public static void main(String[] args) {
System.out.println(PI);
}
}
所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写，例如lastname-->lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大小写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()
Java中的名称命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
变量的类型：声明的变量的数据类型就是变量的类型
算数运算符：+，-，*，/，%，++，--
赋值运算符：=
关系运算符：>，<，>=，<=，==，!= instanceof
逻辑运算符：&&（与）我和你的意思，两个都存在，||（或）我或者你，其中一个，!（非）非你即我，非黑即白不是黑就是白
位运算符：&，|，^，~，>>，<<，>>>（了解！！！）
条件运算符：?:
扩展赋值运算符：+=，-=，*=，/=
package operator;
?
public class Demo01 {
public static void main(String args[]){
//二元运算符
//Ctel + D ：复制当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 25;
?
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / (double)b);
}
}
package operator;
?
public class Demo02 {
public static void main(String[] args) {
long a = 123123123123123L;
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);//short自动升型默认结果为运算中的最高类型
//Java程序不知道具体的这个变量在做完运算后会不会超出当前这个变量的范围，所以会先把变量转换为一个更大长度
}
}
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
l 算术运算符
l 赋值运算符
l 比较运算符（关系运算符）
l 逻辑运算符
l 位运算符
l 三元运算符
1、 算术运算符
运算符 运算 范例 结果 + 正号 +3 3 - 负号 b=4;-b -4 + 加 5+5 10 - 减 6-4 2 * 乘 3*4 12 / 除（当整数除以整数的时候，会把结果的小数部分舍弃，只保留整数部分） 5/5 1 % 取模（取余） 7%5 2 ++ ++ 自增（前）：先运算后取值 自增（后）：先取值后运算 a=2;b=++a; a=2;b=a++; a=3;b=3 a=3;b=2 -- -- 自减（前）：先运算后取值 自减（后）：先取值后运算 a=2;b=--a a=2;b=a-- a=1;b=1 a=1;b=2 + 字符串连接（字符串的加号是字符串的拼接） “He”+“llo” “Hello” ++和—分别是加1和减1的运算，++或者—符号在变量之前，先对变量进行 运算然后再取变量的值；如果这个++或者—符号在变量之后，就先取变量的值，再对变量进行运算。
算术运算符的注意问题：
l如果对负数取模（取余），可以把模数负号忽略不记，如：5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
l 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x=3510;x=x/1000*1000;x的结果是？
l “+”除字符串相加功能外，还能把非字符串转换成字符串。例如：System.out.println(“5+5=”+5+5);//打印结果是？ 5+5=55
l 以下二者的区别：
? System.out.println(‘‘+‘\t‘+‘‘);char类型数据是可以做数学运算的，在做数学运算的时候把字符转化为ACSII码进行计算。
? System.out.println(""+‘\t‘+‘‘);字符串与其它数据类型相加时，实际上是把其他的数据转换为字符串，然后做字符串的拼接。
2、 赋值运算符：
l 符号：=
? 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。（例如：int i=1;shrot s=2;i=s;//自动类型转换 s=(short)i;强制类型转换）
? 可以连续赋值，什么叫做连续赋值呢？比如int i0 = 0;int i1 = 0; int i2 = 0;然后我想给他们赋值为1，就连续赋值 i0 = i1 = i2 = 1;这样就可以连续赋值
l 扩展赋值运算符：+=，-=，/=，%=（比如int i = 1;i = i + 2;输出结果为3，那我们可以更简单一点，用扩展赋值，int i = 1;i += 2;输出结果也为3，加等于就是给i重新赋值，赋值成它原来的值加上它后面的值。说简单点就是i+2=的结果，省略简写了。 字符串怎么+=？String str = “he”;str +=“llo”；输出结果为hello，字符串的+=就是字符串的拼接，仅仅也只能用+=的操作）
l 思考一：(1)和(2)有什么区别？
short s =2；
s=s+3;(1) 变量参与运算时候，Java程序不知道具体的这个变量在做完运算后会不会超出当前这个变量的范围，所以会先把变量转换为一个更大长度，在这个例子中，short是一个短整型数据，会转化为默认的int。此处运算不能将int转换为short，只能强制转换，语句为s=(short)(s+3)。
s+=3;(2) 在使用扩展赋值运算符时，变量在参与运算时会把结果自动强制转换为当前变量的类型
3、 比较运算符
运算符 运算 范例 结果 == 相等于 4==3 false != 不等于 4!=3 true < 小于 4<3 false > 大于 4>3 true <= 小于等于 4<=3 false >= 大于等于 4>=3 true ? 比较运算符的结果都是boolean 型的,也就是要么是ture（是），要么是false（否）。
? 比较运算符“==”不能误写成“=”。
4、 逻辑运算符：
& —逻辑与（并且的关系） | —逻辑或（有一个条件成立就成立，就是或者） ! —逻辑非（取反逻辑，条件成立就取反成不成立）
&& —短路与(两个条件成立它才成立) || —短路或（a和b只要有一个条件成立他就成立） ^ —逻辑异或（a和b一个成立，一个不成立它才成立）
a b a & b a | b !a a^b a&&b a | | b true(成立) true true true false(不成立) false true true true false false true false true false true false true false true true true false true false false false false true false false false 并且（比如说：如果今天晴天并且没有事，就去游泳）、或者（明天或者后天，我都有时间去约会）、异或、非
l 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3&X<6。
l “&”和“&&”的区别：
l 单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。（int i=1;int k=1;System.out.println(i != 0 & ++k == 2);//单个的&时候，两边都要参与运算
System.out.println(i != 0 && ++k == 2);//2个&的时候，如果左边为ture，右边就参与运算；如果左边为flase，右边就不参与运算。）
l “|”和“||”的区别同理，|:左边无论真假，右边都进行运算；||表示：当左边为真，右边不参与运算。（在不需要逻辑运算两边都参与运算的时候，尽量使用&&或||）
l 异或（^）与或（|）的不同之处是：当左右都为true时，结果为false。
理解：异或，追求的是“异”！追求的是不同。
if(boolean值){代码}，当前其中的boolean值是true的时候会执行大括号里面的代码，flase时不执行大括号里面的代码。
5、 位运算符：
位运算符 运算符 运算 范例 << 左移 3<<2 = 12à322=12,m<<nàm*2n >> 右移 3>>1 = 1à3/2=1,m>>nàm*2-n >>> 无符号右移 3>>>1 = 1à3/2=1 & 与运算 6&3=2 | 或运算 6 | 3=7 ^ 异或运算 6^3=5 ~ 反码 ~6=-7 l 位运算是直接对二进制进行运算
二进制，逢2进1 0+1=1 1+1=10 10+1=11 11+1=110
十进制（1，2，3，…9，10，逢10进1），10进制的意思就是逢几进1，10进制的计算 1+8=9 9+1=10
进制计算机内部表示数的字节单位是定长的，如8位，16位，或32位。所以，位数不够时，高位补零。以15为例（负数以-15为例）15的二进制：00000000 00000000 00000000 00001111（因为int是32位数，所以补上了0）-15的二进制：11111111 11111111 11111111 11110001 计算过程：补码（负数的二进制）=反码+1 反码：11111111 11111111 11111111 11110000 补码（即加一）：11111111 11111111 11111111 11110001 也就是-15的二进制。（正数二进制à反码à加1（补码）à负数二进制） （负数二进制à减1à反码à原码à正数二进制）
有符号的右移>>：正数左右移补0，负数右移前面位是0就补是1就补1。（有符号的右移是看右移之后的首位是0还是1，是0前面空位补0，是1就补1）
>>>（无符号右移）：正数的>>>与>>是一致的，负数不一致。移动之后不管首位是0还是1，空位都是直接补0。
&(与)运算：同位&运算的时候，都是1结果为1，其他情况都为0.
|(或)运算：同位|运算时，都是0结果为0，其他情况都为1。
^(异或)运算：同位^运算时，都是0或者都是1的时候结果是0，其他的情况下都是1（相同值为0，其他情况为1）
~(反码)运算：就是把二进制的同位反转，也就是1变0，0变1。
位运算符的总结：
位运算符的总结 << 空位补0，被移除的高位丢弃，空缺位补0. >> 被移除的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。 >>> 被移除二进制最高位无论是0或者是1，空缺位都用0补。 & 二进制进行&运算，只有1&1时结果是1，否则是0； | 二进制进行|运算，只有0|0时结果是0，否则是1； ^ 相同二进制位进行^运算，结果是0；1^1=0,0^0=0 不相同二进制位^运算结果是1。1^0=1,0^1=1 ~ 正数取反，各二进制码按补码各位取反 负数取反，各二进制码按补码各位取反
原文：https://www.cnblogs.com/lengguang/p/13800203.html