JavaSE语法（1）——【数据类型与变量】

会飞的阿喵

已于 2022-11-13 13:42:02 修改

阅读量753

点赞数 6

分类专栏： JavaSE 文章标签： java 开发语言

于 2022-08-28 21:27:29 首次发布

本文链接：https://blog.csdn.net/Che__dan/article/details/126124787

版权

JavaSE 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

坚持不懈地前进，才能保持荣誉；罢手不干，便会像一套久搁生锈的铠甲，过时的式样，会成为世人揶揄的资料。——莎士比亚《特洛伊罗斯与克瑞西达》

✏️前言

这是Java专栏的第一篇文章，我将会持续往下更新。

不多说了，直接开干！！！

JavaSE语法（2）——【运算符】_虾料的博客-CSDN博客https://blog.csdn.net/Che__dan/article/details/126575184?spm=1001.2014.3001.5501

✏️注释

编译器会忽略注释内容，添加注释的目的是便于代码的维护和阅读，你也不想自己的代码在一个星期后变成天书吧.。

单行注释：// 注释内容（用的最多）

public class HelloWorld {
    public static void main(String[] args){
        // 单行注释：System.out.println是Java中标准输出，会将内容输出到控制台
        System.out.println("Hello World");
    }
}

多行注释：/* 注释内容*/

public class HelloWorld {
    /*多行注释：
    1. main方法是Java程序的入口方法
    2. main函数的格式是固定的，必须为public static void main(String[] args)
    */
    public static void main(String[] args){
        // 单行注释：System.out.println是Java中标准输出，会将内容输出到控制台
        System.out.println("Hello World");
    }
}

文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档。

在IDEA编译器上 (我用的是这个，其他编译器没试过。) 输入“ /** ”然后回车，下面的一堆单词会自动生成，只需解释其参数含义即可。

public class HelloWorld {

    /**
     *
     * @param x 传入一个整数
     * @param y 传入一个整数
     * @return  返回x与y的和
     */

    public static int add(int x,int y) {
        return x + y;
    }


    public static void main(String[] args) {
        int x = 4;
        int y = 5;
        int z = add(x,y);
        System.out.println(z);
    }

}

那什么是说明文档呢？

Java中，有解释各种API的文档（Java Platform SE 8 (oracle.com)），其实我们也能写出这种样子的文档。

第一步：在你的IDEA中写一个类、或者方法，找到这Java文件的位置。（把鼠标放在上方的文件名上，就可以看到你文件的位置。）

第二步：找到该Java文件路径，在搜索栏中输入cmd（搜索栏中只能是cmd不能在路径后面添加。），然后回车，进入控制窗口。

第三步：输入“javadoc -d myAdd -author -version -encoding UTF-8 -charset UTF-8 Add.java”（红色部分，前者为目录名，后者是你自己写的Java文件的名字），回车后如下（那么就成功了）。

-d 创建目录 myAdd为目录名
-author 显示作者
-version 显示版本号
-encoding UTF-8 -charset UTF-8 字符集修改为UTF-8

这时候该路径上多了“myAdd”的文件夹，点进去，再点“index.html”（用浏览器打开），就OK啦！

✏️标识符与关键字

用来标识类名、变量名、方法名、类型名、数组名及文件名的有效字符序列称为标识符，其实就是你给它们取的名字叫标识符。

标识符有如下规则：

标识符不能是关键字。
标识符的第一个字符不能是数字。
标识符中可以包含字母、数字以及下划线和 $ 符号等，长度不受限制。
标识符不能是true、false、null（true、false、null不是关键字）。

关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字。

图片来源：java关键字名单 - 知乎 (zhihu.com)

✏️字面常量

常量即程序运行期间，固定不变的量称为常量。

public class Demo1 {
    public static void main(String[] args) {
        System.out.println("hello world!");
        System.out.println(34);
        System.out.println(3.14);
        System.out.println('A');
        System.out.println(true);
        System.out.println(false);
    }
}

其中：34、3.14、‘A’、true/false都是常量，将其称为字面常量。

字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000。
浮点数常量：程序中直接写的小数，比如：3.14、0.49。
字符常量：由单引号括起来的当个字符，比如：‘A’、‘1’。
布尔常量：只有两种true和false。
空常量：null

✏️变量与数据类型

1.变量

在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩分数、数学函数的计算结果等，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。

定义变量的语法格式为：

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

//数据类型 变量名 = 初始值;
int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
double d = 3.14;
char c = 'A';
boolean b = true;

2.数据类型

2.1基本数据类型

整形

        // 方式一：在定义时给出初始值
        int a = 10;
        System.out.println(a);

        // 方式二：在定义时没有给初始值，但使用前必须设置初值
        int b;
        b = 10;
        System.out.println(b);

        //定义后，在使用前如果没有赋值，则编译期间会报错
        int c;
        System.out.println(c);
        c = 100;

        // int型变量所能表示的范围：
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);

        // 注意：在定义int型变量时，所赋值不能超过int的范围
        int d = 12345678901234; // 编译时报错，初值超过了int的范围

长整型

int a = 10;

long c = 100L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
long d = 100l; // 一般更加以加大写L，因为小写l与1不好区分

// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
System.Out.println(Long.MIN_VALUE);
System.Out.println(Long.MAX_VALUE);

注意：给long类型变量赋值的时候，后面一定要加 L 或者 l 。

短整形

short a = 10;
System.out.println(a);
// short型变量所能表示的范围：
System.out.println(Short.MIN_VALUE);
System.out.println(Short.MAX_VALUE);

字节型

byte b = 10;
System.out.println(b);
// byte型变量所能表示的范围：
System.out.println(Byte.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);

双精度浮点型

double d = 3.14;
System.out.println(d);

int a = 1;
int b = 2;
System.out.println(a / b); // 输出 0.5 吗？其实是0。

double a = 1.0;
double b = 2.0;
System.out.println(a / b); // 输出0.5

double num = 1.1;
System.out.println(num * num); // 输出1.21吗？
// 执行结果：1.2100000000000002

1.除法“/”运算，被除数与除数如果都为整型，那么商就为整数（小数点被舍去）；其中任意一个为浮点型的话，商就为浮点型。

2.单精度浮点型精确位数为7位，双精度浮点型精确位数为15位。

单精度浮点型

float num = 520.0f; // 写作 520.0F 也可以
System.out.println(num);

布尔型

boolean b = true;
System.out.println(b);
b = false;
System.out.println(b);

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

2.2引用数据类型

String类型

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表示：将s1和s2进行拼接
}

字符串和整形数字之间进行转换：

1.int 转成 String

int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);

2.String 转成 int

String str = "100";
int num = Integer.parseInt(str);

3.类型转换

3.1自动类型转换(隐式)

代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行。

        System.out.println(2022); // 整型默认情况下是int
        System.out.println(3.1415926); // 浮点型默认情况下是double
        int a = 444;
        long b = 100L;
        b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值

        a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
        float f = 3.14F;
        double d = 5.21;
        d = f; // 编译器会将f转换为double，然后进行赋值
        f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
        byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

3.2强制类型转换(显式)

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小的。

        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
        
        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
        a = d; // 报错，类型不兼容
        a = (int)d; // double没有int表示的数据范围大，需要强转，小数点之后全部丢弃
        
        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
        boolean flag = true;
        a = flag; // 编译失败：类型不兼容
        flag = a; // 编译失败：类型不兼容

注意：如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失。

4.类型提升

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

int与long之间：int会被提升为long

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的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);

你认为上面代码是对的吗？答案：错。

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

正确写法：

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

会飞的阿喵

关注

6
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录