java变量运算

忘是亡心i 2022-11-07 05:50 150阅读 0赞

[java初体验][java]

### 文章目录 ###

*  java变量运算
 *   *   *  变量
         *   *   *  基本数据类型
                 *  自动类型提升
                 *  强制类型转换
                 *   *  引用数据类型
                 *  进制和进制转换

# java变量运算 #

### 变量 ###

*  变量的概念

> 内存中的一个存储的区域  
> 该区域的数据可以在同一类型的范围内不断的变化  
> 变量时程序中最基本的存储单元，包含变量的类型、变量的名称和存储的值

*  变量的作用：

> 用来在内存中保存数据

*  使用变量时应该注意什么

> java中每一个变量必须先进行声明，后使用  
> 使用变量名来访问这块区域的数据  
> 变量的作用域是其定义所在的一对\{\}中  
> 变量只有在其作用域内才算有效  
> 同一个作用域内，不可以定义重名的变量。

class VariableTest{ 
        public static void main(String[] args){ 
            //变量的定义
            int myage = 20;
            //变量的使用
            System.out.println(myage);
            int mynumber;
            //变量的声明
            mynumber = 1001;
            //变量的赋值
            System.out.println(mynumber);
            //变量必须先进行声明赋值后再进行使用
            //System.out.println(myclass);
    // java: 找不到符号
    // 符号: 变量 myclass
    // 位置: 类 variableTest
            //int myage = 22;不可以在同一个作用域内定义同名的变量。
    // java: 已在方法 main(java.lang.String[])中定义了变量 myage
        }
        public void method(){ 
            int myclass = 1;
            //变量是有作用域的，变量的使用要在一个作用域下进行
        }
    }

*  变量的分类–>按照数据类型分：  
    对于每一种数据都定义了明确的具体的数据类型，在内存中分配了不同大小的内存空间
    
    > 基本数据类型：整数类型 浮点类型 字符型 布尔型  
    > 引用数据类型：类 接口 数组 字符串  
    > ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70]

##### 基本数据类型 #####

*  整数类型：byte short int long

> java各整数类型有固定的表数范围和字段长度，不受具体的OS的影响，用来保证java程序的可移植性。  
> java的整型常量默认为int型，声明long型常量时后面要加上大写或者小写的L  
> java程序中的变量通常定义为int型，除非不足以表示较大的数据，才使用long

*  浮点类型  
    浮点类型和整数类型相似，java浮点类型有固定的表数范围和字段长度，不受具体操作系统的影响  
    浮点型常量有两种表示形式：

> 十进制数形式：5.12 512.0f  
> 科学计数法形式：5.12e2 512E2 100E-2

float：单精度，尾数可以精确到7位有效数字，通常情况下，float的精度很难满足需求  
double：双精度，精度时float的两倍，通常使用double  
java的浮点型常量默认时double类型，声明float型常量时，后面需要加大写或者小写的F

*  字符型char  
    char型数据用来表示通常意义上的字符  
    java中所有的字符都使用Unicode编码，所以一个字符可以存储一个字母，一个汉字或者时其他书面语的一个字符  
    字符型变量的三种表现形式：
    
    > 字符型常量是用(’’)包含起来的单个字符  
    > Java中允许使用转义字符’'来将其后的字符转变为特殊字符型常量  
    > 直接使用Unicode值来表示字符型常量  
    > char类型是可以进行运算的，因为它都有对应的Unicode编码
 *  常见的转义字符

> \\b退格符  
> \\n换行符  
> \\r回车符  
> \\t制表符  
> \\反斜线

class variableTest{ 
        public static void main(String[] args){ 
            //整型
            //整型：byte(1byte = 8 bit) short(2byte) int(4byte) long(8byte)
            //byte范围：-128~127
            byte b1 = 12;
            byte b2 = -128;
            //b2 = 128;//编译不通过，原因是因为超过了byte的数字范围
            System.out.println(b1);
            System.out.println(b2);
            //声明long型变量，必须以小写或者大写的L结尾
            short s1 = 128;
            int i1 = 1234;
            long l1 = 34567890L;
            System.out.println(l1);
            //通常定义整型变量的时候一般使用的都是int类型
            //浮点型float(4字节) double(8字节)
            //浮点型：表示带小数点的数值
            //float表示的数值的范围比long还要大
            double d1 = 123.3;
            System.out.println(d1 + 1);
            float f1 = 12.3f;//注意：定义float类型变量时，变量必须要用小写或者大写的f来结尾
            //java: 不兼容的类型: 从double转换到float可能会有损失
            System.out.println(f1);
            //通常定义浮点型变量的时候，使用的时double,原因是范围更大，精度更高
            //字符型：char(1字符=2字节)
            //定义char型变量，通常使用一对单引号
            char c1 = 'd';
            //c1 = 'Ab';//char类型只可以写一个字符
            //java: 未结束的字符文字
            System.out.println(c1);
            //表示方式：1.声明一个字符2.转义字符3.unicode进行表示
            char c5 = '\n';//换行符
            c5 = '\t';//制表符
            System.out.println("hello"+ " " + "world");
            System.out.println("hello" + c5);
            System.out.println("world");
            char c6 = '\u0043';
            System.out.println(c6);
            //布尔类型：true false
            //布尔类型的值通常用于条件判断、循环结构中使用
            boolean bb1 = true;
            System.out.println(bb1);
            boolean  ismarried = true;
            if(ismarried){ 
                System.out.println("你不可以参加单身party");
            }else{ 
                System.out.println("你可以多谈谈女朋友");
            }
        }
    }

