变量的分类与声明

最新推荐文章于 2023-01-14 18:48:18 发布

Miracle Bear

最新推荐文章于 2023-01-14 18:48:18 发布

阅读量422

点赞数

分类专栏： java学习文章标签： java 数据结构 c++

本文链接：https://blog.csdn.net/weixin_48100716/article/details/125944776

版权

java学习专栏收录该内容

45 篇文章 1 订阅

订阅专栏

1.变量：

声明：相当于在银行开了个账户

声明的语法固定

int a；//声明了一个整型变量，名为a。

int a,c,d; //声明了多个整型变量，当变量类型相同则可以装到一起。

初始化：往账户中存钱

Java中“=”读作赋值，第一次赋值称为初始化

int a = 67；//声明一个整型变量a并赋值为67--------开户的同时存了67

int b;//声明一个整型变量b

b = 87;//给变量b赋值为87-----------先开户再存87

b = 68;//修改变量b的值为68

使用：使用的是账户里的钱

对变量的使用就是对它所存的数的使用

int a = 5;

int b = a+10; //取出a的值，加10后，再赋值给整型变量b

System.out.println(b); //输出变量b的值，不加双引号则默认为变量

System.out.println(“b”); //输出b，双引号中的原样输出

a = a+10;//在a本身基础上加了个10

变量在使用之前必须声明并初始化

System.out.println(i); //编译错误，i未声明

int i;

System.out.println(i); //编译错误，i未初始化

int i = 78;

System.out.println(i);

命名：

标识符：自己起的名字，用于和其他名字做区分

（1）.命名时只能包含字母、数字、_和$符，不能以数字开头

（2）.严格区分大小写

（3）.不能使用关键字，例如public等具有特殊意义的单词

（4）.简单建议（非规定）：Java规则允许中文命名但是不建议，建议使用该变量代表含义的英文命名，不允许拼音，因为不直观也不专业。

（5）.建议使用小驼峰命名法

标识符命名法：

小驼峰命名法：第一个单词首字母小写，其他单词首字母大写

score,myScore,myJavaScore----------变量名称

大驼峰命名法/帕斯卡命名法：所有单词首字母大写

Score,MyScore,MyJavaScore----------类名

2.数据类型的分类：基本数据类型（八种），引用数据类型。

数据占据空间是由其数据类型控制，不是由其数据大小控制。

八种基本数据类型：byte(文件流)、short（和其他语言兼容）、int、long、float（和其他语言兼容）、double、boolean、char；

int：整型，占用四个字节空间，-21亿到+21亿数字范围内。

（1）直接量：（直接写出的数1,2,673,24667,....）

整数直接量：直接写出来的整数，默认int型，但不能超出范围，但是超出范围会发生编译错误

小数直接量：直接写出来的小数，

（2）两个整数相除，结果还是整数，小数位无条件舍弃（不会四舍五入）

（3）运算时若超出范围，会发生溢出，溢出是需要避免的

直接量超范围编译错误，运算超范围发生溢出但不报错

    int a = 55; //25为整数直接量，默认为int类型
    int b = 2888888888888; //编译错误，该数默认为int类型但是超出范围内
    int c = 234.2; //编译错误，数据类型不匹配
    System.out.println(5/2); //输出2,两个整数相除，结果还是整数，小数位无条件舍弃（不会四舍五入）
    System.out.println(5.0/2); //输出2.5，如果一定要输出小数则输入时要让小数参与。
    int c = 2147483647; //int的最大值
        c = c+1;
    System.out.println(c); //输出-2147483648（int最小值）
    /*
    运算时若超出范围，会发生溢出，溢出是需要避免的
    最大值2147483647
    +1----------输出-2147483648
    +2----------输出-2147483647
    */

long:长整型，8个字节，范围非常大

（1）长整型的直接量需要在数字后边加L或者l,不然就会默认int类型

（2）若运算时有可能溢出，则在第一个数字后加L

    long e = 125L; //25L为长整型直接量
    long f = 1000000000000; //编译错误，该数值默认为int型，但是超出Int范围
    long g = 100000000000L; //100亿L为长整型
    //20亿（int）
    long h = 1000000000*2*10L;
    System.out.println(h); //200亿
    //溢出了
    long i = 1000000000*3*10L;
    System.out.println(i); //不是三百亿，是把溢出之后的数*10

    //30亿（long）
    long j = 1000000000L*3*10;
    System.out.println(j); //300亿

