第一章开发工具IntelliJ IDEA

1.0 为什么要用IDE

集成开发环境(Integrated Development Environment, IDE)，是一种专门用来提高开发效率的软件。
对于JAVA来说：
免费的IDE当中：Eclipse
收费的IDE当中：IntelliJ IDEA
免费+收费所有的IDE当中：全世界用得最多的就是 IntelliJ IDEA

IDEA 中： Project > Module > Package

1.1 开发工具概述

IDEA是一个专门针对Java的集成开发工具(IDE)，由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。它可以极大地提升我们的开发效率。可以自动编译，检查错误。在公司中，目前IDEA使用率最高。

1.2 IDEA软件安装

此软件集成了32位和64位，Java9之后不再支持 32位的JDK，注意选择位数。

1.3 IDEA首次驱动

首次新建项目时，默认的Project Location路径有问题，如 c:\xxx ，正确写法为 c:\xxx 。更改后不会再出现此类问题。

此问题是 IDEA2017存在的，未验证最细新版是否还存在此问题。

1.4 创建包和类

包名: com.itheima.demo，表示创建了多级的文件夹(一个点分隔一级)。

小贴士：所谓包，就是文件夹，用来对类文件进行管理。

1.5 字体设置

点击菜单栏上的 File->Settings->Editor->Font 修改字体，可对 size 进行修改。

1.6 IDEA的项目目录

创建的项目目录中

.idea 目录和 demo.iml 和我们开发无关，是IDEA工具自己使用的
out 目录是存储编译后的.class文件
src 目录是存储我们编写的.java源文件

1.7 IDEA常用快捷键

操作	快捷键
导入包，自动修正代码	Alt+Enter
删除光标所在行	Ctrl+Y
复制光标所在行的内容，插入光标位置下面	Ctrl+D
格式化代码	Ctrl+Alt+L
提示补全 (Class Name Completion)	alt+/
单行注释	ctrl + /
多行注释	ctrl + shift + /
收起所有的方法(collapse all)	ctrl + shift + 减号
打开所有方法(expand all)	ctrl + shift + =
查找方法在哪里被调用(Call Hierarchy)	ctrl+shift+h
查看类的继承结构图(Show UML Diagram)	ctrl + shift + u
查看方法的多层重写结构(method hierarchy)	ctrl+alt+h

1.8 IDEA修改快捷键

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

1.9 IDEA导入和关闭项目

关闭IDEA中已经存在的项目， File->Close Project 这时IDEA回到了刚启动界面，点击项目上的 X ，IDEA中就没有这个项目了。
在IDEA的启动界面上，点击 OPEN ，选择项目目录即可。

若想通过IDEA同时开启多个项目，点击OPEN打开项目时，点击New Window按钮

导入 module 在 project structure 里面导入。

第二章方法

2.1 回顾--方法的定义和调用

前面的课程中，将方法定义为 void ，没有返回值。在主方法 main 中直接被调用。

public class Method_Demo1 {
    public static void main(String[] args) {
        print();
    } 
    private static void print() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print("*");
            } 
            System.out.println();
        }
    }
}

print 方法被 main 方法调用后直接输出结果，而 main 方法并不需要 print 方法的执行结果，所以被定义为 void 。

2.2 定义方法的格式详解

修饰符 返回值类型 方法名(参数列表){
    //代码省略...
    return 结果;
}

修饰符： public static 等，很多种。
返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

小贴士：return 结果; 这里的"结果"在开发中，我们正确的叫法成为方法的返回值

2.3 定义方法的两个明确

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

public class Method_Demo2 {
    public static void main(String[] args) {
        // 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数
        // 并接收方法计算后的结果，返回值
        int sum = getSum(5, 6);
        System.out.println(sum);
    } /
    * 定义
    计算两个整数和的方法
    返回值类型，计算结果是int
    参数：不确定数据求和，定义int参数.参数又称为形式参数
    */
    public static int getSum(int a, int b) {
        return a + b;
    }
}

2.4 定义方法的注意事项

定义位置，类中方法外面。
返回值类型，必须要和 return 语句返回的类型相同，否则编译失败。
不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。

2.5 调用方法的三种形式

直接调用：直接写方法名调用
赋值调用：调用方法，在方法前面定义变量，接收方法返回值
输出语句调用：在输出语句中调用方法， System.out.println(方法名())

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

2.6 调用方法的流程图解

graph LR
方法开始调用-->实际参数传递
实际参数传递-->方法体内执行
方法体内执行-->方法结束返回

总结性方法

/*
方法其实就是若干语句的功能集合。

参数（原料）：就是进入方法的数据。
返回值（产出物）：就是从方法中出来的数据。

定义方法的完整格式：
修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
    方法体
    return 返回值;
}

修饰符：现阶段的固定写法，public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
PS：参数如果有多个，使用逗号进行分隔
方法体：方法需要做的事情，若干行代码
return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。

定义一个两个int数字相加的方法。三要素：
返回值类型：int
方法名称：sum
参数列表：int a, int b

方法的三种调用格式。
1. 单独调用：方法名称(参数);
2. 打印调用：System.out.println(方法名称(参数));
3. 赋值调用：数据类型 变量名称 = 方法名称(参数);

注意：此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。
*/
public class Demo02MethodDefine {

