day02【IDEA、数据类型转换、运算符、方法】

太过爱你忘了你带给我的痛 2022-08-29 10:53 733阅读 0赞

# day02【IDEA、数据类型转换、运算符】 #

# 一、开发工具IntelliJ IDEA #

## 1.1 开发工具概述 ##

IDEA 全称 IntelliJ IDEA，是java编程语言开发的集成环境。IntelliJ在业界被公认为最好的java开发工具之一，尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn等)、JUnit、CVS整合、代码分析、 创新的GUI设计等方面的功能可以说是超常的。IDEA是JetBrains公司的产品，这家公司总部位于捷克共和国的首都布拉格，开发人员以严谨著称的东欧程序员为主。它的旗舰版本还支持HTML，CSS，PHP，MySQL，Python等。免费版只支持Java，Kotlin等少数语言。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

> 官网：https://www.jetbrains.com/idea/

## 1.2 安装IntelliJ IDEA ##

参考IntellIJ IDEA安装和破解手册

## 1.3 创建项目和模块 ##

### 1）创建项目 ###

1）点击`Create New Project`：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

2）创建一个空项目

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cgy7I4i1-1627646268374)(media/98.png)\]

![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70]

3）选择磁盘路径：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

4）finish：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

### 2）创建模块 ###

1）在弹出的对话框中，点击"+"，然后点击`New Module`创建一个新的模块：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

2）创建一个Java模块：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

3）选择模块的磁盘路径：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

4）模块创建成功：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

5）目录介绍：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

### 3）编写代码 ###

*  编写HelloWorld代码：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        public static void main(String[] args) { 
            System.out.println("Hello World");
        }
    }

### 4）运行代码： ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

查看控制台输出：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]

## 1.4 IDEA的项目目录 ##

*  .idea：和我们开发无关，是IDEA工具自己使用的
 *  out：目录是存储编译后的.class文件
 *  Demo01：模块所在文件夹

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

## 1.5 字体设置 ##

点击菜单栏上的 `File->Settings->Editor->Font` 修改字体

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]

## 1.6 IDEA常用快捷键 ##

<table> 
 <thead> 
  <tr> 
   <th>快捷键</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Alt+Enter</td> 
   <td>导入包，自动修正代码</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Y</td> 
   <td>删除一行</td> 
  </tr> 
  <tr> 
   <td>Ctrl+D</td> 
   <td>快速复制一行</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Alt+L</td> 
   <td>格式化代码</td> 
  </tr> 
  <tr> 
   <td>Ctrl+/</td> 
   <td>单行注释</td> 
  </tr> 
  <tr> 
   <td>Ctrl++Shift+/</td> 
   <td>多行注释</td> 
  </tr> 
  <tr> 
   <td>Alt+Shift+上下箭头</td> 
   <td>移动当前代码行</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Shift+N</td> 
   <td>快速查询当前项目下的所有文件</td> 
  </tr> 
  <tr> 
   <td>Ctrl+N</td> 
   <td>快速查询当前项目的所有类</td> 
  </tr> 
 </tbody> 
</table>

## 1.7 IDEA修改快捷键 ##

在IDEA工具中， Ctrl+空格的快捷键，可以帮助我们补全代码，但是这个快捷键和Windows中的输入法切换快捷键冲突，需要修改IDEA中的快捷键。 `File->Settings->keymap->Main menu->code->Completion->Basic`

1）先移除掉之前的快捷键

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]

2）添加`Alt+/`快捷键：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]

# 二、数据类型转换 #

Java程序中要求参与计算的数据，必须要保证数据类型一致，如果数据类型不一致将发生类型的转换。

## 2.1 自动转换 ##

一个 `int`类型变量和一个 `byte` 类型变量进行加法运算， 结果会是什么数据类型？

int i = 1;
    byte b = 2;

运算结果，变量的类型将是 `int` 类型，这就是出现了数据类型的**自动类型转换现象**。

*  自动转换：将**取值范围小**的类型 自动提升为**取值范围大**的类型 。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        public static void main(String[] args) { 
    
            int i=1;
            byte b =2;
    
            // byte x=b+i; // 报错
    
            // int类型和byte类型运行,结果是int类型
            int j=b+i;
    
            System.out.println(j);
        }
    }

### 2.1.1 转换图解 ###

`byte` 类型内存占有1个字节，在和 `int`类型运算时会提升为int `类型` 自动补充3个字节，因此计算后的结果还是 `int` 类型。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]