基本数据类型之间的运算规则：  
前提：这里讨论的是7种的基本数据类型变量之间的运算，不包含boolean类型的

##### 自动类型提升 #####

byte、char、short --> int --> long --> float --> double  
当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量最大的数据类型  
(容量大小值的是数的范围的大小)  
特别的，当byte、char 、short这几个类型之间进行运算的时候，一定要用int来进行接收

package day03.dh;
    public class VariableTest2 { 
        public static void main(String[] args){ 
            byte b1 = 2;
            int i1 = 12;
            //byte b2 = b1 + i1;编译不通过
            int i2 = b1 + i1;
            System.out.println(i2);
            long l1 = b1 + i1;
            System.out.println(l1);
            float f = b1 + i1;
            System.out.println(f);
            short s1 = 123;
            double d1 = s1;
            System.out.println(d1);
            char c1 = 'a';
            int i3 = 10;
            int i4 = c1 + i3;
            System.out.println(i4);
            short s2 = 10;
    // char c2 = c1 + s2;
    // char c4 = c1 + b2;
        }
    }

##### 强制类型转换 #####

强制类型转换：自动类型提升的逆运算  
1.需要使用强转符()  
2.注意点：强制类型的转换，可能会导致精度损失

package day03.dh;
    public class VariableTest3 { 
        public static void main(String[] args) { 
            double d1 = 12.3;
            int i1 = (int) d1;//截断操作
            System.out.println(i1);
            //没有精度损失
            long l1 = 123;
            short s2 = (short) l1;
            //精度损失
            int i2 = 128;
            byte b = (byte) i2;
            System.out.println(b);
        }
    }

同时也具有一些特殊的情况：

###### 引用数据类型 ######

*  String  
    String不是基本的数据类型，它属于引用数据类型  
    使用的方式和基本数据类型是一致的。  
    String类型变量的引用：

> 格式是：String 变量名 = “变量值”;

一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据  
String可以和8种基本的数据类型变量做运算，且运算只能是连接运算，并且运算的结果只能是String类型，但是String类型这里不能转换为类似于int float double 类型，但是可以通过特殊的方法进行转换

package day03.dh;
    public class StringTest { 
        public static void main(String[] args){ 
            String s1 = "hello world";
            System.out.println(s1);
            String s2 = "a";
            String s3 = "";
    // char c = '';//必须要放置字符
            int number = 1001;
            String numberStr = "学号：";
            String info = numberStr + number;//+ 连接运算
            String info1 = info + true;
            System.out.println(info);
            System.out.println(info1);
            char c = 'a';//97 A:65
            int num = 10;
            String str = "hello";
            System.out.println(c + num + str);//107hello
            System.out.println(c + str + num);//ahello10
            System.out.println(c + (num + str));//a10hello
            System.out.println((c + num) + str);//107hello
            System.out.println((str + num + c));//hello10a
            String str1= 123 + "";
            System.out.println(str1);
            //int num1 = (int)str1;java: 不兼容的类型: java.lang.String无法转换为int
            int num1 = Integer.parseInt(str1);
            System.out.println(num1);
        }
    }

##### 进制和进制转换 #####

*  常用的进制  
    所有的数字在计算机的底层都是以二进制的形式存在的  
    那么对于整数来讲，常见的有这几种表示方式：

> 二进制(binary):0或者1，满2进1,统一使用0b或者是0B开头  
> 十进制(decimal):0-9,满10进1  
> 八进制(octal):0-7,满8进1，数字以0开头进行表示  
> 十六进制(hexadecimal):0-9和A-F，满16进1，以0x或者是0X开头，此处的A-F不区分大小写

package day03.dh;
    /* 计算机中不同进制的说明 */
    public class BinaryTest { 
        public static void main(String[] args){ 
            int num1 = 0b110;//二进制
            int num2 = 110;//十进制
            int num3 = 0127;//八进制
            int num4 = 0x110A;//十六进制
            System.out.println("num1 = " + num1);
            System.out.println("num2 = " + num2);
            System.out.println("num3 = " + num3);
            System.out.println("num4 = " + num4);
        }
    }

*  进制转换  
    以最常用的二进制和十进制之间互换为例(采用的是位权加减法)：  
    第一行是十进制，第二行是二进制

![在这里插入图片描述][20210105162900183.png]

也就是十进制转换为二进制：将数大的一方减去比它小的十进制，对应的二进制写1.

比方说13的二进制是：0000 1101，254的二进制是1111 1110

十进制转换为二进制称为编码，二进制转换为十进制称为解码。

我们输入的数据转换为二进制之后由计算机接收，计算机会将二进制进行解码，每8位二进制数据分析一次转换为十进制  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 1]  
在计算机底层都是以补码的方式来存储数据。  
[java运算符][java 1]

[java]: https://blog.csdn.net/qq_45671732/article/details/111389273
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70]: /images/20221023/d0a967c460eb48fbb1897830f49fa563.png
[20210105162900183.png]: /images/20221023/7b5197c28b724a64a066e33876aa9d9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 1]: /images/20221023/56768034a8464bb7aeeb78de84f9e17d.png
[java 1]: https://blog.csdn.net/qq_45671732/article/details/114694582