程序员scholar
  • Java
  • JavaSE - 基础篇
scholar
2024-03-17
目录

Java常量和变量

# 前言

Java以前自学过一些，现在工作了，时间太久有一些知识都遗忘了，今天开始就更新Java了，想着把之前的Java基础知识捡起来；从最基础的开始，打好Java基础，便于以后复习。也欢迎大家跟我一起复习。

# 1. 常量值（constant）

  • 常量值：在程序执行的过程中，其值不可以发生改变

  • 常量值的分类：

    类型 举例
    整数常量值 12，-23, 1567844444557L
    浮点常量值 12.34F，12.34
    字符常量值 ‘a’，'0'，‘高’
    布尔常量值 true，false
    字符串常量值 ”HelloWorld“

  1. 整数常量值：包括没有小数部分的数字。如果整数超过了int类型的范围，需要在数字后面加上L或l来表示long类型。

    System.out.println(12);
System.out.println(-23);
System.out.println(2352654566L);
    1
    2
    3

  2. 浮点常量值：包括有小数点的数字。默认情况下，浮点数是double类型的，如果需要表示float类型，应在数字后加上F或f。

    System.out.println(12.34F);
System.out.println(12.34);
    1
    2

  3. 字符常量值：用单引号'包裹的单个字符。可以是普通的字符、数字或Unicode字符。

    System.out.println('a');
System.out.println('0');
System.out.println('尚');
    1
    2
    3

  4. 布尔常量值：逻辑值true或false，表示逻辑上的真或假。

    System.out.println(true);
System.out.println(false);
    1
    2

  5. 字符串常量值：用双引号"包裹的字符序列。

    System.out.println("HelloWorld");
    1

# 2. 变量（variable）

# 2.1 什么是变量

image-20230530191821409

变量可以看做是一个盒子，这个盒子可以存储数据。本质上，变量是内存当中的一块空间，这块空间有三要素（变量的三要素）：

  • 要素一：数据类型（决定了空间大小）。例如有一种数据类型叫做整数型：int
  • 要素二：名字（只要是合法的标识符就行）。例如：age（年龄）
  • 要素三：值（盒子中具体存储的数据）。例如：20

例如以下代码则表示声明了一个整数类型的变量age，值为20

int age = 20;
1

以及以下代码则表示声明了一个字符串类型的变量name，值为"jack"

String name = "jack";
1

数据类型后面小节会详细讲解。目前只需要知道int代表整数类型，String代表字符串类型即可。 另外，变量的“变”体现在哪里呢？体现在变量这个盒子中的数据是可以改变的。例如，通过“=”赋值运算符，可以改变盒子中存储的数据：

age = 30;
1

这个操作用专业术语表达叫做：给变量重新赋值。 重新赋值时也是有要求的，值的类型要和变量的类型一致，不然就会报错，例如：

age = "30";
1

报错信息如下： image.png

编译器找到等号右边的数据，发现是String类型，然后发现age这个盒子只能存储int类型，类型不匹配，表示这种int盒子不能存放String类型的数据。

# 2.2 变量的作用

有这样一个需求：请用你当前所学知识，分别计算100和111、222、666、888、999的和，你该怎么编写代码？

System.out.println(100 + 111);
System.out.println(100 + 222);
System.out.println(100 + 666);
System.out.println(100 + 888);
System.out.println(100 + 999);
1
2
3
4
5

现在需求变化了，要求计算234和111、222、666、888、999的和，你需要将以上代码中所有的100全部进行修改：

System.out.println(234 + 111);
System.out.println(234 + 222);
System.out.println(234 + 666);
System.out.println(234 + 888);
System.out.println(234 + 999);
1
2
3
4
5

修改了5个位置，如果求和的数据更多，那么修改的位置也会更多，显然：可维护性太差。怎么解决？使用变量可以解决。

int num = 100;
System.out.println(num + 111);
System.out.println(num + 222);
System.out.println(num + 666);
System.out.println(num + 888);
System.out.println(num + 999);
1
2
3
4
5
6

如果需求变化了，只需要修改一个位置即可：

int num = 234;
System.out.println(num + 111);
System.out.println(num + 222);
System.out.println(num + 666);
System.out.println(num + 888);
System.out.println(num + 999);
1
2
3
4
5
6

通过以上内容的学习，可以得知，变量的存在，可以让程序更加易维护。

再比如，又有这样一个需求：现在有三个圆，半径分别是10cm，20cm，30cm，π取值3.14，请分别计算他们的面积，如果不使用变量，程序是这样的：

System.out.println(3.14 * 10 * 10); // 314
System.out.println(3.14 * 20 * 20); // 1256
System.out.println(3.14 * 30 * 30); // 2826
1
2
3

上面程序存在的最大问题就是：可读性太差。使用变量可以提高程序的可读性：

double π = 3.14;
int r1 = 10;
int r2 = 20;
int r3 = 30;
System.out.println(π * r1 * r1);
System.out.println(π * r2 * r2);
System.out.println(π * r3 * r3);
1
2
3
4
5
6
7

因此变量的出现可以提高程序的可读性。

# 2.3 变量的声明

数据类型  变量名;
例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

# 2.4 变量的赋值

给变量赋值，就是把“值”存到该变量代表的内存空间中。

1、变量赋值的语法格式

变量名 = 值;
1
  • 给变量赋值，变量名必须在=左边，值必须在=右边
  • 给变量赋的值类型必须与变量声明的类型一致或兼容（<=）

2、可以使用合适类型的常量值给变量赋值