同样道理，当一个 `int` 类型变量和一个 `double` 变量运算时， `int` 类型将会自动提升为 `double` 类型进行运算。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
    
            int i=1;
    
            double d=2.5;
    
            // int类型和double类型运算，结果是double类型
            // int类型会提升为double类型
    
            // int x= i+d; // 报错
            double x=d+i;
    
            System.out.println(x);
        }
    }

### 2.1.2 转换规则 ###

范围小的类型向范围大的类型提升，`byte`、`short`、`char` 运算时直接提升为 `int` ；

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

条件1 ： 小的范围与大的范围相加的结果就是大的范围的数据类型

## 2.2 强制转换 ##

将 1.5 赋值到 `int` 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i=1.5;  // 报错

`double`类型内存8个字节， `int`类型内存4个字节。 1.5是`double`类型，取值范围大于`int` ；

想要赋值成功，只有通过强制类型转换，将 `double` 类型强制转换成 int 类型才能赋值。

*  **强制转换**：将 取值范围大的类型 强制转换成 取值范围小的类型；比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

强制转换格式：

数据类型 变量名 = (数据类型)被转数据值;

将 1.5 赋值到 int 类型，代码修改为：

// double类型数据强制转成int类型，直接去掉小数点。
    int i=(int)1.5;

同样道理，当一个 `short` 类型与 `int` 类型相加，我们知道会类型提升，但是还想给结果赋值给 `short` 类型变量，就需要强制转换。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) { 
            // short类型变量,内存中存储两个字节
            short s = 1;
            int i = 1;
            /* 出现编译错误 出现编译失败 s和i做运算的时候，i是int类型，s会被提升为int类型 s+i后的结果是int类型，将结果在赋值会short类型时发生错误 short内存2个字节，int类型4个字节 必须将int强制转成short才能完成赋值 */
    
    // s = s + i; //编译失败
            s = (short) (s + i);        //编译成功
            System.out.println(s);
        }
    }

### 2.2.1 转换图解 ###

`short` 类型内存占有2个字节，在和 `int`类型运算时会提升为 int 类型 ，自动补充2个字节，计算后的结果还是 `int` 类型，但最终被强转为了`short`类型，占用2个字节空间。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]

### 2.2.2 注意事项 ###

*  1）浮点转成整数，直接取消小数点（不是四舍五入），可能造成数据损失精度；
 *  2）int 强制转成 short 砍掉2个字节，可能造成数据丢失；

练习，以下代码是否有问题？如何解决？

public class Demo04 {     
        public static void main(String[] args) {         
            byte b1 = 1;        
            byte b2 = 2;       
            byte b3 = b1 + b2;        // 当变量的数据类型小于int做运算时,会转成int再运算 byte b3 = (byte)b1 + b2; 
        }
    }

# 三、运算符 #

## 3.1 算术运算符 ##

<table> 
 <thead> 
  <tr> 
   <th>算术运算符</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>+</code></td> 
   <td>加法运算，字符串连接运算</td> 
  </tr> 
  <tr> 
   <td><code>-</code></td> 
   <td>减法运算</td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td>乘法运算</td> 
  </tr> 
  <tr> 
   <td><code>/</code></td> 
   <td>除法运算</td> 
  </tr> 
  <tr> 
   <td><code>%</code></td> 
   <td>取模运算，两个数字相除取余数</td> 
  </tr> 
  <tr> 
   <td><code>++、--</code></td> 
   <td>自增自减运算</td> 
  </tr> 
 </tbody> 
</table>

### 3.1.1 基本运算 ###

*  算数运算符练习：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo05 {     
        public static void main(String[] args) {         
            // 定义变量 
            int a = 5;        
            int b = 3;        
            System.out.println(a + b);      //8 
            System.out.println(a - b);      //2 
            System.out.println(a * b);      //15 
            System.out.println(a / b);      //1 
            System.out.println(a % b);      //2 
            System.out.println("------------");        //整数相除，结果是整数，要得到小数，必须有小数参与运算(提升为double类型) 
            System.out.println(5.0 / 3);        //1.6666666666666667 
            System.out.println(5 / 3.0);        //1.6666666666666667 
        }
    }

**%取余注意事项：**

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo06 {     
        public static void main(String[] args) {         
            System.out.println(5 % 3);        
            System.out.println(-5 % 3);        
            System.out.println(5 % -3);        
            System.out.println(-5 % -3);    
        }
    }

> tips：取余结果符号与左边符号相同

### 3.1.2 ++和– ###

