java将运算符号替换成_java中的运算符与类型转换

类型转换:

从小到大的排序 自动类型转化(隐式转换)

小的数据类型与大的数据类型进行运算的时候,结果会自动转化大的类型

byte char short -->int -->long -->float -->double

注意事项:byte char short 相互之间不转换 他们参与运算首先转换为int类型

格式:范围大的数据类型 变量 = 范围小的数据类型值

强制类型转换(显示转换)

可以忍受精度缺失的情况下 可以把大类型的数据强制转化成小类型的数据

格式:范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型

运算符的概念:

对常量和变量进行操作的符号称为运算符

表达式的概念:

用运算符把常量连接起来符合java语法的式子就可以称为表达式

常用的运算符:算术运算符 赋值运算符 关系运算符 逻辑运算符 三元运算符

算数运算符: + - * / % ++ --

在java中两个int型数据进行除法运算得到的结果也是int 直接砍掉小数点

代码演示:

public static void main(String[] args) {

int a = 10;

int b = 20;

System.out.println(a + b); // 30

System.out.println(a - b); // -10

System.out.println(a * b);// 200

System.out.println(a / b);// 0

System.out.println(1/2.0);//0.5

System.out.println(1/3);//0

System.out.println(2/3);//0

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

// 当字符串与数字中间使用+的时候 表示链接 最终得到一个新的字符串

int d = 10;

System.out.println("嘿嘿"+10);//嘿嘿10

System.out.println("嘿嘿"+10+10);//嘿嘿1010

System.out.println("嘿嘿"+(10+10));//嘿嘿20

System.out.println(10+10+"嘿嘿");//20嘿嘿

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

System.out.println(10%3);// 求余 取余数 (取模)

System.out.println(7%2);// 1

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

// 'a' ---> 97 'b'---> 98

// 'A' ---> 65

// '0'---> 48

System.out.println('a' + 10);// 107

System.out.println('A' + 10);// 75

System.out.println('0' + 10);// 58

System.out.println((char)('a' + 1));//b

}

++运算符:

当++ 运算符单独使用的时候 无论++符号在变量的左边还是右边 都表示对这个变量自增1

当++运算符配合使用的时候, 如果++符号在变量的左边, 强调的是先改变(自增1)再配合,

如果在变量的右边,强调先配合再改变(自增1)

-- 运算符:

当-- 单独使用的时候 无论--在变量的左边还是右边, 都表示对这个变量进行自减1

当-- 配合的使用的时候, 如果-- 在变量的左边, 强调的是先改变(自减1)再配合,

如果在变量的右边,强调先配合再改变(自减1)

代码演示:

publicstatic void main(String[] args) {

int b = 10;

System.out.println(b++);//10

System.out.println(b);// 11

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

int c = 20;

System.out.println(--c);// 19

System.out.println(c);// 19

int d = 30;

System.out.println(d--);//30

System.out.println(d);// 29

}

赋值运算符:

基本的赋值运算符:=

扩展的赋值运算符:+= -= *= /= %=

把左边和右边的结果赋值给左边

注意:左边不能是常量

隐含了一个强制类型转换

好处:更高效

代码演示:

public static void main(String[] args) {

int a = 10;

a+=2; // a = a + (2) --- > a = 10 + (2) ---> a = 12

System.out.println(a);// 12

int b = 20;

b-=2; // b = b - (2) --->　ｂ　＝　１８

System.out.println(b);//18

short c = 10;

//c = (short)(c + 10); // short = short + int ---> short = int

c+=10;

System.out.println(c);//20

}

关系运算符:

==(等于) !=(不等于) >(大于) =(大于等于) <=(小于等于)

关系运算符的都是boolean型 要么就是true 要么就是false

代码演示:

public static void main(String[] args) {

// TODO Auto-generated method stub

int a = 10;

int b = 20;

int c = 10;

System.out.println( a == b);// false

System.out.println( a == c);// true

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

System.out.println( a != b);// true

System.out.println( a != c);// false

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

System.out.println( a >= b);// false

System.out.println( a >= c);// true

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

System.out.println( a <= b);// true

System.out.println( a <= c);// true

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

System.out.println( a > b); // false

System.out.println( a > c);// false

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

System.out.println( a < b);// true

System.out.println( a < c);// false

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

}

逻辑运算符:

逻辑运算符用于连接布尔表达式 最终的结果值为布尔型

在java中不可以写成33&&x<6

与: & 运算规则: 如果两边有一边为false那整个表达式的结果就为false , 只有两边同时为true 结果才为true

或: | 运算规则: 如果两边有一个为true那整个表达式的结果就为true , 只有两边同时为false ,结果才为false

非: ! 运算规则: 真变假 假变真

异或: ^ 运算规则: 两边相同为false,不同为true

代码演示:

public static void main(String[] args) {

System.out.println(true & true ); // T

System.out.println(false & true );// F

System.out.println(true & false );// F

System.out.println(false & false );// F

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

System.out.println(true | true ); // T

System.out.println(false | true );// T

System.out.println(true | false );// T

System.out.println(false | false );// F

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

System.out.println(!true);// F

System.out.println(!false);// T

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

System.out.println(true ^ true ); // F

System.out.println(false ^ true );// T

System.out.println(true ^ false );// T

System.out.println(false ^ false );// F

}

短路与: &&

短路或: ||

好处:效率更高

短路与: &&

基本的运算规则跟 & 相似 , 区别在于 , 如果左边为false,右边不执行,直接把结果false

短路或: ||

基本运算规则 跟 | 相似, 区别在于, 如果左边为true ,右边不执行, 直接把结果true返回

三元表达式:

表达式1 ? 结果1 : 结果2

执行流程:

先去计算表达式1的结果

如果结果为真 则返回结果1 , 否则 返回结果2

代码演示:(获取两个数中大数。)

(int x=3,y=4,z;z = (x>y)?x:y;//z变量存储的就是两个数的大数。)

public class Demo09Operator {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = (a > b) ? a : b;

System.out.println("c:" + c);

}

}

(比较两个数据是否相同)

public class Demo10Operator {

public static void main(String[] args) {

// 定义两个int类型的变量

int a = 10;

int b = 20;

boolean flag = (a == b) ? true : false;

// boolean flag = (a == b);

System.out.println(flag);

}

}

(获取三个整数中的最大值)

public class Demo11Operator {

public static void main(String[] args) {

// 定义三个int类型的变量

int a = 10;

int b = 30;

int c = 20;

// 先比较两个整数的大值

int temp = ((a > b) ? a : b);

int max = ((temp > c) ? temp : c);

System.out.println("max:" + max);

}

}