java运算规则与运算符
1、基本类型的类型转换
float a=123.45;//错误,右边的double,左边是float类型,类型不一致
int b=1234L;//错误,右边是long类型,左边是int类型,类型不一致
long c=1234;//对,右边是int类型,左边是long类型,类型不一致
double d=123.45f;//对,右边是float类型,左边是double类型,类型不一致
//都是类型不一致,有的对,有的错
问题:为什么有的两边类型不一致是对的,而有的两边不一致是错的?
当变量类型和变量值的类型不匹配时，就需要进行类型转换操作，而这种转换分为两种：
1.1、小到大/隐式转换
从小类型到大类型可以自动完成转换，我们不需要动手操作。
byte a1=10;
int b1=a1;//a1是byte类型,b1是int类型 ,小转大,自动转换了
int a2=10,b2=20;
long c2=a2+b2;//int类型转long类型,小转大,可以自动转换的
char a3='中';//a3其实就是一个整数
System.out.println(a3);
int b3=a3;//char类型转int类型,小转大,自动转换了
System.out.println(b3);//20013
double c3=a3;//char转double,小转大
System.out.println(c3);
1.2、大到小/显示转换/强制转换
需要强制类型转换
long x=1024L;
int y=(int)x;//long转int,是大转小,需要强制转换
System.out.println(y);//1024,输出的结果的没有任何问题
long i=1024L*1024*1024*4;
System.out.println(i);//4294967296
int j=(int)i;
System.out.println(j);//0,整数溢出了,i的数值超过了int所能表达的范围
double h=3.141592653589793;
System.out.println(h);//3.141592653589793,double类型的精度15位小数
float m=(float)h;
System.out.println(m);//3.1415927,float类型小数位只有7位,精度丢失
提示: 大类型转小类型可能会造成溢出和精度丢失问题!
2、运算规则
2.1、规则1:不同类型的数据进行运算，运算结果的类型会自动向较大类型转换
//规则1:不同类型的数据进行运算，运算结果的类型会自动向较大类型转换
int x=10;
long y=3L;
//long z=x+y;//13 int+long 结果会自动向较大的类型long转
int z=(int)(x+y);
System.out.println(z);
System.out.println(10+3.0);
System.out.println(10-3.0);
System.out.println(10*3.0);
System.out.println(10/3.0);
System.out.println(10/3);//int/int=int,虽然计算结果是小数,但是最终转换为int,所以直接去掉小数
2.2、规则2:byte,short,char三种比int小的整数，运算时会先自动转换成int
//规则2:byte,short,char三种比int小的整数，运算时会先自动转换成int
byte a1=3,a2=4;
//byte a3=a1+a2;//a1+a2运算结果最终结果是int,赋值个给byte,是大转小
byte a3=(byte)(a1+a2);
//byte a3=(byte)a1+(byte)a2;是错误的,一点效果都没有
byte b1=10;
short b2=20;
short b3=(short)(b1+b2);
char c1='中';//20013
char c2=(char)(c1+5);//20013+5=20018
System.out.println(c2);//串
2.3、规则3:整数运算溢出
整数运算，类似于一个钟表，转到最大时，再转会回到最小。
//规则3:整数运算溢出
byte d1 = Byte.MAX_VALUE;
System.out.println(d1);//127
byte d2=(byte)(d1+1);//实际计算127+1=128,但是byte没有128
System.out.println(d2);//-128,直接由最大值,变成最小值
int d3=Integer.MIN_VALUE;
System.out.println(d3);//-2147483648
int d4=d3-1;
System.out.println(d4);//2147483647
2.4、规则4：浮点数运算不精确
我们平常使用的编程语言大多都有一个问题——浮点型精度运算会不准确。比如
//浮点数运算
double num=0.1+0.1+0.1;
System.out.println(num);//0.30000000000000004
double num1=0.65-0.6;
System.out.println(num1);//0.050000000000000044
我们的计算机在存储小数时肯定是有长度限制的，所以会进行截取部分小数进行存储，从而导致计算机存储的数值只能是个大概的值，而不是精确的值
2.5、规则5：浮点数的特殊值
package cn.tedu.luoji;
//测试赴浮点数的特殊值
public class FuDianShu {
public static void main(String[] args) {
//1、正无穷大 Infinity
System.out.println(3.14/0);// Infinity
//2、负无穷大 -Infinity
System.out.println(-3.14/0);// -Infinity
//3、非数值 NaN
System.out.println(0.0/0);// NaN
System.out.println(0/0.0);// NaN
}
}
3、引用数据类型
3.1、引用数据类型简介
引用数据类型包括类、接口、数组类型
3.2、String类简介
String 类，通过String类可以定义一个字符串。所谓的字符串就是指一连串的字符，即字符串是由若干个字符连接而成的串。字符串中可以包含任意个字符，无论是0个、1个还是多个字符，这些字符必须包含在一对双引号（""）之内，例如：
package com.tedu.yusuan;
/**
* 字符串入门
* @author Administrator
*
*/
public class StringDemo {
/*
* String 首字母大写 java中的类
* 底层是char数组
* The value is used for character storage.
* private final char value[];
*
*/
public static void main(String[] args) {
//1.直接使用""括起来
String name = "xgg";
System.out.println(name);
//2.使用new
String name2 = new String( "java");
System.out.println(name2);
}
}
字符串可以直接使用：
String name = "java";
System.out.println(name);
也可以先声明再使用：
String name2 = new String( "java");
System.out.println(name2);
4、运算符
| 符号名称 | 表示符号 | 逻辑规则 |
|---|---|---|
| 算数运算符 | + - * / | 基本运算 |
| % | 模-取余数（5%2结果是1） | |
| ++ -- | 自增 自减 | |
| 比较运算符（结果是boolean） | == | 相等比较 1==2 得到false |
| != | 不等比较 1!=2 得到true | |
| 逻辑运算符（结果是boolean） | && & | 逻辑与(短路与)，两边同为真结果才为真 |
| || | | 逻辑或(短路或)，两边只要有一个真结果就是真 | |
| + | 字符串连接 | |
| ! | boolean | |
| 三元运算符 | ？ ： | 三项运算：1?2:3（1是真取2，1是假取3） |
| 赋值运算符 | = | 赋值运算 |
| += -= *= /= | 复合的赋值运算（a=a+2或者a+=2） |
4.1、算数运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法 - 相加运算符两侧的值 | 10 + 20 等于 30 |
| - | 减法 - 左操作数减去右操作数 | 10 – 20 等于 -10 |
| * | 乘法 - 相乘操作符两侧的值 | 10 * 20等于200 |
| / | 除法 - 左操作数除以右操作数 | 20 / 10等于2 |
| % | 取余 - 左操作数除以右操作数的余数 | 20%10等于0 |
//1.算数运算符 +加 减- *乘 /除 %求余数
System.out.println(100 + 20);//120
System.out.println(100 - 20);//80
//java中乘号是* X int X = 10; XX10
System.out.println(100 * 20);//2000
System.out.println(100 / 20);//5
System.out.println(100 / 3);//33
System.out.println(100 % 3);//1
%的用法:
奇偶数的判定
%2 0 偶数
%2 1 奇数
也可以用来判断是否能被n整除
%n==0
4.2、关系运算符
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 如果两个操作数的值是否相等，如果相等则条件为真 | （10 == 20）为假 |
| != | 如果两个操作数的值是否相等，如果值不相等则条件为真 | (10 != 20) 为真 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真 | （10> 20）为假 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真 | （10 <20）为真 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真 | （10> = 20）为假 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真 | （10 <= 20）为真 |
//2.关系运算符
int a = 10;
int b = 2;
// == 等号 在java中=不是等号
System.out.println(a * b == b * a);//乘法交换律 true
//!= 不等
System.out.println(a != b); //true
// > 大于
System.out.println(a > b); //true
// >= 大于等于
System.out.println(a >= b); //true
// < 小于
System.out.println(a < b); //false 10<2?
System.out.println(a <= b); //false 10<=2?
4.3、逻辑运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真 | （A && B）为假 |
| || | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真 | （A | | B）为真 |
| ! | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false | ！（A && B）为真 |
布尔表达式1 && 布尔表达式2 : 两边都是true，结果才是true，只要有一个是false，结果就是false
布尔表达式1 || 布尔表达式2 : 两边都是false，结果才是false，只要有一个是true，结果就是true
两者都有短路效果：
&&左边(表达式1)如果是false，右边不会执行
||左边(表达式1)如果是true，右边不会执行
&和|和&&和||都是一样的,只不过后者(双个)具有短路能力
通常，我们用0表示false，用1表示true
与：表示并且的关系
单与&：
1 & 2 ，结果想要是true，要求1和2都必须是true
双与/短路与&&：
1 && 2 ，当1是false时，2会被短路，提高程序的效率
或：表示或者的关系
单或|：
1 | 2，结果想要是true，要求1和2只要有一个为true就可以
双或/短路或||：
1 || 2，当1是true时，2会被短路，提高程序效率
//3.逻辑运算符 a=10 b=2
/**
* && 逻辑与 双真为真,有假必假
* 短路规则 若前面的表达式为假,后面的表达式没有判断真假的必要,结果必然为假
*/
System.out.println(a > b && b > 0 );//true 前真后真为真
System.out.println(a > b && b < 0);//false 前真后假为假
System.out.println(a < b && b > 0);//false 前假后真为假
System.out.println(a < b && b < 0);//false 前假后假为假
System.out.println("----||-----");
/**
* || 逻辑或 有真为真,双假必假
* 短路规则 若前面的表达式为真,后面的表达式没有判断真假的必要,结果必然为真
*/
System.out.println(a > b || b > 0 );//true 前真后真为真
System.out.println(a > b || b < 0);//true 前真后假为真
System.out.println(a < b || b > 0);//true 前假后真为真
System.out.println(a < b || b < 0);//false 前假后假为假
System.out.println("----!-----");
/**
* ! 逻辑非(取反) 真假相反
*/
System.out.println(a > b); //true
System.out.println(!(a > b)); //false
短路的意思就是惰性运算，当符号左边的式子已经可以确认最后结果时，符号右边的式子就不进行计算了。
短路与是Java语言中的一个逻辑运算符，记作&&，与编程语言中的与（&）相似，但是具有短路性质：在使用&进行运算时，不论左边为true或者false，右边的表达式都会进行运算，而如果使用&&进行运算，当左边为false时，右边的表达式不会进行运算，因此&&被称为短路与。
短路或是Java语言中的一个逻辑运算符，记作||，与编程语言中的或（|）相似，但是具有短路性质：在使用|进行运算时，不论左边为true或者false，右边的表达式都会进行运算，而如果使用||进行运算，当左边为true时，右边的表达式不会进行运算，因此||被称为短路或。
package cn.tedu.luoji;
//测试短路与、短路或
public class DuanLuYu {
public static void main(String[] args) {
// 1、验证短路与
Boolean res1 = A() && B();// A方法是true的时候，要执行B方法
Boolean res2 = C() && D();// C方法是false的时候，不执行D方法
System.out.println("---------------------------------------------");
// 2、验证与
Boolean res3 = A() & B();// A方法是true的时候，要执行B方法
Boolean res4 = C() & D();// C方法是false的时候，要执行D方法
System.out.println("---------------------------------------------");
// 3、验证短路或
Boolean res5 = A() || B();// A方法是true的时候，不执行B方法
Boolean res6 = C() || D();// C方法是false的时候，要执行D方法
System.out.println("---------------------------------------------");
// 4、验证或
Boolean res7 = A() | B();// A方法是true的时候，要执行B方法
Boolean res8 = C() | D();// C方法是false的时候，要执行D方法
}
public static Boolean A() {
System.out.println("我是A方法------");
Boolean tBoolean = true;
return tBoolean;
}
public static Boolean B() {
System.out.println("我是B方法------");
Boolean fBoolean = false;
return fBoolean;
}
public static Boolean C() {
System.out.println("我是C方法------");
Boolean tBoolean = false;
return tBoolean;
}
public static Boolean D() {
System.out.println("我是D方法------");
Boolean fBoolean = true;
return fBoolean;
}
}
4.3.1、平年闰年的判断
package cn.tedu.yunsuanfu;
import java.util.Scanner;
/*
* 判断是否为闰年
* 要满足为闰年的条件
* 1、能被4整除，并且不能被100整除
* 2、能被400整除
*/
public class RunNian {
public static void main(String[] args) {
// 方式一、普通写法（使用逻辑与&进行判断）
// 1、输入年份，判断是否为闰年
System.out.println("请输入年份？");
int year = new Scanner(System.in).nextInt();
// 2、设置默认值：假设每年都是平年
String desc = "平年";// 修改默认值
// 3、判断，年号是否满足闰年的条件
if (year % 4 == 0 & year % 100 != 0) {
desc = "闰年";
System.out.println(year + "为" + desc + "!!!");
} else if (year % 400 == 0) {
desc = "闰年";
System.out.println(year + "为" + desc + "!!!");
} else {
System.out.println(year + "为" + desc + "!!!");
}
}
}
// 方式二、短路与、短路或写法（使用&&、||进行判断）
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
desc = "闰年";
System.out.println(year + "为" + desc + "!!!");
} else {
System.out.println(year + "为" + desc + "!!!");
}
4.4、自增自减运算符
| 操作符 | 描述 | <例子/th> |
|---|---|---|
| ++ | 自增: 操作数的值增加1 | 20++ 或 ++20 等于 21 |
| -- | 自减: 操作数的值减少1 | 20-- 或 --20 等于 19 |
++: 在当前值的基础上自增1（加1）
int i = 5;
i++: 先使用（访问）i的值，再给i加1
++i: 先给i加1，再使用（访问i）的值
--: 在当前值的基础上自减1（减1）
i--: 和i++相同
--i: 和++i相同
//4.1.自增 ++ 看++的位置,++在前先加再使用 ;++在后先使用再加
System.out.println("----++自增-----");
int i = 5;
// System.out.println(i++); //5 先使用当前值,用完加1
// System.out.println(i);// 6
System.out.println(++i); //6 先加1再使用
System.out.println(i);// 6
//自减 -- 看--的位置,--在前先减再使用 ;--在后先使用再减
i = 5;
System.out.println(i--);//5 先使用当前值,用完减1
System.out.println(i);// 4 此时i=4
i = 5;
System.out.println(--i);//4 先减1再使用
System.out.println(i);// 4 此时i=4
4.5、三目运算符
格式：布尔表达式 ? 表达式1 : 表达式2
如果表达式结果是true，则返回值1，否则返回值2
package com.tedu.yusuan;
/**
* 三目运算符(三元运算符)
* @author Administrator
*
*/
public class TestDemo2 {
public static void main(String[] args) {
//快速删除整行 ctrl+d
int x = 7;
int y = 9;
/**
* 先判断表达式的结果 若为真结果为表达式1的值;否则结果为表达式2的值
*/
int z = x > y ? x : y;
System.out.println(z);
x = 10;
y = 2;
z = x > y ? x : y;
System.out.println(z);
}
}
4.5.1、两个数的最大值
package cn.tedu.yunsuanfu;
import java.util.Scanner;
//测试三元运算符
public class SanYuanYunSuan {
public static void main(String[] args) {
// 从键盘接收2个整数，获取最大值
System.out.println("请输入数字1：");
int a = new Scanner(System.in).nextInt();// a=5
System.out.println("请输入数字2：");
int b = new Scanner(System.in).nextInt();// b=3
// 使用三元运算来判断2个数字中的最大值
// 如果a>b为true就返回a，如果a>b为false就返回b
int c = a > b ? a : b;
System.out.println("大的数字是：" + c);// 大的数字是：5
}
}
怎么比较三个数中的最大值呢？
// 先判断2个数中的最大值，在拿最大值去与第3个数进行比较
int d = a > b ? a : b;// d是a和b之间的最大值
int e = d > c ? d : c;
System.out.println("大的数字是：" + e);
4.6、复合赋值运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| += | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| -= | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| *= | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| /= | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C/=A,C与A同类型时等价于C=C/A |
package com.tedu.yusuan;
/**
* 复合赋值运算符
* @author Administrator
*
*/
public class YSFDemo {
public static void main(String[] args) {
int a1 = 12;
/*
* a1 += 5
* a1 = a1 + 5
* 写1行注释1行是为使用a1初值12
*/
// System.out.println(a1 += 5);//17
// System.out.println(a1 -= 5);//7
// System.out.println(a1 *= 5);//60
// System.out.println(a1 /= 5);//2
System.out.println(a1 %= 5);//2
}
}
4.7、加号（+）的使用
加号可以做加法运算(要求两边都得是数值)，也可以做为拼接符使用（只要两边有一个是字符串）
package com.tedu.yusuan;
/**
* + 数值计算中是加号 字符串中是拼接操作
* @author Administrator
*/
public class YSFDemo2 {
public static void main(String[] args) {
int a = 1 + 3; // + 加号 相加操作
System.out.println(a);
System.out.println(a + "abcd");//拼接操作
}
}
150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