\++ 运算，变量自己增长1。反之， – 运算，变量自己减少1，用法与 ++ 一致。

*  独立运算：
    
     *  变量在独立运算时， 前++ 和 后++ 没有区别 。
     *  变量 前++ ：例如 ++i 。
     *  变量 后++ ：例如 i++ 。
 *  混合运算：
    
     *  和其他变量放在一起， 前++ 和 后++ 就产生了不同。

`变量 前++` ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo07 { 
        public static void main(String[] args) { 
    
            int a = 1;
            int b = ++a;                //先++,后赋值
    
            System.out.println(a);          //2
            System.out.println(b);          //2
        }
    }

`变量 后++` ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo08 { 
        public static void main(String[] args) { 
    
            int a = 1;
            int b = a++;            //先赋值，后++
    
            System.out.println(a);      //2
            System.out.println(b);      //1
        }
    }

**自增自减小练习**

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo09 { 
        public static void main(String[] args) { 
            int a = 10;
            int b = 10;
            int c = 10;
            a = b++;
            c = --a;
            b = ++a;
            a = c--;
    
            System.out.println(a);      //?
            System.out.println(b);      //?
            System.out.println(c);      //?
        }
    }

答案

### 3.1.3 +=运算 ###

public class Demo {     
        public static void main(String[] args) {         
            short s = 1;       
            s += 1;				          
            System.out.println(s);    
        }
    }

s += 1 逻辑上看作是 s = s + 1；计算结果被提升为int类型再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型，但是， s=s+1进行两次运算 ， += 是一个运算符，只运算一次，并带有强制转换的特点，也就是说 s += 1 就是 `s = (short)(s + 1)` ，因此程序没有问题编译通过，运行结果是2；

但如果是s=s+1；那么就会出现编译保存，需要强制转换；

### 3.1.4 字符串注意事项 ###

符号在遇到字符串的时候，表示连接、拼接的含义。“a”+"b"的结果是“ab”，连接含义

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo10 { 
        public static void main(String[] args) { 
            // +遇到字符串表示连接
            System.out.println("df" + "bz");        //"dfbz"
            System.out.println("dfbz" + 10);        //"dfbz10"
    
            //1. "dfbz"+5="dfbz5"; 2. "dfbz5"+5="dfbz"
            System.out.println("dfbz" + 5 + 5);
    
            System.out.println("dfbz" + (5 + 5));   //1. 5+5=10; 2. 10+"dfbz"="10dfbz"
            System.out.println(5 + 5 + "dfbz");     //1. 5+5=10; 2. 10+"dfbz"="10dfbz"
    
            System.out.println("1+1="+1+1);
        }
    }

**思考？**

System.out.println("1+1="+1+1);

### 3.1.5 常量和变量的运算 ###

思考？下面的程序有问题吗？

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo {     
        public static void main(String[] args) {         
            byte b1 = 1;        
            byte b2 = 2;        
            byte b3 = 1 + 2;        
            byte b4 = b1 + b2;    
        }
    }

分析： `b3 = 1 + 2` ， 1 和 2 是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了 1+2 的结果并没有超过byte类型的取值范围，可以赋值给变量 b3 ，因此`b3=1 + 2`是正确的。反之， `b4 = b2 + b3` ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。

## 3.2 赋值运算符 ##

赋值运算符，就是将符号右边的值，赋给左边的变量。

<table> 
 <thead> 
  <tr> 
   <th>赋值运算符</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>=</code></td> 
   <td>赋值</td> 
  </tr> 
  <tr> 
   <td><code>+=</code></td> 
   <td>加后赋值</td> 
  </tr> 
  <tr> 
   <td><code>-=</code></td> 
   <td>减后赋值</td> 
  </tr> 
  <tr> 
   <td><code>*=</code></td> 
   <td>减后赋值</td> 
  </tr> 
  <tr> 
   <td><code>/=</code></td> 
   <td>除后赋值</td> 
  </tr> 
  <tr> 
   <td><code>%=</code></td> 
   <td>取模后赋值</td> 
  </tr> 
 </tbody> 
</table>

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo11 { 
        public static void main(String[] args) { 
    
            // 定义变量 
            int i = 3; // 将3赋值给变量i 
            i = i + 2; // 将变量i和2相加,再赋值给变量i 
            System.out.println(i);
            // +=: 赋值运算符, 将=左边的变量和=右边的值进行操作,再赋值给变量 
            int j = 10;
            j += 5; // j = j + 5 
            System.out.println(j);
    
            int m = 10;
            m -= 5; // m = m ‐ 5; 
            System.out.println(m);
            System.out.println("‐‐‐‐‐‐‐‐‐‐");
            byte b = 1;
            // b = b + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失 
            // b += 2; // 可以
    
            b = (byte) (b + 2);
            System.out.println(b);
        }
    }

## 3.3 比较运算符 ##

比较运算符又叫关系运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

<table> 
 <thead> 
  <tr> 
   <th>比较运算符：</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>==</code></td> 
   <td>比较符号两边数据是否相等，相等结果是true。</td> 
  </tr> 
  <tr> 
   <td><code>&lt;</code></td> 
   <td>比较符号左边的数据是否小于右边的数据，如果小于结果是true。</td> 
  </tr> 
  <tr> 
   <td><code>&gt;</code></td> 
   <td>比较符号左边的数据是否大于右边的数据，如果大于结果是true。</td> 
  </tr> 
  <tr> 
   <td><code>&lt;=</code></td> 
   <td>比较符号左边的数据是否小于或者等于右边的数据，如果小于或等于结果是true。</td> 
  </tr> 
  <tr> 
   <td><code>&gt;=</code></td> 
   <td>比较符号左边的数据是否大于或者等于右边的数据，如果小于或等于结果是true。</td> 
  </tr> 
  <tr> 
   <td><code>!=</code></td> 
   <td>不等于符号 ，如果符号两边的数据不相等，结果是true。</td> 
  </tr> 
 </tbody> 
</table>

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo12 { 
        public static void main(String[] args) { 
            System.out.println(3 == 3); // true 
            System.out.println(3 == 4); // false 
            System.out.println(3 != 4); // true 
            System.out.println(3 > 4); // false 
            System.out.println(3 < 4); // true 
            System.out.println(5 <= 4); // false 
            System.out.println(4 >= 4); // true 
            // 注意 
            int i = 3;
            int j = 4;
            System.out.println(i = j); // 将j赋值给i,输出i 
            System.out.println(i == j); // true 
        }
    }

## 3.4 逻辑运算符 ##

*  逻辑运算符，是用来对两个布尔类型进行运算的，运算结果都是布尔值 `true` 或者 `false`

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>运算规则</th> 
   <th>示例</th> 
   <th>结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>&amp;</code></td> 
   <td>与（有假为假）</td> 
   <td>false&amp;true</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td><code>|</code></td> 
   <td>或（有真为真）</td> 
   <td>false|true</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td><code>^</code></td> 
   <td>异或（相同为false，不同为true）</td> 
   <td>false^true</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td><code>!</code></td> 
   <td>非（取反，true为false，false为trie）</td> 
   <td>!true</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td><code>&amp;&amp;</code></td> 
   <td>短路与（和<code>&amp;</code>一样，前面条件为false不执行后面的，效率高）</td> 
   <td>false&amp;&amp;true</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td><code>||</code></td> 
   <td>短路或（和<code>|</code>一样，前面条件为true不执行后面的，效率高）</td> 
   <td>false||true</td> 
   <td>true</td> 
  </tr> 
 </tbody> 
</table>

`& 与,| 或,! 非,^ 异 或`案例代码：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo13 { 
        public static void main(String[] args) { 
            // & 与: 有false则false, 
            System.out.println(false & false); // false
            System.out.println(false & true); // false
            System.out.println(true & false); // false
            System.out.println(true & true); // true
            System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
            // | 或: 有true则ture, 
            System.out.println(false | false); // false
            System.out.println(false | true); // true
            System.out.println(true | false); // true
            System.out.println(true | true);// true
            System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
            // ! 非: 取反
            System.out.println(!true); // false
            System.out.println(!false); // true
            System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
            // ^ 异或: 不同为true,相同为false
            System.out.println(false ^ false); // false
            System.out.println(false ^ true); // true
            System.out.println(true ^ false); // true
            System.out.println(true ^ true);// false
        }
    }

`&& 短路与,||` 短路或 案例代码：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo14 { 
        public static void main(String[] args) { 
            // &&和&结果一样,左边是false右边不执行 
            System.out.println(false && false);// false 
            System.out.println(false && true);// false 
            System.out.println(true && false);// false 
            System.out.println(true && true);// true 
            System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    
            // ||和|结果一样,左边是true右边不执行 
            System.out.println(false || false);// false 
            System.out.println(false || true);// true 
            System.out.println(true || false);// true 
            System.out.println(true || true);// true 
        
            
            int i = 3;
            int j = 4;
    
            //如果左边的为true还会执行后面的,为false不执行后面的
            System.out.println(i == j && ++i > 2);
            System.out.println(i); // 3 
            System.out.println(j); // 4 
            
            //如果左边为true就不执行后面的,为false执行后面的
            System.out.println(i != j || ++i > 2);
            System.out.println(i);// 3 
            System.out.println(j);// 4 
        }
    }

