java基础——数据类型，关键字，变量，运算符，逻辑控制，输入输出

素颜马尾好姑娘i 2023-09-27 13:04 17阅读 0赞

> **前言：**
> 
> 小亭子正在努力的学习编程，接下来将开启java基础的学习~~
> 
> 分享的文章都是学习的笔记和感悟，如有不妥之处希望大佬们批评指正~~
> 
> 同时如果本文对你有帮助的话，**烦请点赞关注支持一波, 感激不尽~~**

**目录**

初识Java的main方法

注释：

标识符

关键字

字面量

字面常量的分类：

数据类型

变量

整型变量

长整型变量

短整型变量

字节型变量

双精度浮点型

单精度浮点型

字符型变量

布尔型变量

类型转换

1.自动类型转换(隐式)

2.强制类型转换(显式)

类型提升

字符串类型（基础）

运算符

算术运算符

增量运算符

增/自减运算符

关系运算符

逻辑运算符(重点)

1. 逻辑与 &&

2. 逻辑 ||

3. 逻辑非 !

4. 短路求值 && 和 || 遵守短路求值的规则.

位运算符

移位运算

条件运算符

逻辑控制

1. 顺序结构

2.分支结构

if 语句

switch 语句

循环结构

while 循环

break和continue

for 循环

do while 循环

输入输出

出到控制台

从键盘输入

## 初识Java的main方法 ##

public class HelloWorld{                         //（单行注释）class定义类,HelloWord类名
                 public static void main(String[] args){                                                       
                     System.out.println("Hello,world");                                                      
                 }
             }
    /*
    （多行注释）main方法，固定写法,public static void main(String[] args)
    main,方法是程序的入口函数
    快捷输入是psvm+回车
    */  
    
    
       /**
    文档注释：
    @version v1.0.0
    @author will
    作用HelloWorld类，入门第一个程序练习
    */

**通过上述代码，我们可以看到一个完整的Java程序的结构，Java程序的结构由如下三个部分组成：**

> 1.  源文件（扩展名为\*.java)：源文件带有类的定义。用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。
> 2.  类：类中带有一个或多个方法。**方法必须在类的内部声明**。
> 3.  方法：在方法的花括号中编写方法应该执行的语句。

**【总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。】**

**注意：在一个源文件中只能有一个public修饰的类，而且源文件名字必须与public修饰的类名字相同。**

## 注释： ##

Java中的注释主要分为以下三种：

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

**注意：**

1.  **多行注释不能嵌套使用**
2.  **不论是单行还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息。**

## 标识符 ##

在程序中由用户给类名、方法名或 者变量所取的名字。

**【硬性规则】**

**标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。**

**注意：**

**标识符不能以数字开头，也不能是关键字，且严格区分大小写。**

**$符号合法但是不合理**

【软性建议】

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

## 关键字 ##

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

![f25888b507ae4ef5aefdf6ffc66095aa.png][]

## 字面量 ##

上面的例子System.Out.println("Hello World")； 语句，不论程序何时运行，输出的都是Hello World，其实"Hello World"就是字面常量。

常量即程序运行期间，固定不变的量称为常量，比如：一个礼拜七天，一年12个月等。

### 字面常量的分类： ###

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

## 数据类型 ##

在Java中数据类型主要分为两类：**基本数据类型和引用数据类型。**

基本数据类型有四类八种：

1. 四类：整型、浮点型、字符型以及布尔型

2. 八种：

![8f2e3b5b1582453095d313bb5769fd51.png][]

**注意：**

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

## 变量 ##

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

//整型变量
        int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
        //长整型变量
        long c = 10L
        //短整型变量
        short a = 10;
        // 字节型变量
        byte b = 10;
        // 浮点型变量
        //双精度浮点型变量
        double d = 3.14;
        //单精度浮点型
        float num = 1.0f; // 写作 1.0F 也可以
        //字符型变量
        char c = 'A';
        //布尔型变量
        boolean b = true;
    
    
       // 注意：在一行可以定义多个相同类型的变量
    int a1 = 10, a2 = 20, a3 = 30;

### 整型变量 ###

1.  int不论在何种系统下都是4个字节
2.  在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
3.  变量在使用之前必须要赋初值，否则编译报错
4.  int的包装类型为 Integer

补充：包装类型是基本数据类型的加大版（后面再详细讨论）

### 长整型变量 ###

1.  长整型变量的初始值后加L或者l，推荐加L
2.  长整型不论在那个系统下都占8个字节
3.  long的包装类型为Long

### 短整型变量 ###

1.  short在任何系统下都占2个字节
2.  short的表示范围为：-32768 ~ 32767
3.  使用时注意不要超过范围(一般使用比较少)
4.  short的包装类型为Short

### 字节型变量 ###

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

### 双精度浮点型 ###

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

### 单精度浮点型 ###

float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数 都优先考虑 double, 不太推荐使用 float. float的包装类型为Float。

### 字符型变量 ###

1.  Java 中使用 单引号 + 单个字母（或汉字） 的形式表示字符字面值
2.  计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文

### 布尔型变量 ###

1.  boolean 类型的变量只有两种取值, true 表示真, false 表示假。
2.  Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法。
3.  Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。
4.  boolean的包装类型为Boolean。

## 类型转换 ##

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

### 1.自动类型转换(隐式) ###

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

**特点：数据范围小的转为数据范围大的时会自动进行。**

### 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; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
    byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
    byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
    boolean flag = true;
    a = flag; // 编译失败：类型不兼容
    flag = a; // 编译失败：类型不兼容

**注意事项：**

1.  **不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型** 
2.  **如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失**
3.  **将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查**
4.  **强制类型转换不一定能成功，不相干的类型不能互相转换**

## 类型提升 ##

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

1.  不同类型的数据混合运算, 范围小的会提升成范围大的.
2.  对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.（这种运算可能会出错）

## 字符串类型（基础） ##

在Java中使用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进行拼接，+有拼接的作用
    }

## 运算符 ##

Java中运算符可分为以下：

**算术运算符(+ - \* /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等。**

### 算术运算符 ###

1. 基本四则运算符：加减乘除模(+ - \* / %)

**注意：**

**都是二元运算符，使用时必须要有左右两个操作数**

**int / int 结果还是int类型，而且会向下取整**

**做除法和取模时，*右操作数* 不能为0**

% 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

两侧操作数类型不一致时，向类型大的提升

int a = 3;
    int b = 2;
    // 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
    System.out.println(a / b);
    // 如果要得到数学中的结果，可以使用如下方式
    double d = a*1.0 / b;
    System.out.println(d);
    
    
    int a = 1;
    int b = 0;
    System.out.println(a / b)
    // 运行结果
    //Exception in thread "main" java.lang.ArithmeticException: / by zero
    //at Test.main(Test.java:5)
    
    
    System.out.println(11.5 % 2.0);
    // 运行结果1.5
    
    
    System.out.println(1+0.2); 
    // +的左侧是int，右侧是double，在加之前int被提升为double故：输出1.2

### 增量运算符 ###

**+= -= \*= %= 该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。**

int a = 1;
    a += 2; // 相当于 a = a + 2
    System.out.println(a); // 输出3
    a -= 1; // 相当于 a = a - 1
    System.out.println(a); // 输出2
    a *= 3; // 相当于 a = a * 3
    System.out.println(a); // 输出6
    a /= 3; // 相当于 a = a / 3

注意：只有变量才能使用该运算符，常量不能使用。

### 增/自减运算符 ###

**++ -- ++是给变量的值+1，--是给变量的值-1。**

**注意：**

**i=1**

**++i：i=2,++i这个整体=2**

**i++：i=2,i++这个整体=1**

只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

### 关系运算符 ###

**关系运算符主要有六个: == != < > = ，其计算结果是 true 或者 false 。**

注意：当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的

nt a = 10;
    int b = 20;
    // 注意：在Java中 = 表示赋值，要与数学中的含义区分
    // 在Java中 == 表示相等
    System.out.println(a == b); // false
    System.out.println(a != b); // true
    System.out.println(a < b); // true
    System.out.println(a > b); // false
    System.out.println(a <= b); // true
    System.out.println(a >= b); // false

### 逻辑运算符(重点) ###

**逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。**

#### 1. 逻辑与 && ####

语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。

左右都为真结果为真

左右都为假结果为假

左右一真一假为假

#### 2. 逻辑 || ####

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。

左右至少有一个为真，结果为真。

#### 3. 逻辑非 ! ####

语法规则：! 表达式

真变假，假变真。

#### 4. 短路求值 && 和 || 遵守短路求值的规则. ####

**对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.**

**对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.**

**& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值**

### 位运算符 ###

**Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位,字节是最小的存储单位，每个字节是由8个二进制比特位组成的**，多个字节组合在一起可以表示各种不同的数据。

**位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。**

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位 的每一位依次进行计算.

1.   **按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.**
2.   **按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.**
3.   **按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0**
4.   **按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.**

### 移位运算 ###

移位运算符有三个: > >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

**注意：**

1.   **左移 <<: 最左侧位不要了, 最右侧补 0.向左移位时，丢弃的是符号位，因此正数左移可能会变成负数**
2.   **右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)**
3.   **无符号右移 >>>: 最右侧位不要了, 最左侧补 0.**

