Java基础语法一步到位（上篇）

╰半橙微兮° 2023-09-28 12:54 16阅读 0赞

**目录**

一、Java语言的发展

二、Java语言学习路线

三、Java环境的安装

四、Java的基本程序设计结构

4.1 CMD梦开始的地方

4.1.1 进入CMD

4.2 第一个Java程序

4.2.1 编写第一个Java程序

4.2.2 Java中编译和解释并存

4.2.3 Java中的注释

4.3 Java关键字

4.3.1 标识符

4.3.2 字面值

4.4 变量

4.4.1 变量的定义

4.4.2 变量的分类

4.4.3 数据类型

4.4.4 数据类型转换

4.4.4 常量

4.5 字符编码

4.5.1 什么是字节

4.5.2 什么是字符编码

4.5.3 Java中的四种进制

4.5.4 进制的转换

4.6 运算符

4.6.1 算术运算符

4.6.2 关系运算符

4.6.3 逻辑运算符

4.6.4 赋值运算符

4.6.5 三元运算符

4.7 String字符串

附件1：WIN10常见快捷键

--------------------

## 一、Java语言的发展 ##

[Java语言的发展历史![icon-default.png_t_M7J4][]https://blog.csdn.net/qq\_41857955/article/details/124160852][Java_icon-default.png_t_M7J4_https_blog.csdn.net_qq_41857955_article_details_124160852]

## 二、Java语言学习路线 ##

[Java语言学习路线![icon-default.png_t_M7J4][]https://blog.csdn.net/qq\_41857955/article/details/122755180][Java_icon-default.png_t_M7J4_https_blog.csdn.net_qq_41857955_article_details_122755180]

## 三、Java环境的安装 ##

[Java环境配置![icon-default.png_t_M7J4][]https://blog.csdn.net/qq\_41857955/article/details/109564260][Java_icon-default.png_t_M7J4_https_blog.csdn.net_qq_41857955_article_details_109564260]

## 四、Java的基本程序设计结构 ##

### 4.1 CMD梦开始的地方 ###

以前的计算机并没有现在所谓的图形化界面展示的如此直观，都是黑屏下使用命令来操作计算机，打开文件夹现在只需点击鼠标，之前不懂的计算机命令的还真玩不起电脑哈哈。

科普一下，最先使用图形化界面的是施乐公司。对于每一个开发人员来说，操作Windows控制台是必不可少的一步技能，下面就来简单介绍一下**CMD命令**的使用。

#### 4.1.1 进入CMD ####

按住**win+R**快捷键进入WIN的运行窗口，输入CMD：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_17_color_FFFFFF_t_70_g_se_x_16][]

点击确定，进入控制台：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_20_color_FFFFFF_t_70_g_se_x_16][]

下表记录了常见的DOS命令。可以参考去使用**【附件1查看操作WIN10快捷键】**：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>&nbsp; <strong>&nbsp; 命令</strong></td> 
   <td><strong>解释说明</strong></td> 
  </tr> 
  <tr> 
   <td>D:</td> 
   <td>盘符名称加上冒号就可以切换所在的盘符了</td> 
  </tr> 
  <tr> 
   <td>dir</td> 
   <td>查看当前路径下的内容(会展示隐藏的文件)</td> 
  </tr> 
  <tr> 
   <td>cd 目录</td> 
   <td>cd加上目录名称可以进入到所在的目录下</td> 
  </tr> 
  <tr> 
   <td>cd ..</td> 
   <td>返回到上一级的目录</td> 
  </tr> 
  <tr> 
   <td>cd /</td> 
   <td>返回到盘符目录</td> 
  </tr> 
  <tr> 
   <td>cls</td> 
   <td>清屏</td> 
  </tr> 
  <tr> 
   <td>exit</td> 
   <td>退出CMD窗口</td> 
  </tr> 
  <tr> 
   <td>ipconfig</td> 
   <td>查看本机的IP地址与网络情况</td> 
  </tr> 
 </tbody> 
</table>

**小技巧：**WIN10开机时，我们需要启动很多软件，这时候使用脚本启动会很方便，复制以下代码，粘贴至文本将文件名后缀改为**bat**即可。

@echo off
     
    ::启动 QQScLauncher
    echo start webstorm64
    call start /d "C:\Program Files (x86)\Tencent\QQ\Bin\QQScLauncher.exe" QQScLauncher.exe
    ::暂停几秒再执行后面的 命令
    ping -n 5 127.1 >nul 2>nul
    echo QQScLauncher started!
    
    ::多个往下复制即可！

### 4.2 第一个Java程序 ###

#### **4.2.1 编写第一个Java程序** ####

学习每门语言的必经之路，那首先要说的就是开启**HelloWorld**，这就是一个简简单单的Java程序：

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @version 1.0
     * 这是我的第一个Java程序哦
     */
    public class HelloWorld {
    
    	/**
    	 * 主方法输出HelloWorld
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// 输出HelloWorld
    		System.out.println("Hello,World!");
    	}
    }

通过控制台的Java命令编译解释后运行，HelloWorld就出来了：

![c2a5d4a49d474274b704fccbc9c75761.png][]

#### **4.2.2 Java中编译和解释并存** ####

编译Java文件使用**javac**命令，解释字节码文件使用**java，**接下来看看什么是解释与编译。

高级编程语言按照程序执行方式分为**编译型和解释型**。

编译型语言是指编译器将源程序一次性翻译成可被该平台执行的机器码；（**翻译与执行分开**）

解释型语言是指解释器对源程序逐行解释成特定平台的机器码并立即执行。（**翻译与执行一次执行**）

比如，你想阅读一本英文名著，你可以找一个英文翻译人员帮助你阅读， 有两种选择方式。

也就是源码）都翻译成汉语，再去阅读，也可以让翻译人员翻译一段，你在旁边阅读一段，慢慢把书读完。

Java 语言既具有编译型语言的特征，也具有解释型语言的特征，因为 Java 程序要经过先编译，后解释两个步骤。

由 Java 编写的程序需要先经过编译步骤，生成字节码（**\*.class 文件**），这种字节码必须由 Java 解释器来解释执行。因此，我们可以认为 Java 语言编译与解释并存。

![20200705091803330.png][]

#### **4.2.3 Java中的注释** ####

为了代码的可读性更强，需要在代码中添加注释，对于Java的注释，主要分为以下几点：

**单行注释**

> **//注释内容：主要用于单行代码的解释**

**多行注释**

> **/\*注释内容\*/： 多行代码的注释**

**文档注释**

> **/\*\* 注释内容\*/： 文档注释，主要注释类开头，一个方法的开头**

文档注释是Java特有的注释，可以将一个一个Java程序生成一个文本文档：

**CMD**输入以下命令执行上述**Java**文件，会在当前路径出现一个文件夹（**myHello**）

> **javadoc -encoding utf-8 -d myHello -author -version HelloWorld.java**

![7b8242985be24a518ce178ef60602ecd.png][]

![90d49d9ff4e64f04aae6fee4c7418ae2.png][]

打开**index.html**主页显示API文档，代码中的注释会全部显示出来：

![c6c8709d65dc41d7bd2aaad3e9c741c6.png][]

### **4.3 Java关键字** ###

Java中的**关键字**是由特定单词组成，单词全为**小写字母**，每个都有特殊的含义，其实Java关键字也就那么几十个，这个不需要特殊记忆，以后会经常使用，用得多便记得住了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70][]

结合我们在日常开发所常见的关键字，将上面的关键字进行如下分类：

![d4dce3266a8f4ed29a60e1fb9de83ca2.png][]

**小贴士：**

> **值得注意的是goto关键字，以前的时候还在用，现在作为Java的保留字，已经不用了，但是还是存在的，保留下来而已。**

#### 4.3.1 标识符 ####

Java中需要我们自定义的名字叫做**标识符。比如方法名，类名等都是需要我们自己定义。**唯一注意的就是**标识符的命名规则，要做到见名知意：**

一个合法的标识符**只能由数字，字母，下划线，$组成，不能有其它符号，开头不能以数字开头，严格区分字母的大小写,并且不能有空格，不可使用关键字。**

#### 4.3.2 字面值 ####

字面值其实就是数据，如1,2,3，"a"等字符，这些字面值在java中会进行分类，这些字面值会具有特有的类型，下面会介绍Java中的数据类型与变量。

### 4.4 变量 ###

#### 4.4.1 变量的定义 ####

变量就是可以变化的量，是内存当中的一小块存储数据的区域空间，用来存储数据的。

这块区域空间会进行相同数据类型范围内的变化，此外变量也是程序中最小的存储单元。它**包含数据类型，变量名称以及变量的值。**

使用变量的几点注意事项：

1.  Java中的变量**必须先声明后使用。**
2.  使用变量名去访问这块区域数据。
3.  变量的作用域作用在\{\}中，且只在其中有效。
4.  同一个作用域内，变量名不可重复定义。

什么是变量的作用域？

> **作用域呢，就是描述变量的有效作用范围，只要是在这个范围里面变量就是可以被访问的。  
> 变量的作用域只需要记住一句话就行了：出了大括号\{\}就不起作用了。**

#### **4.4.2 变量的分类** ####

**根据声明的位置来区分：方法在后面会介绍。**  
  局部变量：在方法体中声明的变量，从属于方法体  
  成员变量：在方法体外声明的变量，从属于对象  
  静态变量：用static定义局部的变量，从属于类

此外值得注意的是static不可用来修饰局部变量，可以修饰成员变量，那就成为了静态变量

变量分类分为全局变量与局部变量，变量的取值采用就近原则：

public class A {
        int i=12;//成员变量
        static a=15;//静态变量
    	public static void main（String[] args）{
    	  int j=10;//局部变量
    	  //static int j=10;错误！！！
    	  System.out.printIn(j)//10,这里为什么不是12呢？这是java语法中的就近原则
    	}
    	int j=12;
    }

#### 4.4.3 数据类型 ####

程序中需要处理许多数据，每一个数据都有它所属的**数据类型**，，对于不同数据都有其对应的数据类型，就是在内存中分配了所对应大小的内存空间。

并且不同数据所开辟的内存大小也会不一样。按照数据类型分类，**Java**可以分为**基本数据类型**与**引用数据类型。**

**基本数据类型**有八种，分三大类，**数值型（包括整型与浮点型），字符型与布尔型，它们是：**

> **byte,short,int,long,float,double,char,boolean**

**`注意`**:字符串类型不是基本的数据类型,是属于引用数据类型比如“1”，字符类型使用单引号’a’。

![3c32f467979f4e10a3215c0858467375.png][]

**整数类型byte,short,int,long使用**

在Java变量的定义是这样的：**数据类型 变量名 = 字面值，Java中的整型常量默认类型是int类型的，在声明long型时需要在常量后面加入L或者小写的l。**

**它们的区别就是所占的字节不同，也就是表示的范围也是不同的,范围如下：**

![022b56ea7af54bcea79d51fd43b6aaac.png][]

变量声明，只要在范围内都是可以的：

/**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/7/2
     */
    public class Demo02 {
    	
    	public static void main(String[] args) {
    		// 变量声明，只要在范围内都是可以的
    		byte b = 127;
    		short s = 123;
    		int i = 199;
    		long l = 21L;
    	}
    }

**浮点型float，double使用**

浮点型就是带小数点的，但是两者的精度有限**float**属于单精度，所以精度难以满足需求，**double**属于双精度，精度要比**float**要高。

Java中声明浮点类型的数据时**float数据类型后需要加入f**

![0f804b058c97457cacc8a7152c18dcfa.png][]

**浮点数精度问题**

在使用浮点数的时候可能会导致精度的丢失，比如这段代码：

public class DataType {
        public static void main(String[] args) {
            //浮点数精度丢失
            float f1 = 221342423242434f;
            float f2 = f1 + 1;
            System.out.println(f1 == f2);//true
        }

发现结果为**`true`**,所以在实际开发中不要使用浮点数进行运算操作，最标准的话是使用**`BigDecimal`对象类型**进行运算。

**boolean类型**

关于布尔类型，只有**true和false**两个值，通常是作为程序判断的标志。

#### 4.4.4 数据类型转换 ####

**1.自动类型转换**

Java程序在做赋值运算时，精度小的类型会自动转换为精度大的数据类型，称为自动类型转换。

数据类型按照**精度大小**来排序为：

![d0f34eb971c142e98510dbef66555a64.png][]

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/15
     */
    public class Demo02 {
    
    	public static void main(String[] args) {
    		// 自动类型转换 char->int 97
    		int i ='a';
    		// 自动类型转换 int->double 89.0
    		double d = 89;
    		System.out.println(i);
    		System.out.println(d);
    	}
    }

**转换细节：**

1.  多种数据类型运算，全部转为容量最大的数据类型后再运算
2.  （byte,short）和char之间不会相互自动转换
3.  byte,short，char之间可以进行计算，计算时，首先转为int类型
4.  布尔类型不参与转换
5.  表达式中的结果会自动提高至操作数中的最大类型

**2.强制类型转换**

将容量大的数据类型转换为容量小的数据类型，使用时需要加上强转符号(),但是可能会导致精度丢失。

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/16
     */
    public class Demo02 {
    
    	public static void main(String[] args) {
    
    		int i = (int)1.89;// 1
    
    		int i2 = 1999;
    
    		byte b = (byte)i2;// 数据溢出
    	}
    }

**转换细节：**

1.  char类型可以保存int的常量值，但是不能保存int的变量值，需要强转。
2.  byte与short在进行运算的时候，当做int来处理。

**练习：**

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/16
     */
    public class Demo02 {
    
    	public static void main(String[] args) {
    
    		short s = 12;
    		s= (short) (s-9);
    		
    		byte b = 10;
    		b= (byte) (b+11);
    		
    		char c = 'a';
    		int i =16;
    		float d = 3.14f;
    		double rs = c + i + d;
    		
    		byte b2 =16;
    		short s2 = 14;
    		short t = (short) (b2 + s2);
    	}
    }

**3.String类型与基本数据强制类型的转换**

对于基本类型转字符串只需将基本数据类型的值+""即可，若基本数据类型转字符串使用parseXXX方法。

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/16
     */
    public class Demo02 {
    
        public static void main(String[] args) {
    		// 基本数据类型->string
            byte b = 10;
            short s = 11;
            int i = 12;
            long l = 11L;
            float f = 1.2f;
            double d = 23.32;
            String b1 = b + "";
            String s1 = s + "";
            String i1 = i + "";
            String l1 = l + "";
            String f1 = f + "";
    		String d1 = d + "";
    		System.out.println(b1+s1+i1+l1+f1+d1);
    
    		// string->基本数据类型
    		String str1 = "123";
    		Integer.valueOf(str1);
    		String str2 = "12";
    		Byte.valueOf(str2);
        }
    }

#### 4.4.4 常量 ####

所谓的常量就是不变的量声明方式也很简单，使用关键字**final**：

public static final int MAX_VALUE = 20;

### **4.5 字符编码** ###

#### **4.5.1 什么是字节** ####

了解字节之前看看什么是二进制，现在的计算机只会识别二进制指令，也就是0与1。

只认识01010101011101010....这种的，计算机识别0与1的时候是通过底层交流电的开闭来告诉辨别指令的。

所谓的1个字节占8个比特位（**1byte=8bit）**而一个比特位存放的就是0或者1。

> **1Byte = 8bit**  
> **1KB =1024Byte**  
> **1MB = 1024KB**  
> **1G = 1024MB**  
> **1T = 1024G**

#### 4.5.2 什么是字符编码 ####

因为计算机只认识二进制数据，但是我们日常中说的语言比如汉字，英语等。这些计算机并不会认识，它们之间也没有任何转换的关系。

为了让计算机能够识别现实中的文字，于是人为的将现实中的文字与二进制的关系所对应起来。

根据某种格式进行编码，这种对照转换关系就是字符编码。

比如最初只支持英文，所以最先出现的字符编码就是ASCII码。比如’a’对应的字符编码是97,对应的二进制就是【01100001】，'A’对应的是65，'0’对应的是48。

将字符’a’通过ASCII进行解码变为【01100001】，反之就是编码。当解码与编码使用的是不是统一的编码对照表就会出现乱码。

![在这里插入图片描述][770e78ef68734e338f94b6970e7ec784.png_pic_center]

Java中的**`char`**基本数据类型，它占了两个字节，只能存储一个汉字或者一个数字，不管存的是什么其实底层本质就是数字。

也就是说**`char`**与数值之间可以进行常量之间的运算，就是表示字符的时候运算的是ASCII对应的值。

public class DataType {
        public static void main(String[] args) {
            char a = '1';
            char b = '国';
            char c = 'A' + 1;
            char d = 'a';
            System.out.println(a);//1
            System.out.println(b);// 国
            System.out.println((int)b);// 22269
            System.out.println((int)c);// 66
            System.out.println((int)d);//97
    	}
    }

#### 4.5.3 Java中的四种进制 ####

整数有常见的四种表示方式，分别是：

1.  **二进制：0,1组成，以0B或者0b开头**
2.  **十进制：0-9组成**
3.  **八进制：0-7，以0开头**
4.  **十六进制：0-9，A-F（10-15）组成，以0X或者0x开头**

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/18
     */
    public class Demo02 {
    
        public static void main(String[] args) {
            int a2 = 0b1001;
            int a10 = 10;
            int a8 = 0123;
            int a16 = 0X123;
        }
    }

#### 4.5.4 进制的转换 ####

**1.二，八，十六进制转十进制**

二进制转十进制从右边开始，每个位数\*2(位数-1)次方

> **ob1011=![1\*2^0+1\*2^1+0\*2^2+1\*2^3][1_2_0_1_2_1_0_2_2_1_2_3]=11**

八进制转十进制从右边开始，每个位数\*8(位数-1)次方

> **0234=![4\*8^0+3\*8^1+2\*8^2][4_8_0_3_8_1_2_8_2]=156**

十六进制转十进制从右边开始，每个位数\*16(位数-1)次方

> **0X23A=![10\*16^0+3\*16^1+2\*16^2][10_16_0_3_16_1_2_16_2]=570**

**2.十进制转二，八，十六进制**

十进制转二进制：将这个数不断除以2之道商为0，将每步的余数倒过来，就是对应的二进制

> **34=0B00100010**

十进制转八进制：将这个数不断除以8之道商为0，将每步的余数倒过来，就是对应的二进制

> **131=0288**

十进制转十六进制：将这个数不断除以16之道商为0，将每步的余数倒过来，就是对应的二进制

> **237=0XED**

**3.二进制转八，十六进制**

二进制转八进制从低位开始，将二进制数每三位一组，转成对应的8进制

> **0B11010101=0325**

二进制转十六进制从低位开始，将二进制数每四位一组，转成对应的16进制

> **0B110101010=0X1AA**

**4.八进制转二进制，十六进制转二进制**

八进制转二进制将八进制的每一位数都转为3位的二进制数

> **0237=0B010011111**

十六进制转二进制将十六进制的每一位数都转为4位的二进制数

> **0X23B=0B0010000111011**

### 4.6 运算符 ###

#### 4.6.1 算术运算符 ####

对数值类型的变量进行运算，常见的算术运算符为 **+ - \* % / ++ -- 重点看一下% / ++**

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/18
     */
    public class Demo02 {
    
        public static void main(String[] args) {
            System.out.println(10/4);// 2 int类型
            System.out.println(10.0/4);// 2.5 double类型
    
            /** % 取模，取余数
             * 取模的本质：a%b=a-a/b*b
             */
            System.out.println(10%3);// 1
            System.out.println(-10%3);// -1
            System.out.println(10%-3);// -1
    
            /**
             * 自增++
             */
            int a = 10;
            // a的值为11 b的值为10 ++在后先赋值后运算
            int b = a++;
            // a的值为12 c的值为12 ++在前先运算后赋值
            int c = ++a;
            System.out.println(b);
            System.out.println(c);
    
        }
    }

#### 4.6.2 关系运算符 ####

关系运算符的结果是一个布尔值，经常使用在循环判断语句中：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>关系运算符</td> 
   <td>运算描述</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>等于</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于</td> 
  </tr> 
  <tr> 
   <td>instanceof</td> 
   <td>判断对象是否是这个类的</td> 
  </tr> 
 </tbody> 
</table>

**代码实例：**

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/18
     */
    public class Demo02 {
    
        public static void main(String[] args) {
            int a = 5;
            int b = 6;
            System.out.println(a == b);
            System.out.println(a > b);
            System.out.println(a < b);
            System.out.println(a <= b);
            System.out.println(a >= b);
            System.out.println(a != b);
        }
    }

![4d2ca502d0fc492e939be610e3274779.png][]

#### 4.6.3 逻辑运算符 ####

用于连接多个条件的表达式，最终结果也是一个布尔型，逻辑运算符一览：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>a</td> 
   <td>b</td> 
   <td>a&amp;b</td> 
   <td>a&amp;&amp;b</td> 
   <td>a|b</td> 
   <td>a||b</td> 
   <td>!a</td> 
   <td>a^b</td> 
  </tr> 
  <tr> 
   <td>true</td> 
   <td>true</td> 
   <td>true</td> 
   <td>true</td> 
   <td>true</td> 
   <td>true</td> 
   <td>false</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>true</td> 
   <td>false</td> 
   <td>false</td> 
   <td>false</td> 
   <td>true</td> 
   <td>true</td> 
   <td>false</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>false</td> 
   <td>true</td> 
   <td>false</td> 
   <td>false</td> 
   <td>true</td> 
   <td>true</td> 
   <td>true</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>false</td> 
   <td>false</td> 
   <td>false</td> 
   <td>false</td> 
   <td>false</td> 
   <td>false</td> 
   <td>true</td> 
   <td>false</td> 
  </tr> 
 </tbody> 
</table>

**注意：**

对于&和&&的区别就是&&有短路的功能，意思就是如果**左边的表达式为FALSE**，右边的表达式就不会执行。对于^逻辑异或运算符，当a,b不同则为TRUE。

#### 4.6.4 赋值运算符 ####

赋值运算符就是将值赋给指定的变量，用**=号**表示，还有一中是**复合赋值运算符a+=b相当于a=a+b;**

#### 4.6.5 三元运算符 ####

三元运算符的基本表达式是：**表达式1?表达式2：表达式3**

意思是：若表达式1的结果为true则执行表达式2，否则执行表达式3。

package com.jektong.basic.day01;
    
    /**
     * @author 爪哇斗罗(javaDouLuo)
     * @date 2022/09/18
     */
    public class Demo02 {
    
        public static void main(String[] args) {
            int a = 5;
            int b = 6;
            // 6
            System.out.println(a>b?a:b);
        }
    }

### **4.7 String字符串** ###

**[String字符串![icon-default.png_t_M85B][]https://blog.csdn.net/qq\_41857955/article/details/128294286][String_icon-default.png_t_M85B_https_blog.csdn.net_qq_41857955_article_details_128294286]**

## 附件1：WIN10常见快捷键 ##

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <th>快捷键</th> 
   <th>作用</th> 
  </tr> 
  <tr> 
   <td><code>Ctrl + C</code></td> 
   <td>复制</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + V</code></td> 
   <td>粘贴</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + A</code></td> 
   <td>全选</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + X</code></td> 
   <td>剪切</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + Z</code></td> 
   <td>撤销</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + Y</code></td> 
   <td>返回上一级的操作</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + S</code></td> 
   <td>保存</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl + Alt + DEL</code></td> 
   <td>打开任务管理器</td> 
  </tr> 
  <tr> 
   <td><code>DEL</code></td> 
   <td>删除文件，放入回收站</td> 
  </tr> 
  <tr> 
   <td><code>Shift + DEL</code></td> 
   <td>永久删除文件</td> 
  </tr> 
  <tr> 
   <td><code>Alt + F4</code></td> 
   <td>关闭当前窗口</td> 
  </tr> 
  <tr> 
   <td><code>Alt + Tab</code></td> 
   <td>切换窗口</td> 
  </tr> 
  <tr> 
   <td><code>Win + Ctrl + D</code></td> 
   <td>创建新的虚拟桌面</td> 
  </tr> 
  <tr> 
   <td><code>Win + Ctrl + F4</code></td> 
   <td>关闭当前虚拟桌面</td> 
  </tr> 
  <tr> 
   <td><code>Win + R</code></td> 
   <td>打开运行对话框</td> 
  </tr> 
  <tr> 
   <td><code>Win + Q</code></td> 
   <td>快速打开搜索</td> 
  </tr> 
  <tr> 
   <td><code>Win + I</code></td> 
   <td>快速打开Win10设置栏</td> 
  </tr> 
  <tr> 
   <td><code>Win + D</code></td> 
   <td>显示桌面，第二次键击恢复桌面</td> 
  </tr> 
  <tr> 
   <td><code>Win + E</code></td> 
   <td>打开文件资源管理器</td> 
  </tr> 
  <tr> 
   <td><code>Win + L</code></td> 
   <td>锁住电脑或切换用户</td> 
  </tr> 
  <tr> 
   <td><code>Win + M</code></td> 
   <td>最小化所有窗口</td> 
  </tr> 
  <tr> 
   <td><code>Win + Shift + M</code></td> 
   <td>恢复所有最小化窗口</td> 
  </tr> 
 </tbody> 
</table>

[icon-default.png_t_M7J4]: https://csdnimg.cn/release/blog_editor_html/release2.1.9/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=M7J4
[Java_icon-default.png_t_M7J4_https_blog.csdn.net_qq_41857955_article_details_124160852]: https://blog.csdn.net/qq_41857955/article/details/124160852
[Java_icon-default.png_t_M7J4_https_blog.csdn.net_qq_41857955_article_details_122755180]: https://blog.csdn.net/qq_41857955/article/details/122755180
[Java_icon-default.png_t_M7J4_https_blog.csdn.net_qq_41857955_article_details_109564260]: https://blog.csdn.net/qq_41857955/article/details/109564260
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_17_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/ecd976b67ca84e8fb76b1b353b8effc8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5YyX5oWV55-l56eL,size_17,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5YyX5oWV55-l56eL_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/a605a711ba6649b0a923eeb0dbd893ea.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5YyX5oWV55-l56eL,size_20,color_FFFFFF,t_70,g_se,x_16
[c2a5d4a49d474274b704fccbc9c75761.png]: https://img-blog.csdnimg.cn/c2a5d4a49d474274b704fccbc9c75761.png
[20200705091803330.png]: https://img-blog.csdnimg.cn/20200705091803330.png
[7b8242985be24a518ce178ef60602ecd.png]: https://img-blog.csdnimg.cn/7b8242985be24a518ce178ef60602ecd.png
[90d49d9ff4e64f04aae6fee4c7418ae2.png]: https://img-blog.csdnimg.cn/90d49d9ff4e64f04aae6fee4c7418ae2.png
[c6c8709d65dc41d7bd2aaad3e9c741c6.png]: https://img-blog.csdnimg.cn/c6c8709d65dc41d7bd2aaad3e9c741c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200224202758276.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70
[d4dce3266a8f4ed29a60e1fb9de83ca2.png]: https://img-blog.csdnimg.cn/d4dce3266a8f4ed29a60e1fb9de83ca2.png
[3c32f467979f4e10a3215c0858467375.png]: https://img-blog.csdnimg.cn/3c32f467979f4e10a3215c0858467375.png
[022b56ea7af54bcea79d51fd43b6aaac.png]: https://img-blog.csdnimg.cn/022b56ea7af54bcea79d51fd43b6aaac.png
[0f804b058c97457cacc8a7152c18dcfa.png]: https://img-blog.csdnimg.cn/0f804b058c97457cacc8a7152c18dcfa.png
[d0f34eb971c142e98510dbef66555a64.png]: https://img-blog.csdnimg.cn/d0f34eb971c142e98510dbef66555a64.png
[770e78ef68734e338f94b6970e7ec784.png_pic_center]: https://img-blog.csdnimg.cn/770e78ef68734e338f94b6970e7ec784.png#pic_center
[1_2_0_1_2_1_0_2_2_1_2_3]: https://latex.csdn.net/eq?1*2%5E0&plus;1*2%5E1&plus;0*2%5E2&plus;1*2%5E3
[4_8_0_3_8_1_2_8_2]: https://latex.csdn.net/eq?4*8%5E0&plus;3*8%5E1&plus;2*8%5E2
[10_16_0_3_16_1_2_16_2]: https://latex.csdn.net/eq?10*16%5E0&plus;3*16%5E1&plus;2*16%5E2
[4d2ca502d0fc492e939be610e3274779.png]: https://img-blog.csdnimg.cn/4d2ca502d0fc492e939be610e3274779.png
[icon-default.png_t_M85B]: https://csdnimg.cn/release/blog_editor_html/release2.2.0/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=M85B
[String_icon-default.png_t_M85B_https_blog.csdn.net_qq_41857955_article_details_128294286]: https://blog.csdn.net/qq_41857955/article/details/107349798