JavaSe之变量和运算

xiao-骁

已于 2023-02-11 01:17:07 修改

阅读量121

点赞数

分类专栏： Javase 文章标签： java

于 2022-12-15 10:28:32 首次发布

本文链接：https://blog.csdn.net/qq_54227829/article/details/128325809

版权

Javase 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

数据类型以及取值范围

数据类型	占用内存	取值范围
byte	1个字节	-2^7 ~ 2^7-1
short	2个字节	-2^15 ~ 2^15-1
int	4个字节	-2^31 ~ 2^31-1
long	8个字节	-2^63 ~ 2^63-1
float	4个字节	（正数）1.4E-45 - 3.4028235E38 （整体） -3.4028235E38 ~ 3.4028235E38
double	8个字节	1.7976931348623157E308 ~ 4.9E-324
char	2个字节	65536（看字符编码）
boolean	1个字节	两个值 true和false

变量的命名规范

1.所有变量，方法，类名：见名知意；

2.类成员变量（除了常量以外的所有变量）：首字母小写和驼峰原则；eg：userName

3.局部变量：首字母小写和驼峰原则

4.常量：大写字母和下划线 eg：MAX_VALUE

5.类名：首字母大写和驼峰原则 eg：User Man

6.方法名：首字母小写和驼峰原则 eg：addUser() runRun()

7.包名：一般利用公司域名作为包名； eg：com.XXX.XXX

8.变量名字里不能有空格。

9.避免使用关键字，class public int static

10.避免使用汉字，不要使用英文和拼音混着写

11.$和_可以到处使用，但是不建议当做开头

12.数字不能开头

算数运算符

加：+ 减：- 乘：* 除：% 余数：/

    int a=10;
	int b=3;
	System.out.println(a+b);	
	System.out.println(a-b);	
	System.out.println(a*b);	
	System.out.println(a/b);	
	System.out.println(a%b);//取模true
    
	
	
    int k = 10;
	k++;
	
	System.out.println(k);
	
	int y = 10;
	++y;
	System.out.println(k);
	//小结：
	//++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后
	//只要++运算结束，该变量中的值一定会自加1.
	
	//++ 出现在变量后
	//规则：先做赋值运算，在对变量中保存的值进行自加1.
	System.out.println("---------------------------------------------");
	int m =100;
	int n=m ++;
	System.out.println(m);//101
	System.out.println(n);//100
	
	//++ 出现在变量前
	//规则： 先进行自加1运算，然后再进行赋值操作
	int s = 20;
	int t = ++ s;
	System.out.println(s);//21
	System.out.println(t);//21
	
	int xx =500;
	System.out.println(xx);//500
	
	int d = 20;
	int c = ++ d;
	System.out.println(d);//21
	System.out.println(c);//21
	
	int vv =500;
	System.out.println(vv);
	
	int e = 100;
	System.out.println(e++);//100
	System.out.println(e);//101
	
	int h = 100;
	System.out.println(++h);//101
	System.out.println(h);//101
	
	int g = 100;
	System.out.println(++g);//101
	System.out.println(g);//101
	
	System.out.println("-------------------------------------");
	System.out.println(--g);//100【101先运算等于100在赋值，等于100，此时g等于100】
	System.out.println(g++);//100【100的g先赋值等于100，然后自增运算，此时g=101】
	System.out.println(g--);//101【101的g先赋值，再做自减运算，此时g=100】
	System.out.println(g--);//100【100的g先赋值，再做自减运算，此时g=99】
	System.out.println(g--);//99【99的g先赋值，再做自减运算，此时g=98】
	System.out.println(g);//98【98的个不做任何运算，直接赋值，结果为g=98】

逻辑运算符

逻辑运算符	功能
\|\|（短路或）	都为false，则false。有一个为true便不再继续判断了
\|（逻辑或）	都为false，则false。所有的条件都判断
&&（短路与）	都为true，则true。有一个为false便不再继续判断了
&（逻辑与）	都为true，则true。所有的条件都判断
！(非)	变成相反的样子
^（异或）	相同则为false，不相同则为true