    public static void main(String[] args) {
        // 单独调用 有返回值的方法可以单独调用，无须考虑返回值问题。
        sum(10, 20);
        System.out.println("===========");

        // 打印调用
        System.out.println(sum(10, 20)); // 30
        System.out.println("===========");

        // 赋值调用
        int number = sum(15, 25);
        number += 100;
        System.out.println("变量的值：" + number); // 140
    }

    public static int sum(int a, int b) {
        System.out.println("方法执行啦！");
        int result = a + b;
        return result;
    }

}

/*
有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
例如两个数字相加，必须知道两个数字是各自多少，才能相加。

无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
例如定义一个方法，打印固定10次HelloWorld。
 */
public class Demo03MethodParam {

    public static void main(String[] args) {
        method1(10, 20);
        System.out.println("==============");
        method2();
    }

    // 两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算
    // 有参数
    public static void method1(int a, int b) {
        int result = a * b;
        System.out.println("结果是：" + result);
    }

    // 例如打印输出固定10次文本字符串
    public static void method2() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello, World!" + i);
        }
    }

}

/*
题目要求：定义一个方法，用来【求出】两个数字之和。（你帮我算，算完之后把结果告诉我。）
题目变形：定义一个方法，用来【打印】两个数字之和。（你来计算，算完之后你自己负责显示结果，不用告诉我。）

注意事项：
对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
 */
public class Demo04MethodReturn {

    public static void main(String[] args) {
        // 我是main方法，我来调用你。
        // 我调用你，你来帮我计算一下，算完了之后，把结果告诉我的num变量
        int num = getSum(10, 20);
        System.out.println("返回值是：" + num);
        System.out.println("==============");

        printSum(100, 200);
        System.out.println("==============");

        System.out.println(getSum(2, 3)); // 正确写法
        getSum(3, 5); // 正确写法，但是返回值没有用到
        System.out.println("==============");

        // 对于void没有返回值的方法，只能单独，不能打印或者赋值
        // System.out.println(printSum(2, 3)); // 错误写法！
        // System.out.println(void);
        // int num2 = printSum(10, 20); // 错误写法！
        // int num3 = void;
        // void num4 = void;
    }

    // 我是一个方法，我负责两个数字相加。
    // 我有返回值int，谁调用我，我就把计算结果告诉谁
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }

    // 我是一个方法，我负责两个数字相加。
    // 我没有返回值，不会把结果告诉任何人，而是我自己进行打印输出。
    public static void printSum(int a, int b) {
        int result = a + b;
        System.out.println("结果是：" + result);
    }

}

2.7 定义方法练习

比较两个整数是否相同
分析：定义方法实现功能，需要有两个明确，即返回值和参数列表。
明确返回值：比较整数，比较的结果只有两种可能，相同或不同，因此结果是布尔类型，比较的结果相同为true。
明确参数列表：比较的两个整数不确定，所以默认定义两个int类型的参数。

/*
题目要求：
定义一个方法，用来判断两个数字是否相同。
 */
public class Demo01MethodSame {

    public static void main(String[] args) {
        System.out.println(isSame(10, 20)); // false
        System.out.println(isSame(20, 20)); // true
    }

    /*
    三要素：
    返回值类型：boolean
    方法名称：isSame
    参数列表：int a, int b
     */
    public static boolean isSame(int a, int b) {
        /*boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }*/

        // boolean same = a == b ? true : false;

        // boolean same = a == b;

        return a == b;
    }

}

计算1+2+3...+100的和
分析：定义方法实现功能，需要有两个明确，即返回值和参数。
明确返回值：1~100的求和，计算后必然还是整数，返回值类型是int
明确参数：需求中已知到计算的数据，没有未知的数据，不定义参数

public class Method_Demo4 {
    public static void main(String[] args) {
        //调用方法getSum
        //并接收方法计算后的结果，整数
        int sum = getSum();
        System.out.println(sum);
    } /
    *
    定义计算1~100的求和方法
    返回值类型，计算结果整数int
    参数：没有不确定数据
    */
    public static int getSum() {
        //定义变量保存求和
        int sum = 0;
        //从1开始循环，到100结束
        for (int i = 1; i <= 100; i++) {
            sum = sum + i;
        } 
        return sum;
    }
}

实现不定次数打印
分析：定义方法实现功能，需要有两个明确，即返回值和参数。
明确返回值：方法中打印出 HelloWorld 即可，没有计算结果，返回值类型 void。
明确参数：打印几次不清楚，参数定义一个整型参数。