int age = 18;
double weight = 44.4;
char gender = '女';
boolean marry = true;
String name = "Cisyam";
1
2
3
4
5

long类型：如果赋值的常量整数超过int范围，那么需要在数字后面加L。

float类型：如果赋值为常量小数，那么需要在小数后面加F。

char类型：使用单引号''

String类型：使用双引号""

3、可以使用其他变量或者表达式给变量赋值

int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;
1
2
3
4
5
6

# 2.5 变量值的输出

//输出变量的值
System.out.println(age);

//输出变量的值
System.out.println("年龄：" + age);
System.out.println("age：" + age);
System.out.println("name" + name + ",age = " + age + "，gender = " + gender + ",weight = " + weight + ",marry = " + marry);
1
2
3
4
5
6
7

如果()中有多项内容，那么必须使用 + 连接起来

如果某些内容想要原样输出，就用""引起来，而要输出变量中的内容，则不要把变量名用""引起来

# 2.6 变量可以反复赋值

  • 变量的第一次赋值称为初始化；
  • 变量的再赋值称为修改变量的值；
//先声明，后初始化
char gender;
gender = '女';

//声明的同时初始化
int age = 18;
System.out.println("age = " + age);///age = 18

//给变量重新赋值，修改age变量的值
age = 19;
System.out.println("age = " + age);//age = 19
1
2
3
4
5
6
7
8
9
10
11

# 2.7 变量的三要素

1、数据类型

  • 变量的数据类型决定了在内存中开辟多大空间
  • 变量的数据类型也决定了该变量可以存什么值

2、变量名

  • 见名知意非常重要

3、值

  • 基本数据类型的变量：存储数据值

  • 引用数据类型的变量：存储地址值，即对象的首地址。例如：String类型的变量存储的是字符串对象的首地址（关于对象后面章节再详细讲解）

# 2.8 变量的使用应该注意什么？

1、先声明后使用

int age;
System.out.println(age); // 报错，原因是变量age没有赋值
1
2

如果没有声明，会报“找不到符号”错误

2、在使用之前必须初始化

如果没有初始化，会报“未初始化”错误

3、变量有作用域

如果超过作用域，也会报“找不到符号”错误

4、在同一个作用域中不能重名

5、变量值的类型必须与变量声明的类型一致或兼容（<=）

一致：一样
int age = 18;  18是int类型的常量值，age也是int类型

    
兼容：可以装的下，=右边的值要 小于等于 =左边的变量类型
long bigNum =18; 18是int类型的常量值，bigNum是long类型
int < long

int age = 18L; 错误  18L是long类型的常量值，age是int类型
long > int
1
2
3
4
5
6
7
8
9
10

# 2.9 变量的作用域

# 什么是变量作用域

作用域就是变量的有效范围。变量的作用域是怎样的呢？用一句大白话就可以概括了：出了大括号就不认识了。

public class MyClass {
    static int e = 100;
    public static void main(String[] args){
        int i = 100;
        System.out.println(i);
        for(int k = 0; k < 10; i++){
            int f = 100;
        }
        // 这里是无法访问f变量的
        System.out.println(f);

        // 这里是可以访问e的
        System.out.println(e);
    }
    public static void m(){
        // 这里无法访问main方法中的i
        System.out.println(i);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

image-20230530192428689

作用域的不同主要是因为声明在不同位置的变量具有不同的生命周期。所谓的生命周期是：从内存开辟到内存释放。

# Java的就近原则

public class MyClass {
    
    static int num = 10;
    
    public static void main(String[] args){
        int num = 200;
        // 输出结果是200，这就是就近原则。
        System.out.println(num);
    }
}
1
2
3
4
5
6
7
8
9
10

# 2.10 变量的分类

Java中的变量可以按照作用域的不同划分为以下几类：

  1. 局部变量：定义在方法、语句块、形式参数中的变量。

  2. 成员变量：定义在类中，但在方法之外的变量。

    • 静态成员变量：使用static关键字定义的变量。

    • 实例成员变量：没有使用static关键字定义的变量。

# 3. 最终变量/常量（final）

最终变量习惯上也称为常量，因为它是通过在声明变量的数据类型前面加final的方式实现的，所以叫最终变量。加final修饰后，这个变量的值就不能修改了，一开始赋值多少，就是多少，所以此时的变量名通常称为常量名。常量名通常所有字母都大写，每一个单词之间使用下划线分割，从命名上和变量名区分开来。

这样做的好处，就是可以见名知意，便于维护。

public class FinalVariableDemo {
	public static void main(String[] args){
        //定义常量
        final int FULL_MARK = 100;//满分
       // FULL_MARK = 150;//错误，final修饰的变量，是常量，不能重新赋值
        
        //输出常量值
        System.out.println("满分：" + FULL_MARK);
        
        //小王的成绩比满分少1分
        int wang = FULL_MARK - 1;
        //小尚得了满分
        int shang = FULL_MARK;
        //小刘得了一半分
        int liu = FULL_MARK/2;
        
        //输出变量值
        System.out.println("小王成绩：" + wang);
        System.out.println("小李成绩：" + shang);
        System.out.println("小刘成绩：" + liu);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

以上便是本文的全部内容，本人才疏学浅，文章有什么错误的地方，欢迎大佬们批评指正！我是scholar，一个在互联网行业的小白，立志成为更好的自己。

如果你想了解更多关于scholar (opens new window) (opens new window)，可以关注公众号-书生带你学编程，后面文章会首先同步至公众号。

公众号封面

编辑此页 (opens new window)
上次更新: 2024/12/28, 18:32:08
Java数据类型
Java进制和存储

← Java进制和存储→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar