变量&运算符

云中键仙

已于 2023-10-03 11:31:17 修改

阅读量21

点赞数

分类专栏： JavaEE Java 后端文章标签： java 开发语言

于 2023-10-03 10:52:44 首次发布

本文链接：https://blog.csdn.net/qq_45842677/article/details/133513896

版权

Java 同时被 3 个专栏收录

5 篇文章 0 订阅

订阅专栏

JavaEE

4 篇文章 0 订阅

订阅专栏

后端

3 篇文章 0 订阅

订阅专栏

变量

1 知识回顾

java介绍
java平台概述
- javaSE
- javaME
- javaEE
JDK和JRE和JVM
java语言是跨平台的，JVM不是跨平台的
jdk安装
dos命令
- cd
- dir
- cls
- exit
- mkdir
- rmdir
- tree
- 绝对路径/软件.exe 绝对路径/文件.后缀
- javac
- java
HelloWorld案例
一个java文件只能有一个公共类,而且这个公共类的名称必须和文件名相同，可以有多个普通类
Java中区分大小写，windows中不区分大小写
idea安装
注释

2 关键字

关键字是被java语言赋予特殊含义，具有专门用途的单词。

比如HelloWorld案例中的public class,static,void 都是java中的关键字。

2.1 关键字的特点

组成关键字的字母全部都是小写
在常用的IDE中，针对关键字都有高亮效果。不需要去死记硬背。

3 常量

常量又称之为字面值(字面量),就是程序在执行过程中，其值不可以发生改变的量。

字符串常量
- 用双引号括起来的内容
- “HelloWorld”
整数常量
- 所有的整数
小数常量
- 所有的小数
字符常量不能为空也不能有多个字符
- ‘A’
布尔常量 true false
空常量

        // 字符串常量
        System.out.println("我爱北京天安门~");
        // 整数常量
        System.out.println(-23);
        // 小数常量
        System.out.println(3.14);
        // 字符常量 字符常量中不能没有内容 也不能有多个内容
        System.out.println('中');
        // 布尔常量 比较特殊 只有两个值 true false
        System.out.println(false);
        // 空常量

4 变量

4.1 变量概述

在程序执行过程中，在某个范围内其值可以发生改变的量。
从本质上讲，变量是内存中存储数据的区域，能够用来存数据也可以取数据，还可以改变这个数据。
变量的格式: 数据类型变量名 = 初始化值;

4.2 标识符

作用
- 给包，类，变量，方法等起名字。
组成规则(硬性规定)

由**字符，下划线 _,美元符$**组成

这里的字符包括英文大小写字母，中文字符，数字字符。但是符号只能有两个:下划线和美元符

注意事项（硬性规定）

不能以数字开头

不能是Java中的关键字

命名规则(软性建议)
- 基本要求–见名知意 age name
常见命名规则
- 包(其实就是文件夹，用于对类进行管理)
  - 全部小写，多级包用.隔开,是公司域名的反写。
- 类
  - 首字母大写，如果有多个单词，每个单词的首字母都大写(驼峰命名)
  - Hello HelloWorld
- 变量或者方法
  - 一个单词时首字母小写 age name
  - 如果有多个单词，首字母小写，第二个单词开始首字母大写 userAddress ageOfGirlFriend maxAge
- 常量
  - 用大写字母组成 _隔开
  - MY_FRIEND_AGE

4.3 计算机存储单元

变量是内存中的小容器,用来存储数据。

无论是内存还是硬盘，计算机存储设备的最小信息单元叫"位"(bit),又称之为比特位。通常用小写字母b表示。

计算机中最小的存储单元叫"字节"，通常用大写B表示，一个字节由8个位组成。

1 byte(B) = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

1ZB = 1024EB

4.4 数据类型

基本数据类型
- 分为四类八种
- 整数型
  - byte 1 -128~127
  - short 2 -32768~32767
  - int 4 整数的默认类型
  - long 8
    - 定义long类型时，需要添加L或者l,建议使用L
- 浮点型
  - float 4
    - 定义float类型时，需要添加F或者f，建议使用F
  - double 8 浮点型的默认类型
    - 定义double类型时，可以添加D或者d，可以省略
- 字符型
  - char 2
- 布尔型
  - boolean 1
引用数据类型
- 除了基本数据类型，其它的都是引用数据类型

4.5 变量的定义