public class Method_Demo5 {
    public static void main(String[] args) {
        //调用方法printHelloWorld，传递整数
        printHelloWorld(9);
    } 
    /* 定义
    打印HelloWorld方法
    返回值类型，计算没有结果 void
    参数：不确定打印几次
    */
    public static void printHelloWorld(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("HelloWorld");
        }
    }
}

使用方法的注意事项

/*
使用方法的时候，注意事项：

1. 方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
2. 方法定义的前后顺序无所谓。
3. 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
4. 如果方法有返回值，那么必须写上“return 返回值;”，不能没有。
5. return后面的返回值数据，必须和方法的返回值类型，对应起来。
6. 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
7. 对于void方法当中最后一行的return可以省略不写。
8. 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
 */
public class Demo04MethodNotice {

    public static int method1() {
        return 10;
    }

    public static void method2() {
        // return 10; // 错误的写法！方法没有返回值，return后面就不能写返回值。
        return; // 没有返回值，只是结束方法的执行而已。
    }

    public static void method3() {
        System.out.println("AAA");
        System.out.println("BBB");
        // return; // 最后一行的return可以省略不写。
    }

    public static int getMax(int a, int b) {
        /*int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;*/

        if (a > b) {
            return a;
        } else {
            return b;
        }
    }

}

2.8 方法重载 (OverLoad) ★

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

/*
对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：
1. 参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同

方法重载与下列因素无关：
1. 与参数的名称无关
2. 与方法的返回值类型无关
 */
public class Demo01MethodOverload {

    public static void main(String[] args) {
        /*System.out.println(sumTwo(10, 20)); // 30
        System.out.println(sumThree(10, 20, 30)); // 60
        System.out.println(sumFour(10, 20, 30, 40)); // 100*/

        System.out.println(sum(10, 20)); // 两个参数的方法
        System.out.println(sum(10, 20, 30)); // 三个参数的方法
        System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
        // System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！

        sum(10, 20);
    }

    public static int sum(int a, double b) {
        return (int) (a + b);
    }

    public static int sum(double a, int b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数的方法执行！");
        return a + b;
    }

    // 错误写法！与方法的返回值类型无关
    // public static double sum(int a, int b) {
    //      return a + b + 0.0;
    // }

    // 错误写法！与参数的名称无关
    // public static int sum(int x, int y) {
    //      return x + y;
    // }

    public static int sum(double a, double b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个参数的方法执行！");
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        System.out.println("有4个参数的方法执行！");
        return a + b + c + d;
    }

}

2.9 方法重载练习

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

public class Demo02MethodOverloadSame {

    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));

        System.out.println(isSame((short) 20, (short) 20));

        System.out.println(isSame(11, 12));

        System.out.println(isSame(10L, 10L));
    }

    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数的方法执行！");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }

    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数的方法执行！");
        boolean same = a == b ? true : false;
        return same;
    }

    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数的方法执行！");
        return a == b;
    }

    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数的方法执行！");
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }

}

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

public static void open(){}  √
public static void open(int a){} √
static void open(int a,int b){} × 和第8行冲突
public static void open(double a,int b){}  √
public static void open(int a,double b){} × 和第6行冲突
public void open(int i,double d){} × 和第5行冲突
public static void OPEN(){} × 名称不同，不是有效重载
public static void open(int i,int j){} × 和第8行冲突

模拟输出语句中的 println 方法效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法名
println

Java基础 04 IDEA、方法

第一章开发工具IntelliJ IDEA

1.0 为什么要用IDE

1.1 开发工具概述

1.2 IDEA软件安装

1.3 IDEA首次驱动

1.4 创建包和类

1.5 字体设置

1.6 IDEA的项目目录

1.7 IDEA常用快捷键

1.8 IDEA修改快捷键

1.9 IDEA导入和关闭项目

第二章方法

2.1 回顾--方法的定义和调用

2.2 定义方法的格式详解

2.3 定义方法的两个明确

2.4 定义方法的注意事项

2.5 调用方法的三种形式

2.6 调用方法的流程图解

2.7 定义方法练习

2.8 方法重载 (OverLoad) ★

2.9 方法重载练习

猜你喜欢

Java基础 04 IDEA、方法

第一章 开发工具IntelliJ IDEA

1.0 为什么要用IDE

1.1 开发工具概述

1.2 IDEA软件安装

1.3 IDEA首次驱动

1.4 创建包和类

1.5 字体设置

1.6 IDEA的项目目录

1.7 IDEA常用快捷键

1.8 IDEA修改快捷键

1.9 IDEA导入和关闭项目

第二章 方法

2.1 回顾--方法的定义和调用

2.2 定义方法的格式详解

2.3 定义方法的两个明确

2.4 定义方法的注意事项

2.5 调用方法的三种形式

2.6 调用方法的流程图解

2.7 定义方法练习

2.8 方法重载 (OverLoad) ★

2.9 方法重载练习

猜你喜欢

第一章开发工具IntelliJ IDEA

第二章方法