文章目录

02【IDEA、数据类型转换、运算符】
一、开发工具IntelliJ IDEA
二、数据类型转换
三、运算符
四、方法
记得点赞~！！！

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

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

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

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

三元运算符计算方式：

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