【Java】——数据类型和变量

在这里插入图片描述
个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章

文章目录：

1.Java中的注释
- 1.1.基本规则
- 1.2.注释规范
2.标识符
3.关键字
4.字面常量
5.数据类型
6.变量
- 6.1变量的概念
- 6.2语法
- 6.3整型变量
- - 6.3.1整型变量
  - 6.3.2长整型变量
  - 6.3.3短整型变量
  - 6.3.4字节型变量
- 6.4浮点型变量
- - 6.4.1双精度浮点型
  - 6.4.2单精度浮点型
- 6.5字符型变量
- 6.6布尔型变量
- 6.7类型转换
- - 6.7.1⾃动类型转换(隐式)
  - 6.7.2强制类型转换（显式）
- 6.8类型提升
- 6.8字符串类型

1.Java中的注释

和C语言一样，注释的作用是为了让代码更容易被理解，虽然不被编译运行，但却不可或缺。为了方便你我他，请重视注释

1.1.基本规则

单行注释：//注释内容
多行注释：/*注释内容 */
文档注释：/** 文档注释 */（常见于方法和类之上描述方法和类的作用），可以被javadoc⼯具解
析，⽣成⼀套以⽹⻚⽂件形式体现的程序说明⽂档

注：多行注释不能嵌套使用

1.2.注释规范

内容准确: 注释内容要和代码⼀致, 匹配, 并在代码修改时及时更新
篇幅合理: 注释既不应该太精简, 也不应该⻓篇⼤论
使⽤中⽂: ⼀般中国公司都要求使⽤中⽂写注释, 外企另当别论
积极向上: 注释中不要包含负能量(例如领导 SB 等)

2.标识符

标识符是程序中用户给类名，方法名，或者变量所取的名字。

标识符中可以包含：字母，数字，下划线及＄符号（合法但不合理）…
注意：标识符不能以数字开头，也不可能是关键字，且严格区分大小写

类名：每个单词的首字母大写（大驼峰）
方法名：首字母小写，后面每个单词的首字母大写（小驼峰）
变量名：与方法名规则相同

3.关键字

我们在写程序时可以发现，public、class以及static等颜⾊会发⽣变化，将这些具有特殊含义的标识符称为关键字。即：关键字是由Java语⾔提前定义好的，有特殊含义的标识符，或者保留字
在这里插入图片描述

4.字面常量

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

在这串代码中，“Hello World”就是字面常量。
常量即程序运行期间，固定不变的量. eg:⼀个礼拜七天，⼀年12个⽉等。

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello World");
        System.out.println(100);
        System.out.println(3.14);
        System.out.println('A');
        System.out.println(true);
        System.out.println(false);
    }
}

在这里插入图片描述

其中，100，3.14，‘A’，true/false都是常量，将其称为字面常量

字符串常量：由 “” 括起来的，⽐如"12345"、“hello”、“你好”。
整型常量：程序中直接写的数字(注意没有⼩数点)，⽐如：100、1000
浮点数常量：程序中直接写的⼩数，⽐如：3.14、0.49
字符常量：由单引号括起来的当个字符，⽐如：‘A’、‘1’
布尔常量：只有两种true和false
字符串、整型、浮点型、字符型以及布尔型，在Java中都称为数据类型。

5.数据类型

Java中数据类型分为两类：基本数据类型和引用数据类型。
基本数据类型有四类八种：

四类：整型，浮点型，字符型，及布尔型
八种：

注：

不论是在16位系统还是32位系统，int都占4个字节，long都占8个字节
整型和浮点型都是带有符号的
整型默认是int 型，浮点型默认是double
字符串属于引用类型

6.变量

6.1变量的概念

在Java中，经常改变的量，称为变量，数据类型就是用来定义不同种类的变量的

6.2语法

数据类型变量名 = 初始值；

public class Test {
    public static void main(String[] args) {
        int a = 10;//变量a,也叫标识符
        double b =3.14;
        char c = 'A';
        boolean d = true;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        a = 100;//和C语言引用，这里是将100赋值给a
        System.out.println(a);
        int a1 = 10, a2 = 20, a3= 30;//一行可以定义多个相同类型的变量
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(3);
    }
}

在这里插入图片描述

6.3整型变量

6.3.1整型变量

public class Test {
    public static void main(String[] args) {
        //定义方法一：定义时给出初始值
        int a = 10;
        System.out.println(a);
        //定义方法二：赋值（使用前没有赋值的话会报错）
        int b;
        b = 20;
        System.out.println(b);
        //int型变量所能表示的范围：
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        //赋值不能超过int范围
    }
}

int的包装类型为Integer

6.3.2长整型变量

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 10;
        //为了区分int和long类型，一般long类型变量的初始值后加上L
        long c = 10L;
    }
}

注：

⻓整型变量的初始值后加L或者l，推荐加L
⻓整型不论在那个系统下都占8个字节
⻓整型的表⽰范围为：-2^63 ~ (2^63)-1
long的包装类型为Long

6.3.3短整型变量

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);
        //范围：
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);
    }
}

注意事项：

short在任何系统下都占2个字节
short的表⽰范围为：-32768 ~ 32767
使⽤时注意不要超过范围(⼀般使⽤⽐较少)
short的包装类型为Short

6.3.4字节型变量

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        System.out.println(a);
        // byte型变量所能表⽰的范围：
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);
    }
}

注意事项：

byte在任何系统下都占1个字节
byte的范围是：-128 ~ 127
字节的包装类型为Byte

