文章目录

02【IDEA、数据类型转换、运算符】
一、开发工具IntelliJ IDEA
- 1.1 开发工具概述
- 1.2 安装IntelliJ IDEA
- 1.3 创建项目和模块
- - 1）创建项目
  - 2）创建模块
  - 3）编写代码
  - 4）运行代码：
- 1.4 IDEA的项目目录
- 1.5 字体设置
- 1.6 IDEA常用快捷键
- 1.7 IDEA修改快捷键
二、数据类型转换
- 2.1 自动转换
- - 2.1.1 转换图解
  - 2.1.2 转换规则
- 2.2 强制转换
- - 2.2.1 转换图解
  - 2.2.2 注意事项
三、运算符
- 3.1 算术运算符
- - 3.1.1 基本运算
  - 3.1.2 ++和--
  - 3.1.3 +=运算
  - 3.1.4 字符串注意事项
  - 3.1.5 常量和变量的运算
- 3.2 赋值运算符
- 3.3 比较运算符
- 3.4 逻辑运算符
- 3.5 三元运算符
四、方法
- 4.1 方法概述
- 4.2 方法的简单使用
- - 4.2.1 方法的定义
  - 4.2.2 方法的调用
  - 4.2.3 调用练习
  - 4.2.4 注意事项
- 4.3 方法使用进阶
- - 4.3.1 方法的参数列表和返回值
  - 4.3.2 调用方法的三种形式
  - 4.3.3 方法的重载
  - 4.3.4 方法重载练习
  - - 练习一
    - 练习二
记得点赞~！！！

上一篇：01【计算机基础、Java概述】

下一篇：03【流程控制、JVM内存、数组】

02【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等少数语言。

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

1.2 安装IntelliJ IDEA

参考IntellIJ IDEA安装和破解手册

1.3 创建项目和模块

1）创建项目

1）点击Create New Project：

2）创建一个空项目

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

3）选择磁盘路径：

4）finish：

2）创建模块

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

2）创建一个Java模块：

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

4）模块创建成功：

5）目录介绍：

3）编写代码

编写HelloWorld代码：

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

4）运行代码：

查看控制台输出：

1.4 IDEA的项目目录

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

1.5 字体设置

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

1.6 IDEA常用快捷键

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

1.7 IDEA修改快捷键

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

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

2）添加Alt+/快捷键：

二、数据类型转换

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 类型。

同样道理，当一个 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个字节空间。

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 算术运算符

算术运算符
`+`	加法运算，字符串连接运算
`-`	减法运算
`*`	乘法运算
`/`	除法运算
`%`	取模运算，两个数字相除取余数
`++、--`	自增自减运算

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);          //2System.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);      //2System.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 赋值运算符

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

赋值运算符
`=`	赋值
`+=`	加后赋值
`-=`	减后赋值
`*=`	乘后赋值
`/=`	除后赋值
`%=`	取模后赋值

/*** @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 。

比较运算符：
`==`	比较符号两边数据是否相等，相等结果是true。
`<`	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
`>`	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
`<=`	比较符号左边的数据是否小于或者等于右边的数据，如果小于或等于结果是true。
`>=`	比较符号左边的数据是否大于或者等于右边的数据，如果小于或等于结果是true。
`!=`	不等于符号，如果符号两边的数据不相等，结果是true。

/*** @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

运算符	运算规则	示例	结果
`&`	与（有假为假）	false&true	false
`	`	或（有真为真）	false\|true
`^`	异或（相同为false，不同为true）	false^true	true
`!`	非（取反，true为false，false为trie）	!true	false
`&&`	短路与（和`&`一样，前面条件为false不执行后面的，效率高）	false&&true	false
`		`	短路或（和`

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

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

三元运算符计算方式：

布尔类型表达式结果是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;}
}

方法信息详解：

方法调用详解：

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数的最大值功能是一样的，其意思也差不多；如果定义不同的方法名使用起来不方便，我们给方法命名最好能够见名知意；这个时候我们就希望定义成一样的名称，就是方法的重载；

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

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){}

上一篇：01【计算机基础、Java概述】

下一篇：03【流程控制、JVM内存、数组】

记得点赞~！！！