## 3.5 三元运算符 ##

*  三元运算符格式：

数据类型 变量名 = 布尔类型表达式 ? 结果1 : 结果2;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 17]

三元运算符计算方式：

*  布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
 *  布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo15 { 
        public static void main(String[] args) { 
    
            int a = 30;
            int b = 30;
            int c = a > b ? 100 : 20;
    
            System.out.println(c);
        }
    }

三元运算符练习

*  判断两个数是否相同
 *  获取两个数的较大值

# 四、方法 #

## 4.1 方法概述 ##

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。

**简单来说Java方法是语句的集合，它们在一起执行一个功能。**

*  **方法**：就是将一个**功能**抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

## 4.2 方法的简单使用 ##

### 4.2.1 方法的定义 ###

*  定义格式：

修饰符 返回值类型 方法名(参数列表){ 
        逻辑代码...
        return 返回值;
    }

*  定义格式解释：
    
     *  修饰符： 目前固定写法 `public`、`static` 。
     *  返回值类型： 方法运行结果的数据类型，如果该方法没有返回值，那么请声明为`void`
     *  方法名：满足标识符的规范，用来调用方法。
     *  参数列表：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
 *  举例：

public static void methodName() { 
        System.out.println("这是一个方法");
    }

### 4.2.2 方法的调用 ###

方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo16 { 
        public static void main(String[] args) { 
            // 调用方法
            methodName();
        }
    
        public static void methodName() { 
            System.out.println("这是一个方法");
        }
    }

### 4.2.3 调用练习 ###

需求：定义一个方法利用三元运算符求3个数的最大值。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo17 { 
        public static void main(String[] args) { 
            operator2();
            operator3();
        }
    
        // 求3个数的最大值 
        public static void operator3() { 
            int i = 250;
            int j = 120;
            int k = 60;
    
            // 先找出2个数中较大的数 
            int tmp = i > j ? i : j;
    
            // 再让较大的数和第三个数比较 
            int max = tmp > k ? tmp : k;
            System.out.println("最大的数: " + max);
        }
    
        // 求2个数的最大值
        public static void operator2() { 
            int i = 50;
            int j = 30;
    
            int m = i > j ? i : j;
            System.out.println("较大的数: " + m);
        }
    }

### 4.2.4 注意事项 ###

方法定义注意事项：

*  方法必须定义在一个类中方法外
 *  方法不能定义在另一个方法的里面

public class Demo { 
    
        public static void main(String[] args) { 
            
        }
        //正确位置,类中方法外
        public static void method(){ 
        }
        
    }

错误示例：

public class Demo { 
    
        public static void main(String[] args) { 
            //错误写法
            public static void method(){ 
    
            }
        }
    }

## 4.3 方法使用进阶 ##

### 4.3.1 方法的参数列表和返回值 ###

需求：定义方法实现两个整数的求和计算。

*  \*\*明确返回值类型：\*\*方法计算的是整数的求和，结果也必然是个整数，返回值类型定义为int类型。
 *  \*\*明确参数列表：\*\*计算哪两个整数的和，并不清楚，但可以确定是整数，参数列表可以定义两个int类型的  
    变量，由调用者调用方法时传递

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo18 { 
        public static void main(String[] args) { 
    
            int max = max(20, 18);
    
            System.out.println("最大值为: "+max);
        }
    
        public static int max(int num1, int num2) { 
    
            int result;
    
            if (num1 > num2) { 
                result = num1;
            } else { 
                result = num2;
            }
            return result;
        }
    }

*  方法信息详解：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 18]

*  方法调用详解：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 19]

### 4.3.2 调用方法的三种形式 ###

public static void main(String[] args) { 
    	print();
    }
    public static void print() { 
    	System.out.println("方法被调用");
    }

\*\*赋值调用：\*\*调用方法，在方法前面定义变量，接收方法返回值

public static void main(String[] args) { 
    	int sum = getSum(5,6);
    	System.out.println(sum);
    }
    	public static int getSum(int a,int b) { 
    	return a + b;
    }

输出语句调用：在输出语句中调用方法， System.out.println(方法名()) 。

