2 Java的基本程序设计结构（基本语法1）-CSDN博客

本文链接：https://blog.csdn.net/smalltorch/article/details/140281390

文章目录

前言
一、数据类型
二、变量与常量
三、变量和类起名规范
四、java重要的两个包 java.lang和 java.util
- 1 java.lang 包
- 2 java.util 包
五、输入与输出方法
六、生成随机数（Random类）
- （1）nextInt(int bound): 生成一个范围在0（包括）到指定bound（不包括）之间的随机int值。不指定bound就是随机生成一个int值
- （2）nextDouble(): 生成一个范围在0.0（包括）到1.0（不包括）之间的随机double值。不能指定范围
七、运算符
八、判断与循环语句
九、练习

前言

一、数据类型

java数据类型分为两大类：基本数据类型和引用数据类型

基本数据类型：整数、浮点数、字符（char）、布尔类型
引用数据类型：封装在类对象里面的数据类型，字符串（不可变）、数组（可变）、集合（可变）、字典（可变）

与Python进行一个对比：

不可变数据类型：
（1）当该数据类型的对应变量的值发生了改变,那么它对应的内存地址也会发生改变,对于这种数据类型,就称不可变数据类型。
或者说，指的是是对象一旦创建（地址确定），其里面的状态或内容就无法修改。
（2）这一概念与Java中的不可变数据类型的定义是一致的。由于Java里面整数这些数据类型不是对象，就是值，修改就是修改值（修改直接就是在原地改）。因此Java为了解决这个问题，就专门设计了包装类，包装类中将所有字段声明为 private 和 final：这确保了不可变性了，并且也是对象了，所以Java里面的集合里面整数这些都是用的包装类。
可变数据类型：
当该数据类型的对应变量的值（内容）发生了改变,那么它对应的内存地址不发生改变,对于这种数据类型,就称可变数据类型。
- Java中的int、double这类基本数据类型（非对象，直接存在栈空间中）直观上是可变的,需要变成对应的包装类才能和Python中的int,float这些不可变的数据类型一一对应。
- int、double的包装类是不可变的（因此Java集合api里面使用的都是基本数据类型的包装类，而不是基本数据类型），这样就完全和Python里面对应起来了

0 与Python的一些区别

我们主要的目的就是为了搞清楚这些和Python里面有什么异同。
首先，Python传参传的全是传引用。

给出java里面传参规则：

基本数据类型是传值：即传递的是这个变量的值的副本；
引用数据类似是传引用：一般情况下传引用会修改一个就会影响另一个；但如果在类里面规定不可修改，其实也可以实现不影响另一个的；
典型例子就是java里面的字符串是引用数据类型，但是不可变；对原字符串修改其实是新创建一个字符对象在赋值过去，并不是在原来的内存地址上面修改。

基本数据类型需解释一下这里和Python的区别，用整数来说吧。
Python里面整数是不可修改的，传的是引用，

修改是新创建一个整数对象在赋值过去；
且在函数中传参于全局变量与局部变量的关系和Python不可变数据类型的特殊修改方式，导致在函数内部修改不会影响外部的全局变量，因为内部只是一个局部变量；下面代码中的两个 a 实际上是两个不一样的东西，一个放在全局空间，一个放在局部空间。

但在java中，基本数据类型传的是值的副本。什么叫副本就是一个完全不相关的东西，修改一个不会影响另一个的那种。

先说一下修改吧，java中基本数据类型是存在一个栈中，单独没有独立的内存地址（你当他有也行），我们就当它有吧，进行修改操作就直接是在原内存上修改值就可以了。意思理解成假设java中整数有地址，a = a + 1这种操作是在原地址上操作。
然后就是函数传参，由于传参传的是值的副本，那函数内怎么修改肯定不会影响外面的了。

a = 10
def f(a):
    a = a+1
f(a)

public class Main {
   
