JAVA基础------变量的使用

变量：

• 声明：相当于开户
• 初始化：给账户存钱
• 使用：用的是账户里面的钱
  • ​​​​​对变量的使用就是对它所存的那个数的使用
  • 变量在用之前必须声明并初始化
• 命名：给账户起名
  • 只能包含字母、数字、_和$，并且不能以数字开头
  • 严格区分大小写
  • 不能使用关键字
  • 允许中文命名、但不建议、建议"英文起名见名知意"、"小驼峰命名法"

​​​​八种基本数据类型:

     byte、short、int、long、float、double、boolean、char

1.  int：整型，4字节，-21个多亿到21个多亿
   • 整数的直接量默认为int类型，但不能超出范围，若超出范围则会发生编译错误
   • 两个整数相除，结果还是整数，小数位无条件舍弃（不会四舍五入）
   • 运算时若超出范围则发生溢出，溢出不是错误，但需要避免
2. long：长整型，8个字节，-900万万亿多到900万万亿多
   1. 表示长整型直接量，需要在数字后加L或小写l建议大写
   2. 运算时若有可能溢出，建议在第1个数后加L
3. double：浮点型（双精度），8个字节，很大很大
   1. 小数直接量默认为double类型，若想表示floa(单精度)需在数字后加F或者f
   2. 不能表示精确数据，运算时有可能会发生舍入误差，精确场合不能使用
4. boolean：布尔型，1个字节
   1. 只能存储true或false
5. char：字符型，2个字节
   1. 采用Unicode编码格式，一个字符对应一个码，看到的是字符char，但本质上是码
   2. 字符型直接量必须放在单引号中，只能有一个
   3. 特殊符号需要通过 \ 来转义

类型间的转换：

• 数据类型由小到大依次为：byte<short/char<int<long<float<double
• 两种转换方式：
  • 自动/隐式类型转换：小类型到大类型
  • 强制类型转换：大类型到小类型
  • 强转语法：(需要转换称为的数据类型)变量
  • 注意：强转有可能会发生溢出或丢失精度
• 两点规则：
  • 整数直接量可以直接赋值给byte、short、char，但不能超出范围
  • byte、short、char型数据参与运算时，系统一律将其转换为int再运算

---

变量演示：

• 变量：存钱的
  • 声明：相当于开户

/*注意：变量名不能重名，严格区分大小写*/
int a;//声明了一个整型变量，名为a
int b,c,d;//声明三个整型变量，名为b，c，d

• 初始化：给账户存钱

int a = 66;//声明整型变量a并赋初始值为66---------相当于开户同时存钱
int b;    //声明整型变量b----------先开账户
b = 99;   //给变量b赋初始值为99----后存钱
b = 88;   //修改变量b的值为88
int c = 1 , d = 2 , e = 3; //声明四个整型变量c , d , e并分别赋值为1 2 3

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

/* 对变量的使用就是对它所存的那个数的使用 */
int k = 5;
int m = k+10;//取出k的值，加10后，再赋值给变量m
System.out.println("m="+m);//输出变量m的值：15
k = k+10;//在k本省基础之上增10
System.out.println("k="+k);输出k的值：15
//---------------------------------------------------------------------
int balance = 5000;//账户余额
balance = balance+1000;//存款1000
System.out.println("balance="+balance);//余额剩余：6000
balance = balance-2000;//取款2000
System.out.println("balance="+balance);//余额剩余：4000

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

System.out.println(n);//编译报错，变量n未声明
int n;
System.out.println(n);//编译报错，变量n未初始化

• 命名：给账户起名

/* 注意：
        只能包含字母、数字、_和$，并且不能以数字开头
        严格区分大小写
        不能使用关键字
        允许中文命名，但不建议，建议"英文的见名知意"、"小驼峰命名法"
                                                                */
int a1,a_5,_3c,$_7;
int a*b;//编译报错，不能包含*号等特殊符号
int 1a;//编译报错，不能以数字开头
int 年龄;//允许，但不建议
int nianling;//必须杜绝拼音起名
int age;//建议"英文的见名知意"
int score,myScore,myJavaScore;//推荐使用"小驼峰命名法"

---

八种基本类型：

        byte、short、int、long、float、double、boolean、char

• int：整型，4字节，-21个多亿到21个多亿
  • 整数直接量默认为int类型