**没有无符号左移**

![52057cfb51d04ec8b34ce440f57a023d.png][]

注意:

1.  左移 1 位, 相当于原数字 \* 2. 左移 N 位, 相当于原数字 \* 2 的N次方.
2.  右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
3.  由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
4.  移动负数位或者移位位数过大都没有意义.

### 条件运算符 ###

条件运算符只有一个:

**表达式1 ? 表达式2 : 表达式3**

**当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;**

**当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.**

也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法

// 求两个整数的最大值
    int a = 10;
    int b = 20;
    int max = a > b ? a : b;
    
    
    //注意：
    //1. 表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换
    int a = 10;
    int b = 20;
    int c = a > b? 1 : 2.0;
    //2. 表达式不能单独存在，其产生的结果必须要被使用。
    int a = 10;
    int b = 20;
    int c = a > b? 1 : 2.0;

## 逻辑控制 ##

### 1. 顺序结构 ###

顺序结构比较简单，按照代码书写的顺序一行一行执行。

### 2.分支结构 ###

#### if 语句 ####

if(布尔表达式){
    // 语句
    }
    
    
    if(布尔表达式){
    // 语句1
    }else{
    // 语句2
    }
    //如果布尔表达式结果为true，则执行if中语句，否则执行else中语句。
    
    
    if(布尔表达式1){
    // 语句1
    }else if(布尔表达式2){
    // 语句2
    }else{
    // 语句3
    }
    //表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

**注意：if / else 语句中可以不加 大括号 . 但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配.**

int x = 10;
    int y = 10;
    if (x == 10)
    if (y == 10)
    System.out.println("aaa");
    else
    System.out.println("bbb");

#### switch 语句 ####

switch(表达式){
    case 常量值1:{
    语句1;
    [break;]
    }
    case 常量值2:{
    语句2;
    [break;]
    }
    ...
    default:{
    内容都不满足时执行语句;
    [break;]
    }
    }

执行流程：

1.  先计算表达式的值
2.  和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束
3.  当表达式的值没有与所列项匹配时，执行default

**【注意事项】**

*  **多个case后的常量值不可以重复** 
 *  **switch的括号内只能是以下类型的表达式：**
 *  **基本类型：byte、char、short、int，注意不能是long类型**
 *  **引用类型：String常量串、枚举类型**
 *  **reak 不要遗漏, 否则会失去 "多分支选择" 的效果**
 *  **witch 不能表达复杂的条件**
 *  **switch 虽然支持嵌套, 但是很丑，一般不推荐~**