    public static void main(String[] args) {
   
        int a = 10;
        modifyValue(a);     // 11   内部自动新创建了一个a的值的副本变量传了进去
        System.out.println("Outside method: " + a);  // 10
    }

    public static void modifyValue(int x) {
      
        x = x + 1;
        System.out.println("Inside method: " + x);
    }
}

在这个例子中，a 是一个整数变量，初始值为10。当我们将 a 传递给 modifyValue 方法时，传递的是 a 的值的副本（即10）。在 modifyValue 方法内部，对参数 x 的修改不会影响外部的 a。这就是Java中基本类型按值传递的体现。
python里面用全局变量与局部变量解释，java里面更简单直接用传的是值的副本就可以解释了。

相信还有一个疑问，在Python中的不可变和java中的不可变什么意思；
整数在Python和java中都是不可变的，不可变指的是一个数据类型创建了，它的内存地址就不能改变。Python中直接就硬到底，整数对象生成了就赖在那个地方了；java宽松一点，地址不能变，但里面值还是可以变的。

数组这种虽然最外层的地址不可以变，但内部的其他地址随时都可以变，那就可变了呗。

【注】：java里面基本数据类型都看做不可变数据类型，不可变指的是地址不可变。对象创立了，无论内部地址还是外部地址都不能变的那种。如此看来，虽然Python和java内部规则有不同，但最终结果却是一样的，我们直接可以无缝衔接上。
所以看很多博客将Python的不可变数据函数传参解释成 ‘传值’ 也是有道理的，毕竟和真的传值最后结果是一样的，不过我们还是要牢牢记住还是传引用的。虽然最后结果一样，但档次不一样嘛，拿出去吹牛皮也好啊！

在函数内部Python和java还是有一个奇奇怪怪的区别：

a = 10
def add(a):
    a = 5      # 在Python中，函数内部这种 a 是创建了一个新的局部变量，并不是传进来的那个 a，
                # 可以看到，上面括号里面的a还是灰色的，说明压根没用上海
add(a)
print(a)   # 10

lst = [1, 2, 3, 4, 5]
def add2(lst):
    lst = [1]
    
add2(lst)
print(lst)   # [1, 2, 3, 4, 5]

public class Main {
   
    public static void main(String[] args) {
   
        int a = 10;
        modifyValue(a);     // 20
        System.out.println("Outside method: " + a);  // 10
    }

    public static void modifyValue(int x) {
   
        x = 20;       // java这里并没有创建局部变量（很显然没有声明变量的语法），说明用的就是传进来的 x ，和Python不一样
        System.out.println("Inside method: " + x);
    }
}

奇奇怪怪的吧！这些如果不注意不一定能发现！奇奇怪怪的知识又增加了。

1 基本数据类型

（1）整型

类型	存储需求	取值范围
int	4字节	-2 147 483 648 ~ 2 147 483 647（略高于20亿）
short	2字节	-32 768 ~ 32 767
long	8字节	-9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
byte	1字节	-128 ~ 127

【注】：通常情况下 int 最常用，long也常用；short和byte类型主要在特定场合下用。
【特别注意】：使用long时需要再数据后面加一个大写或小写 L ，类似 long a = 999999999L。其他的正常，就long有点神经病
1byte = 1 字节 = 8bit(位)

（2）浮点数类型

类型	存储需求	取值范围
float	4字节	大约 $\pm 3.402 823 47\times 10^{38}$ （6~7位有效数字）
double	8字节	大约 $\pm 1.79769313486231570\times 10^{308}$ （15位有效数字）

【注】：double的精度是float的两倍，故也称为双精度；通常float类型的精度并不能满足要求，因此用的少，实际中还是要用double
【特别注意】：由于默认是double，所以使用float是数据后面要加一个大写或小写的F，类似 float a = 0.99F

另外，有三个特殊的浮点数表示溢出和出错情况：