double:浮点型（装小数的），8个字节，范围非常大

（1）浮点数直接量默认为double型，若想表示float则需在数字后加f或F

（2）double与float型数据运算时，有可能会发生舍入误差，精确场合不能使用

    double d = 3.6; //3.6为浮点型直接量，默认为double
    float k =3.5F; //3.5F为float型
    double l =3.0,m=2.9;
    System.out.println(l-m); //0.10000000000000009
                             // 与正确结果有或上或下或不变的微小的误差
                             //应该为0.1

boolean:布尔型，1个字节，存真与假，对与错

只能取值为true与false

    boolean n = true; //true为布尔型的直接量
    boolean o = false; //false为布尔型直接量
    boolean o1 = 2222; //编译错误，数据类型不匹配

char:字符型，2个字节

（1）采用Unicode（解释见补充）编码格式，一个字符对应一个码（0到65535之间），表现的形式是字符char，但本质上是码int

（2）字符型直接量必须放在单引号中，只能装一个。

（3）ASCLL码：美国标准编码，‘a’=“97”，‘b’=“98”，‘A’=“65”，‘0’=“48”

（0与‘0’代表的含义完全不一样）

（4）字符直接量必须放在单引号中，且只能装一个

（5）特殊符号需要通过\来转义

    char c1 = '女'; //字符女
    char c2 = 'f'; //字符f
    char c3 = '6'; //字符6
    char c4 = ' '; //空格符
    char c5 = 女; //编译错误，字符直接量必须放在单引号中
    char c6 = ''; //编译错误必须有字符
    char c7 = '女性'; //编译错误，单引号中只能有一个字节
    char c8 = 65; //此时计算机传出的值为A，不加引号的话数值必须在0-65535之间
    println（）时会依据c8的数据类型来输出数据
    System.out.println(c8); //输出结果A，c8为char类型，所以会以字符的格式输出
    char c9 = '\''; //\为转义符
    System.out.println(c9); //输出’

3.类型间的转换：

||数据类型从小到大依次为byte,short,int,long,float,double.(char一般意义上不参与转换，Boolean不是数字不能参与转换)

两种方式：

自动/隐式类型转换：小类型转换成大类型

强制类型转换：大类型转换成小类型

||语法：（要转换成的数据类型）变量，例如（int）b

||注意：强转有可能溢出或丢失精度

     //类型转换
    int a = 5;
    long b = a; //此处发生自动类型转换
    int c = b; //报错，大类型转为小类型必须强制类型转换
    int c = (int)b; //强制类型转换

    long d = 5; //此处发生自动转换
    double e = 5; //此处发生自动类型转换,转换成int

    long f = 10000000000L;
    int g = (int)f;
    System.out.println(g);//输出为1410065408,强转有可能发生溢出

    double h = 25.987;
    int i = (int)h;
    System.out.println(i); //输出为25，强转有可能会丢精度

    byte b1 = 5; //整数的直接量可以直接给byte赋值
    int a1 = 5;
    byte b2 = a1; //编码错误，因为a是一个变量，所以不能直接赋值，要强制转换

    byte b11 = 5;
    byte b22 = 6;
    byte b3 = b11+b22; //报错,byte，short，char型数据参与运算时，系统会将其统一转换为int再运算
    byte b4 = (byte)b11+(byte) b22; //报错，强转优先级高，应该将运算结果强转
    byte b5 = (byte)(b11+b22);

    System.out.println(2+2); //输出结果为4
    System.out.println('2'+'2'); //输出结果为100，因为char型参与运算时先转换成int再参与运算，此处为‘2’的码50加上‘2’的码50得到输出结果
    System.out.println('2'+2); //输出结果为52
    System.out.println('我'+'你'); //输出结果为45425
    System.out.println('2'); //输出结果为2，因为没参与运算，所以此处仍然会输出2，不过是字符类型的2
    int W = '我'; //此处发生自动类型转化

两点规则：

整数直接量可以直接给byte，short，char赋值，但是不能超范围

byte，short，char型数据参与运算时，系统会将其统一转换为int再运算

4.补充

Unicode:万国码、统一码、通用码，世界级通用的定长（固定16位）字符集，因为符号太多所以Unicode被划分为了很多个子集。Java中的char采用的是其中最通用的一个子集（中文、英文、符号、数字等），char中总共65536个