public static void main(String[] args) { 
    	System.out.println(getSum(5,6));
    }
    public static int getSum(int a,int b) { 
    	return a + b;
    }

不能用输出语句调用void 类型的方法。因为方法执行后没有结果，也就打印不出任何内容。

### 4.3.3 方法的重载 ###

上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？

在同一个类中定义max方法：

public static double max(double num1, double num2) { 
    
        double result;
    
        if (num1 > num2) { 
            result = num1;
        } else { 
            result = num2;
        }
    
        return result;
    }

我们发现求2个int数的最大值和2个double数的最大值功能是一样的，其意思也差不多；如果定义不同的方法名使用起来不方便，我们给方法命名最好能够见名知意；这个时候我们就希望定义成一样的名称，就是方法的重载；

*  **方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同**即可，与**修饰符和返回值类型无关（即使修饰符和返回值列表不一样也不属于重载）**
 *  参数列表不同：个数不同，数据类型不同，顺序不同。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 20]

### 4.3.4 方法重载练习 ###

#### 练习一 ####

比较两个数据是否相等。参数类型分别为两个 `byte` 类型，两个 `short` 类型，两个 `int` 类型，两个 `long` 类型，并在 `main` 方法中进行测试。

public class Method_Demo6 { 
        public static void main(String[] args) { 
            //定义不同数据类型的变量
            byte a = 10;
            byte b = 20;
            short c = 10;
            short d = 20;
            int e = 10;
            int f = 10;
            long g = 10;
            long h = 20;
            // 调用
            System.out.println(compare(a, b));
            System.out.println(compare(c, d));
            System.out.println(compare(e, f));
            System.out.println(compare(g, h));
        }
        // 两个byte类型的
        public static boolean compare(byte a, byte b) { 
            System.out.println("byte");
            return a == b;
        }
        // 两个short类型的
        public static boolean compare(short a, short b) { 
            System.out.println("short");
            return a == b;
        }
        // 两个int类型的
        public static boolean compare(int a, int b) { 
            System.out.println("int");
            return a == b;
        }
        // 两个long类型的
        public static boolean compare(long a, long b) { 
            System.out.println("long");
            return a == b;
        }
    }

#### 练习二 ####

判断哪些方法是重载关系。

public static void open(){ }
    public static void open(int a){ }
    static void open(int a,int b){ }
    public static void open(double a,int b){ }
    public static void open(int a,double b){ }
    public void open(int i,double d){ }
    public static void OPEN(){ }
    public static void open(int i,int j){ }

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

**上一篇**：[day01【计算机基础、Java概述】][day01_Java]

**下一篇**：[day03【流程控制、JVM内存、数组】][day03_JVM]

**目录**：【JavaSE零基础系列教程目录】

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

# 记得点赞~！！！ #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/ace9b3af610d4863b21936b9ccbcf7b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/2f3db6c7c4a247dead5fe2ae57d42f3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70]: /images/20220829/3a5e2a56a0ec40ffb8cacdfdabffa13f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/558184ab19454341ae45b2986a12dead.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/876690cdb12b45808c41063ae9ad9494.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/2a0c69244b0a4a138854c8bf172ff48b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/e1889c611bce4f5086148aa0d1798931.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/37126429e90e4a5e9214a62eddd75892.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/30bb844708f94158b74d7bab0dbdaf6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/b0ff64c51eb7419ab9969b2a6d3f0343.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/2593d4e366ed45a4bf16b1da5a66f15d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/a5112ad3fad24cb7a6414cf63b1eb940.png
[a786cefffd884852ae438a19f33c6d5e.png_pic_center]: /images/20220829/1504c191252742d8b26ec21dfb61e6c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/d8d516324c574f58a049b212366da2e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/074bc777008642f4b7e4ff8149365e13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/1818754523104317ae87ca46503e9a6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20220829/cee25aaf711e48b9ac3d6387e8e82734.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20220829/badaae51343247a08049fd80251caf6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20220829/ceba77ac417f4f9789880a570a2944ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20220829/60b947b0bf8048e789242a4c9e250776.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20220829/e659e060c5df4713a61dd9dcd219dce4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20220829/1ff2ace18c3d40f890337808835a6018.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20220829/95ec3329f20d4216bc5a8ec93453e488.png
[day01_Java]: https://blog.csdn.net/Bb15070047748/article/details/119254950?spm=1001.2014.3001.5501
[day03_JVM]: https://blog.csdn.net/Bb15070047748/article/details/119255318?spm=1001.2014.3001.5501