System.out.println(5 > 3 & 5 > 4);     //  true
        System.out.println(5 > 100 | 5 > 4);   //  true
        System.out.println(!(5 > 3));          //  false
        System.out.println(!(5 < 3));          //  true
        System.out.println(true & true);       //  true
        System.out.println(true & false);      //  false
        System.out.println(true | false);      //  true
        System.out.println(!false);            //  true
        System.out.println(!true);             //  false
        System.out.println(true ^ false);      //  true
        System.out.println(true ^ true);       //  false
        System.out.println(false ^ false);     //  false
        // 重点研究逻辑与（&）和短路与（&&）的区别
        int x = 100;
        int y = 98;
        int z = 99;
        System.out.println(x > y & x > z); //true
        System.out.println(x > y && x > z); //true
        /*
          通过测试得出，逻辑与（&）和短路与（&&）最终运行
          结果相同那么它们有什么区别呢？请看以下代码。
        */
        int m = 99;
        int n = 100;
        System.out.println(m > n & m > n++); //false
        /*
          逻辑与（&）运算符只有当两边的操作数都是 true 的时候，
          结果才是 true，只要有一个是 false，结果必然是 false。
          以上程序逻辑左边的表达式(m > n)显然结果是 false，
          通过左边的表达式已经可以得出结果是false 了，右边的
          表达式没有执行的必要，那我们来看一下右边的表达式
          有没有执行，只要输出 n 就可以了断定。
        */
        System.out.println("n = " + n); //101
        /*
          以上程序的运行结果是 101，足以说明 n++已经执行了。
          也说明了逻辑与运算符无论左边表达式结果是true 还
          是 false，右边表达式一定会执行。
        */
        //那我们来看一下短路与（&&）是怎样的？
        int k = 99;
        int f = 100;
        System.out.println(k > f && k > f++); //false
        System.out.println("f = " + f); //100
        /*
          通过以上测试得出 f++并没有执行，因为左边表达式(k > f)
          为 false，右边的表达式就不再执行了，这种现象被称为短路
          现象。也就是说对于短路与来说，左边的表达式只要为 false，
          就会发生短路，右边表达式不再执行了。
        */

赋值运算符

赋值运算符主要是这几种：=、+=、-=、*=、/=、%=，

public class AssignmentOperatorTest01 {
    public static void main(String[] args) {
        //基本的赋值运算符
        int i;
        i = 10;
        System.out.println("i = " + i);
        i = 100;
        System.out.println("i = " + i);
        //扩展的赋值运算符
        int x = 10;
        x += 1; //等同于 x = x + 1
        System.out.println("x = " + x); //11
        int y = 10;
        y -= 1; //等同于 y = y - 1
        System.out.println("y = " + y); //9
        int z = 10;
        z *= 2; //等同于 z = z * 2
        System.out.println("z = " + z); //20
        int m = 10;
        m /= 3; //等同于 m = m / 3
        System.out.println("m = " + m); //3
        int n = 10;
        n %= 3; //等同于 n = n % 3
        System.out.println("n = " + n); //1
    }
}

三元运算符

语法：条件表达式？表达式1：表达式2；

运算规则：

1、如果条件表达式为true，运算后的结果是表达式1；

2、如果条件表达式为false，运算后的结果是表达式2；

        int a = 99;
        int b = 10;
        int result = a > b ? a++ : b--;  //表达式1  先赋值后自增
        System.out.println(result);//输出99
        System.out.println("a = " + a);//输出 100
        System.out.println("b = " + b);//输出10

位移运算符

Java中有三种移位运算符，分别是左移运算符（<<），有符号右移（>>），无符号右移（>>>），作用分别如下：

左移运算符（<<）：将数值的所有二进制位左移给定的位数，高位即左边的二进制位溢出则丢弃，低位空出来的部分补0

有符号右移（>>）：将数值的所有二进制位右移给定的位数，高位空出来的补符号位，即负数补1，正数补0,；低位溢出的部分直接丢弃

无符号右移（>>>）：将数值的所有二进制位右移给定的位数，高位空出来的补0，不论正数还是负数；低位溢出的部分直接丢弃

需要注意的是，移位的所有操作都是对数值的补码进行操作的！！！

我们知道数值有原码、反码、补码三种表示形式，在计算机里的整数值都是以补码的形式存储的。对于正数来说，原码=反码=补码；对于负数来说，反码等于原码除符号位之外各位取反，补码等于反码末位加一。

也就是说我们只需要关心负数的补码即可，并且负数原码反码补码中转换的规则是通用的，即原码=补码除符号位之外各位取反末位加一，而补码=原码除符号位之外各位取反末位加1。当然你也可以先减1然后除符号位之外各位取反。

补码：1000 0000 …这样的数很特殊，它是没有原码的。当数值为16位时，10000000 00000000的真值为-32768，32位时10000000 00000000 00000000 00000000的真值为-2147483648。

数据类型装换

在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为(byte，short，char)–int–long–float–double

简单数据类型之间的转换又可以分为：

●低级到高级的自动类型转换

●高级到低级的强制类型转换

●包装类过渡类型能够转换

自动数据类型转换

  public static void main(String[] args) {
	// 把int类型的值赋值给double数据类型（符合低字节向高字节转换）
	double num = 32;  
	// 把整数常量赋值给byte、 short和char类型变量（不符合低字节向高字节转换）
	byte b = 123;
	short s = 123;
	byte by = 1234; // 错误，整数常量不能操出其类型的表数范围
}

强制类型转换

强制类型转换(显示类型转换)，主要用于显式的转换一个数值的类型。在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。语法格式：目标类型变量 =（目标类型）源类型变量或常量

public static void main(String[] args) {
	float a = 123.23f;
	byte b = (byte)a;   // 注意：强转之后有可能会丢失精度
	System.out.println(b); // 输出：123
	// 注意：原类型数据被强转后数据是不会变化。
	System.out.println(a); // 输出：123.23   
}

使用强制类型转换的时候，一定要明确需要强转的数据。

当多个类型数字相计算时，结果将自动转换为最高精度有特殊情况:

short + short = int

byte + short = int

byte + byte = int