6.4浮点型变量

6.4.1双精度浮点型

public class Test {
    public static void main(String[] args) {
        double a = 3.14;
        System.out.println(a);
        int b = 1;
        int c = 2;
        System.out.println(b / c);//在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃⼩数部分)
        double m = 1.0;
        double n = 2.0;
        System.out.println(m / n);//输出0.5
        double x = 1.1;
        System.out.println(x*x);//输出1.2100000000000002
    }
}

在这里插入图片描述

注意事项：

double在任何系统下都占8个字节
浮点数与整数在内存中的存储⽅式不同，不能单纯使⽤的形式来计算
double的包装类型为Double
double 类型的内存布局遵守 IEEE 754 标准(和C语⾔⼀样), 尝试使⽤有限的内存空间表⽰可能⽆限的⼩数, 势必会存在⼀定的精度误差，因此浮点数是个近似值，并不是精确值。

6.4.2单精度浮点型

public class Test {
    public static void main(String[] args) {
        float num = 1.0f;
        System.out.println(num);
    }
}

在Java中占4个字节，不常使用

6.5字符型变量

public class Test {
    public static void main(String[] args) {
        char c1 = 'A';
        char c2 = '1';
        System.out.println(c1);
        System.out.println(c2);
        char c3 = '乾';
        System.out.println(c3);
    }
}

在这里插入图片描述

注意事项:

Java 中使⽤单引号 + 单个字⺟的形式表⽰字符字⾯值.
计算机中的字符本质上是⼀个整数. 在 C 语⾔中使⽤ ASCII 表⽰字符, ⽽ Java 中使⽤ Unicode 表⽰字符. 因此⼀个字符占⽤两个字节, 表⽰的字符种类更多, 包括中⽂.
char的包装类型为Character

6.6布尔型变量

布尔类型常⽤来表⽰真假

public class Test {
    public static void main(String[] args) {
        boolean a = true;//
        System.out.println(a);
        a = false;
        System.out.println(a);

    }
}

注意事项：

boolean 类型的变量只有两种取值, true 表⽰真, false 表⽰假.
Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表⽰ true, 0 表⽰ false 这样的⽤法.

6.7类型转换

Java 作为⼀个强类型编程语⾔, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验.

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        b = a;
        a = b;//编译失败
    }
}

在Java中，当参与运算数据类型不⼀致时，就会进⾏类型转换。Java中类型转换主要分为两类：⾃动类型转换(隐式) 和 强制类型转换(显式)。

6.7.1⾃动类型转换(隐式)

⾃动类型转换：代码不需要经过任何处理，在代码编译时，编译器会⾃动进⾏处理。特点：数据范围⼩的转为数据范围⼤的时会⾃动进⾏。

public class Test {
    public static void main(String[] args) {
        System.out.println(1024);//默认int
        System.out.println(3.14);//默认double
        int a = 100;
        long b = 10L;
        b = a;//int 类型的值⾃动转换为了long类型
        float m =3.14F;
        double n = 5.12;
        n = m;//float 类型的值 ⾃动转换为了double 类型
    }
}

6.7.2强制类型转换（显式）

强制类型转换：当进⾏操作时，代码需要经过⼀定的格式处理，不能⾃动完成。特点：数据范围⼤的到数据范围⼩的。

```java
public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        b = a;//int--long,数据范围由小到大，隐式转换
        a = (int)b;//long--int, 数据范围由⼤到⼩，需要强转，否则编译失败
        float f = 3.14F;
        double d = 1.21;
        d = f;// float-->double，数据范围由⼩到⼤，隐式转换
        f = (float)d;// double-->float, 数据范围由⼤到⼩，需要强转，否则编译失败
        byte m = 100;// 100默认为int，没有超过byte范围，隐式转换
        byte n = (byte)200;// 200默认为int，超过byte范围，需要显⽰转换，否则报错
    }
}

注意事项：

不同数字类型的变量之间赋值, 表⽰范围更⼩的类型能隐式转换成范围较⼤的类型
如果需要把范围⼤的类型赋值给范围⼩的, 需要强制类型转换, 但是可能精度丢失
将⼀个字⾯值常量进⾏赋值的时候, Java 会⾃动针对数字范围进⾏检查
强制类型转换不⼀定能成功，不相⼲的类型不能互相转换

6.8类型提升

不同类型的数据之间相互运算时，数据类型⼩的会被提升到数据类型⼤的。

int被提升为long

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        int c = a + b;//编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b;// 编译成功：a + b==>int + long--->long + long 赋值给long
    }
}

byte与byte之间运算

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        //byte c = a + b;//编译错误
        byte d = (byte)(a + b);//正确书写
        System.out.println(d);
    }
}

在这里插入图片描述

结论:
byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b会先将 a 和 b 都提升成 int, 再进⾏计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现⽅便, 诸如 byte 和short 这种低于 4 个字节的类型, 会先提升成int, 再参与计算.

6.8字符串类型

public class Test {
    public static void main(String[] args) {
        String s1 = " hello";
        String s2 = " world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2);//将s1和s2拼接而不是进行计算
    }
}

在这里插入图片描述

int转String

public class Test {
    public static void main(String[] args) {
        int num = 10;
        String str1 = num + "";//方法一
        String str2 = String.valueOf(num);//方法二
    }
}

String转int

public class Test {
    public static void main(String[] args) {
        String str = "100";
        int num =Integer.parseInt(str);
    }
}

在这里插入图片描述