### 循环结构 ###

#### while 循环 ####

while(循环条件){
    循环语句;
    }
    //循环条件为 true, 则执行循环语句; 否则结束循环

循环条件为 true, 则执行循环语句; 否则结束循环

**注意事项**

1.   **和 if 类似, while 下面的语句可以不写 \{ \} , 但是不写的时候只能支持一条语句. 建议还是加上 \{ \}**
2.   **和 if 类似, while 后面的 \{ 建议和 while 写在同一行.** 
3.   **和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行.**

#### break和continue ####

**break 的功能是让循环提前结束**

**continue 的功能是跳过这次循环, 立即进入下次循环.从而不会执行到continue下方的语句.**

#### for 循环 ####

**for ( 表达式 ① ; 布尔表达式 ② ; 表达式 ③ ) \{ 表达式 ④ ; \}**

**表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次**

**表达式2: 循环条件，满则循环继续，否则循环结束**

**表达式3: 循环变量更新方式.**

【执行过程】

①②③④--->②③④--->②③④--->②③④--->②③④--->②③④--->...--->②为false，循环结束。

【注意事项】 (和while循环类似)

1.  和 if 类似, for 下面的语句可以不写 \{ \} , 但是不写的时候只能支持一条语句. 建议还是加上 \{ \}
2.  和 if 类似, for 后面的 \{ 建议和 while 写在同一行.
3.  和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行.
4.  和while循环一样，结束单趟循环用continue，结束整个循环用break

#### do while 循环 ####

do{
    循环语句;
    }whi

**先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。**

**【注意事项】**

1.  **do while 循环最后的分号不要忘记**
2.   **一般 do while 很少用到, 更推荐使用 for 和 while.**

## 输入输出 ##

### 出到控制台 ###

System.out.println(msg); // 输出一个字符串, 带换行
    System.out.print(msg); // 输出一个字符串, 不带换行
    System.out.printf(format, msg); // 格式化输出

格式化字符串

![ca4c53bd111c45a1bc069744b02c8619.png][]

### 从键盘输入 ###

使用 Scanner 读取字符串/整数/浮点数

import java.util.Scanner; // 需要导入 util 包
    
    Scanner sc = new Scanner(System.in);
    
    System.out.println("请输入你的姓名：");
    String name = sc.nextLine();
    System.out.println("请输入你的年龄：");
    int age = sc.nextInt();
    System.out.println("请输入你的工资：");
    float salary = sc.nextFloat();
    System.out.println("你的信息如下：");
    System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
    sc.close(); // 注意, 要记得调用关闭方法
    // 执行结果
    请输入你的姓名：
    张三
    请输入你的年龄：
    18
    请输入你的工资：
    1000
    你的信息如下：
    姓名: 张三
    年龄：18
    工资：1000.0

使用 Scanner 循环读取 N 个数字，并求取其平均值

Scanner sc = new Scanner(System.in);
    
    int sum = 0;
    int num = 0;
    while (sc.hasNextInt()) {
    int tmp = sc.nextInt();
    sum += tmp;
    num++;
    }
    System.out.println("sum = " + sum);
    System.out.println("avg = " + sum / num);
    sc.close();
    // 执行结果
    10
    40.0
    50.5
    ^Z
    sum = 150.5
    avg = 30.1

//注意事项: 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl + d).

[f25888b507ae4ef5aefdf6ffc66095aa.png]: https://img-blog.csdnimg.cn/f25888b507ae4ef5aefdf6ffc66095aa.png
[8f2e3b5b1582453095d313bb5769fd51.png]: https://img-blog.csdnimg.cn/8f2e3b5b1582453095d313bb5769fd51.png
[52057cfb51d04ec8b34ce440f57a023d.png]: https://img-blog.csdnimg.cn/52057cfb51d04ec8b34ce440f57a023d.png
[ca4c53bd111c45a1bc069744b02c8619.png]: https://img-blog.csdnimg.cn/ca4c53bd111c45a1bc069744b02c8619.png