正无穷大：Double.POSITIVE_INFINITY
负无穷大 : Double.NEGATIVE_INFINITY
NaN(不是一个数，或者称为一个无法表示的浮点数)，例如 0/0 就出现 NaN : Double.NaN

【注】不能用 == 判断一个特定结果是否是Double.NaN ，但是可以用 Double.isNaN(x)

if (x==Double.NaN)   // 会报错

if (Double.isNaN(x))  // 这样才行

【注】这里关于数据类型的取值大小关系：double>float>long>int>short>byte

（3）字符（char）类型

类型	符号	取值范围
字符	char	0-65535（这里是指编码表里对应的数，一般是Unicode编码）
1 char 占用 2 个字节，16位（bit）。每个位（bit）是一个二进制数字，可以是0或1。因此，一个 char 类型的变量由16个位组成，用于表示字符的UTF-16编码值。

在Java中，char 类型的字符表示 Unicode 码点的 UTF-16 编码单元。在UTF-16中，大部分常见字符（包括绝大多数西文字符和部分中文字符）用一个 char 即可表示，但是某些超出基本多语言平面的字符（如某些少见的中文字符、表情符号等）需要用两个 char 才能表示。

两个字节基本就能存下所以汉字（除了少部分并不常见的），进一步就可以推广到UTF-8，但是Java中的char默认是UTF-16两个字节处理的。

（4）布尔类型(true、false)

类型	符号	取值范围
布尔	boolean	true、false

（5）代码示例

public class HelloWord{
   
		public static void main(String[] args) {
   
            // int
            int i = 9999999;
            System.out.println(i);
            // short
            short s = 9999;
            System.out.println(s);
            // byte
            byte b = 100;
            System.out.println(b);


            // long
            long l = 999999999999999999L;    // long类型后面要加一个大写或小写L
            System.out.println(l);

            // double
            double d = 0.98;
            System.out.println(d);

            // float
            float f = 0.98F;       // float类型后面要加一个大写或小写F
            System.out.println(f);

            // char
            char c = 'a';         // 字符必须用单引号
            System.out.println(c);

            // boolean
            boolean t = true;
            System.out.println(t);
        }
}

2 引用数据类型

引用数据类型：封装在类对象里面的数据类型，字符串（不可变）、数组（可变）、集合（可变）、字典（可变）

【注】：这里只对字符串做一个简单的解释，具体的需要学到具体的在说

类型	符号	注意
字符串(不可变)	String	java中字符串必须使用双引号

public class HelloWord{
   
		public static void main(String[] args) {
   
            String a = "hello world!";   // java中字符串必须使用双引号
            System.out.println(a);
        }
}

二、变量与常量

1 变量

使用语法

声明变量： $数据类型：变量名；$
初始化变量： $数据类型：变量名 = 数据值；$

public class HelloWord{
   
		public static void main(String[] args){
   
			int a;                  // 声明变量
			a = 10;
			System.out.println(a);  // 10

			double b = 2.0;          // 声明变量+初始化
			b = b + 10;
			System.out.println(b);   // 12.0

			int i,j = 0, 1; 
			System.out.println(i,j);
		}

}

【注】：声明变量类型只需要声明一次即可，声明过后后面再用直接用变量名即可；声明变量和变量初始化可以同时进行；
另外，声明变量名时声明变量名不能相同。

与Python相比的小细节

java支持同时声明多个变量，但多重赋值语法和Python有区别
java的打印函数不支持Python一样同时打印多个变量

public class HelloWord{
   
		public static void main(String[] args){
   
			int i,j;
			i = 0;
			j = 1;
			System.out.println(i);    // 0
			System.out.println(j);    // 1

			int a = 4 , b =5;         // java的多重赋值语法
			System.out.println(a);    // 4
			System.out.println(b);    // 5
			

			System.out.println(i,j);    // 报错，java打印不支持Python一样同时打印多个变量

			int a,b = 4,5;              // 报错，java不支持Python一样多重赋值
			

		}

}