// 定义变量 byte short int long float double char boolean
        // 变量的定义格式： 数据类型 变量名 = 值;
        //byte
        byte b1 = 127;
        System.out.println(b1);
        // short
        short s1 = 8799;
        System.out.println(s1);
        // int
        int personNum = 1400000000;
        System.out.println(personNum);
        // long
        long num1 = 8000000000L;
        System.out.println(num1);
        float f1 = 5.12F;
        System.out.println(f1);
        double d1 = 3.14D;
        System.out.println(d1);
        char c = '中';
        System.out.println(c);
        boolean flag = false;
        System.out.println(flag);

        // 以下写法都对
        int num = 10_000_000;
        System.out.println(num);

        double num2 = 3e4;
        System.out.println(num2);

5 码表概述

计算机中之所以可以存储这么多字母，主要是因为每种字母都可以通过码表来转换成数字进行存储。

ASCII码表是从0-127,总共128个。包含了常见中英文大小写，阿拉伯数字以及键盘上的操作.

ISO8859-1称之为西欧码表，范围是0-255,在ASCII码表的基础上又添加了新的数据。由于总共有256个，占用了一个字节，所以是世界上第一张完整码表。

GBK中一个汉字占2个字节。

UTF-8中一个汉字占3个字节。

6 转义字符

\t  制表符    相当于按了一次tab键

\r 回车

\n 换行

\\ 反斜杠
\'  单引号
\"  双引号
默认值: \u0000   0

7 变量的注意事项

变量如果没有进行赋值，是不可以直接使用的。
变量只有在自己所属的作用域之内才有效，出了作用域之后，就不能使用了!
- 作用域:从变量定义的那一行开始，到所在的大括号结束为止。
一行当中可以一次性的定义多个相同类型的变量并且赋值(不推荐使用)

public static void main(String[] args) {
        // 变量如果没有进行赋值，是不可以直接使用的。
        // 格式： 数据类型 变量名 = 初始化值;
        // 数据类型 变量名;
        // 变量名 = 初始化值;
        // 定义一个变量，名称是num1
        int num1;
        // 将100赋值给num1
        num1 = 100;
        System.out.println(num1);

        // 扩展: {}是可以嵌套的
        int num2;
        {
            num2 = 10;
            System.out.println(num2);
        }
        System.out.println(num2);
        //一行当中可以一次性的定义多个相同类型的变量并且赋值.
        // 这种方式不推荐使用！！！
        int x =10,y=20,z=30;
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
    }

8 变量的类型转换

8.1 类型转换

类型转换分为:

自动(隐式)类型转换
- 由范围小的数据类型转换成范围大的数据类型
- 特点:代码不需要处理，程序会自动完成。

// 当数据类型不一致时，需要进行类型转换
        // 整数类型的默认类型是int   浮点型类型的默认类型是double
        //这行代码是把int类型赋值给了long类型
        // int类型4个字节，long类型8个字节
        // 这里是由范围小的int类型转换成范围大的long类型
        long l = 100;
        System.out.println(l);
        // float(小) --> double(大)
        double d = 3.14F;
        System.out.println(d);

强制类型转换(强转)
- 由范围大的数据类型转换成范围小的数据类型
- 特点:代码需要特殊处理，否则直接报错
- 格式:范围小的数据类型变量名 = (范围小的数据类型)范围大的值;

		// 强制类型转换
        // =左边的是int类型 =右边的是long类型
        // 由long类型转换成int类型
        // long(大) --> int(小)
        // 范围小的数据类型 变量名 = (范围小的数据类型)范围大的值;
        int num1 = (int) 10000L;
        System.out.println(num1);

8.2 补充:查看数据类型的取值范围

// byte类型的取值范围   max最大值  min最小值   value值
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);

        // short类型的取值范围
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);

        // int类型的取值范围
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        // long类型的取值范围
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);

        // float类型
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);

        // double类型
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);

8.3 类型转换扩展

数字变量是可以用做运算
byte/short/char 在运算时会先提升为int类型，再进行计算

		byte num1 = 20;
        // byte(小) result = int(大);
        byte result = (byte) (num1 + 1);
        System.out.println(result);

        byte num2 = 30;
        short num3 = 100;
        // short(小) = int(大);
        short result1 = (short) (num2 + num3);

boolean具有特殊含义，不能进行强制类型转换
对于byte/short/char类型来说，如果=右侧没有超出范围，那么编译器会自动补全强转

		byte num4 = 127;
        System.out.println(num4);

案例补充

		// 编译这一行时，由于'b'没有超出c的范围，所以编译成功
        char c = 'b';
        // 编译这一行时，系统只知道c是char类型，而不知道c具体的值。
        // c是char类型，范围是0-65535
        // s是short类型，范围是-32768 - 32767
        // 由于c的正整数范围比s的正整数范围大，所以系统认为有可能放不下，报错。
        short s = (short) c;
        System.out.println(c);
        System.out.println(s);

运算符

1 运算符

1.1 运算符介绍

运算符概述
- 对常量或者变量进行操作的符号称之为运算符 +
表达式概述
- 用运算符把常量或者变量连接起来，符合java语法的式子叫做表达式。
- a + b
运算符分类
- 算术运算符
- 赋值运算符
- 关系运算符
- 逻辑运算符
- 三元运算符
- 位运算(等到手撕源码时再讲)

1.2 算术运算符

1.2.1 常规算术

+ - * / %

public static void main(String[] args) {
        // 重命名 shift + f6
        // 加     +
        // 减     -
        // 乘     *
        // 除     /
        // 取余   %   不看商，只看余数
        int a = 10;
        int b = 20;
        System.out.println(a + b);// 30
        System.out.println(a - b);// -10
        System.out.println(a * b);// 200
        // 在java中，对于整数来说，除法用的是小学一年级的算法
        // / 只看商，舍弃余数
        System.out.println(a / b);// 0
        // 只要算数运算中出现了小数，那么结果肯定是小数
        System.out.println(1 / 2.0);

        int i = (int) (4350.0 / 1000 * 1000);
        System.out.println(i);

        System.out.println(1 % 2);
        int num = 34324334;
        System.out.println(num % 2);
    }

1.2.2 扩展

		// 负数取余 就是看表达式左边值的符号  如果左边是正数，那么结果就是正数。如果左边是负数，结果就是负数
        System.out.println(-5 % 3);

        // 小数取余
        System.out.println(3.6 % 2);//1.6
        System.out.println(3 % 1.4);//0.2
        System.out.println(3 - 2.09);

        // ArithmeticException:数学异常
//        System.out.println(1 / 0);
        // NaN  not a number  不是一个数字
        System.out.println(0.0 / 0);

        // +可以用于字符相加
        char zifu1 = '我';
        System.out.println(zifu1 + 1);

        // + 可以用于字符串连接  任何数据类型和字符串进行相加，结果肯定是一个字符串
        System.out.println("Hello" + 1);
        // "Hello" + 3
        System.out.println("Hello" + (1 + 2));

        System.out.println("最大值是" + a);

1.2.3 自增自减运算符

自增运算符 ++

自减运算符 –

格式:可以放在变量前面，也可以放在变量后面

区别:

对于单独使用，自增自减运算符放在变量前面和后面没有任何区别。
对于混合使用
1. 如果++(–)符号在变量前面，那么会先将变量自身立刻加1(减1)，然后根据加1(减1)之后的结果进行其他操作
2. 如果++(–)符号在变量后面，那么会先进行其他操作，然后在进行加1（减1）

        int a  = 10;
        a++;
        System.out.println(a);

        int b = 10;
        ++b;
        System.out.println(b);

        int num1 = 10;
        // 以下代码干了2件事
        // 1.输出变量结果
        // 2.给num1加1
//        1. 如果++(--)符号在变量前面，那么会先将变量自身立刻加1(减1)，然后根据加1(减1)之后的结果进行其他操作
//        2. 如果++(--)符号在变量后面，那么会先进行其他操作，然后在进行加1（减1）
        System.out.println(num1++);// 10
        System.out.println(num1);// 11

        int num2 = 10;
        System.out.println(++num2);//11
        System.out.println(num2);//11

        int num3 = 10;
        int result = num3++ + 1;
        System.out.println(result);// 11
        System.out.println(num3);// 11

        int x = 30;
        int y = 40;
        // 30 + 39
        int z = x++ + --y;
        System.out.println(x);// 31
        System.out.println(y);// 39
        System.out.println(z);// 69

        // 以下代码在运算完成之后，Java在底层会对结果做一个强制类型转换
        byte b1 = 3;
        b1++;
        System.out.println(b1);

1.3 赋值运算符

赋值运算符代表一个动作，将右边的值交给符号左边的内容

分类:

        // = 赋值运算符
        int num1 = 10;
        int num2 = num1;
        System.out.println(num1);
        System.out.println(num2);

        // 复合运算符
        // +=
        int a = 10;
        a += 20; // 相当于 a = a + 20;
        System.out.println("a的值是" +a);

        // -=
        a -= 5;// 相当于 a = a - 5;
        System.out.println("a的值是" + a);

        // *=
        a *= 10;// 相当于 a = a * 10;
        System.out.println("a的值是" + a);

        // /=
        a /= 5;// 相当于 a = a / 5;
        System.out.println("a的值是" + a);

        int b = 4;
        // d = 4 += 4 -= 4 *= 4;
        // d = 4 += 4 -= 16;
        // d = 8 -= 16
        // d = -8
        int d = b += b -= b *= b;
        System.out.println(d);// -8
        
        // 复合运算符默认底层有一个强制类型转换
        byte b1 = 10;
//        b1 = (byte) (b1 + 10);
        b1 += 10;// b1 = b1 + 10;

1.4 关系(比较)运算符

==(相等) !=(不相等) > (大于) < (小于) >= (大于等于) <= (小于等于)
关系运算符的结果都是boolean类型，要么是true，要么是false

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 等于
        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);
        // 小于等于
        System.out.println(a <= b);
    }

注意：关系运算符中的 == 不要误写成 =

1.5 逻辑运算符

作用:逻辑运算符用于连接布尔类型的表达式。
在java中不能写 3 < x < 6
分类
- 与: & 有false则false
- 或: | 有true则true
- 异或: ^ 相同则false，不同则true
- 非: ! 取反 true则false,false则true

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        // 与 &   有false则false   并且
        // true & true
        System.out.println(a < b & a < c & b > c);

        // 或 |   有true则true   或者
        // true | false
        System.out.println(a < c | a > b | a > c);

        // 异或 ^   相同就是false，不同就是true
        // false ^ true
        System.out.println(a > b ^ a > c ^ b > c);

        // 非 ！ 取反  true则false，false则true
        System.out.println(!(a > b));
    }

& | ^ 可以连接多个表达式！只能连接一个表达式

补充:

1. & 和| 哪个优先级更高?

&的优先级高于 |

		// & 比 | 优先级高
        // true
        System.out.println(false & true | true);
        // true
        System.out.println(true | true & false);

2. && 和 &的区别(面试题)?

&&和&在结果上是完全一样的。只是&&的效率更高.

&&有短路效果:如果左边的表达式已经可以判断出最终的结果，那么右边的代码就不会执行.

        // 如果左边的表达式已经可以判断出最终的结果，那么右边的代码就不会执行.
        // false & true
        System.out.println(a > b && a < c);

        int num = 100;
        System.out.println(3 > 4 && ++num < 1000);
        System.out.println(num);  // 100 因为 && 左边的结果是false，右边的代码就不需要执行了 ++num根本没有执行

注意: || 和| 也是一样的效果，||也有短路效果

1.6 三元(三目)运算符

三元运算就是有三个元素参与的运算。

格式: 数据类型变量名 = 判断条件？表达式A : 表达式B;

判断条件必须是一个布尔值

如果条件结果是true，那么将表达式A赋值给变量。

如果条件结果是false，那么将表达式B赋值给变量。

        // 获取两个变量的最大值
        int a = 30;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println("最大值是" + max);

1.7 练习

输入3个整数，获取这3个整数的最大值.

public static void main(String[] args) {
        // 练习:在控制台输入3个整数，获取3个整数的最大值
        Scanner scanner = new Scanner(System.in);
        System.out.println("请您输入三个整数:");
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();
        // 先获取 a b 的最大值
        int max1 = a > b ? a : b;
        // 用c和ab的最大值进行比较
        int max = max1 > c ? max1 : c;
        System.out.println("最大值是" + max);
    }

2 键盘录入

获取用户通过键盘输入的整数。

格式

Scanner 变量名 = new Scanner(System.in);
int a = 变量名.nextInt();

3 package

package是java语言中的包机制，包本质上就是一个文件夹。package用来声明当前文件所在的包。

目的是为了方便程序的管理。

包名全部使用小写，中间用.隔开。一般报名都是公司域名的反写。

package声明包的代码必须在java文件的有效代码的第一行。

import是java中的关键字，用来导入其他地方的包的文件。

云中键仙

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
变量&运算符

在程序执行过程中，在某个范围内其值可以发生改变的量。从本质上讲，变量是内存中存储数据的区域，能够用来存数据也可以取数据，还可以改变这个数据。变量的格式:数据类型变量名 = 初始化值;// 定义变量 byte short int long float double char boolean// 变量的定义格式：数据类型变量名 = 值;//byte// short// int// longchar c = '中';// 以下写法都对。
复制链接

扫一扫

专栏目录