int age = 22;//22为整数直接量，默认为int类型
int myScore = 10000000000;//编译错误，100亿默认为int类型，但超出了范围
int balance = 25.55;//编译错误，整型变量中只能装整数

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

System.out.println(5/2); //2
System.out.println(2/5); //0
System.out.println(7/5); //1

• 运算时若超出范围则发生溢出，溢出不是错误，但需要避免

int d = 2147483647;//int的最大值
d = d+1;
System.out.println(d);//-2147483648 发生溢出了

• long：长整型，8个字节-900万万亿多到900万万亿多
  • 表示长整型直接量，需要在数字后加L或l
  • 运算时多有可能溢出，建议在第1个数字后加L

long a = 25L;//25L为长整型直接量
long b = 10000000000;//编译报错，100亿默认为int类型，但超出int范围了
long c = 10000000000L;//100亿L为长整型直接量
long d = 365L*24*60*60*1000;//去年一年所经历的毫秒数
System.out.println(d);//31536000000

/*  运算时若有可能溢出，建议在第1个数字后加L  */
long e = 100000000*2*10L;
System.out.println(e); //--200亿

long f = 1000000000*3*10L;
System.out.println(f); //--不是300亿

long g = 1000000000L*3*10;
System.out.println(g); //--300亿

• double：浮点型（双精度），8个字节，很大很大
  • 小数直接量默认为double类型，若想表示float需要在数字后加F或f
  • 不能不能表示准确的数据，运算时有可能会发生舍入误差，精确场合不能使用

double a = 25.767; //25.767为小数直接量，默认为double类型
float b = 25.767F; //25.767F为float型直接量

/*  不能表示精确的数据，运算时有可能会发生舍入误差，精确场合不能使用  */
double c = 3.0 , d = 2.9;
System.out.println(c-d);//0.00000000000000009  发生舍入误差了

• char：字符型，2个字节
  • 采用Unicode编码格式，一个字符对应一个码，看到的是字符char，本质上是码
  • 字符型直接量必须放在一个单引号中，只能有一个
  • 特殊符号需要用 \ 来转义

char c1 = '女'; //字符女
char c2 = 'f'; //字符f
char c3 = '6'; //字符6
char c4 = ' '; //空格符
//char c5 = 女; //编译错误，字符直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '10'; //编译错误，只能装一个字符
char c8 = 65; //0到65535之间
System.out.println(c8); //'A'，println()时会依据c8的类型来做输出展示
//若c8为char类型，则以字符形式展示
//若c8为int类型，则以数字形式展示
char c9 = '\\';
System.out.println(c9); //---\

---

类型间的转换

• 数据类型由小到大依次为：byte<short/cahr<int<long<float<double
  • 两种转换方式
    • 自动/隐试转换：小类型到大类型
    • 强制类型转换：大类型到小类型
      1. 语法：（要转换成为的数据类型）变量
      2. 注意：强转可能会发生溢出或丢失精度
• 两点规则
  • 整数直接量可以直接赋值给byte、short、char，但不能超出范围
  • byte、short、char，型数据参与运算时，系统一律将其转换为int再运算

• int a = 5;
  long b = a; //自动/隐式类型转换
  int c = (int)b; //强制类型转换
  long d = 5; //自动类型转换
  double e = 5; //自动类型转换
  System.out.println(e); //5.0
  long f = 10000000000L;
  int g = (int)f;
  System.out.println(g); //1410065408，强转有可能发生溢出
  double h = 25.978
  int i = (int)h;
  System.out.println(i); //25，强转有可能丢失精度
  //----------------------- 两点规则 -------------------------------------
  byte b1 = 5;
  byte b2 = 6;
  byte b3 = (byte)(b1+b2);
  System.out.println(2+2); //4
  System.out.println(2+'2'); //52，2加上'2'的码50
  System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
  System.out.println('2'); //2
  int aa = '我'; //看字符对应的码
  System.out.println(aa); //'我'的码
  char bb = 65; //看码对应的字符
  System.out.println(bb); //A

补充

• 命名法
  • 小驼峰命名法：第1个单词首字母小写，其余单词首字母大写------变量、方法

score,myScore,myJavaScore

• 内存单位换算

1G=1024M(兆)

1M=1024KB(千字节)

1KB=1024B(字节)

1B=8bit(位)