【Java基础】DAY4

推荐阅读：

• 【Java基础】DAY1
• 【Java基础】DAY2
• 【Java基础】DAY3
• 【Java基础】DAY4
• 【Java基础】DAY5
• 【Java基础】DAY6
• 【Java基础】DAY7
• 【Java基础】DAY8
• 【Java基础】DAY9
• 【Java基础】DAY10
• 【Java基础】DAY11

DAY4

1、IDEA

Integrated Development Environment，IDE，集成开发环境

开发Java程序的步骤：
1、编写代码
2、启动cmd
3、调用javac编译
4、调用java运行

集成开发环境，是一种专门用来提高Java开发效率的软件。

免费的IDE当中：Eclipse

收费的IDE当中：IntelliJ IDEA

免费+收费所有的IDE当中：全世界用得最多的就是IntelliJ IDEA

psvm

public static void main(String[] args) {
    
}

sout

System.out.println();

常用设置

File→Settings

字体设置

Editor→Font

快捷键设置

数据库

Keymap→Tool Windows→Database Ctrl+8

代码补全

Main menu→Code→Completion→Basic Alt+/

代码模板

Template	IntelliJ IDEA
Define a main method	psvm
Iterate over an array	itar
Iterate over a collection	itco
Iterate over a list	itli
Iterate over an iterable using foreach syntax	iter
Print to System.out	sout
Print to System.err	serr
Define a static field	psf

2、项目结构

Create New Project

New Module

New Package

3、IDEA常用快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码
Ctrl+Y	删除光标所在行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L	格式化代码
Ctrl+/	单行注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释
Alt+Ins	自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头	移动当前代码行
shift + F6	选中修改对象

4、复习一下嵌套循环

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

5、方法的定义与调用

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

方法好比是一个工厂。
蒙牛工厂 原料： 奶牛、饲料、水
产出物： 奶制品

钢铁工厂 原料：铁矿石、煤炭
产出物：钢铁建材

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

定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，……）{
方法体
return 返回值；
}

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

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

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

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

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

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);
    System.out.println("变量的值为：" + number);
}

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

6、有参与无参

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

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

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

7、练习题1

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

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

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

8、练习题2

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

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

    /*
    三要素：
    返回值类型： 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 same;

        return a == b;
    }

9、练习题3

题目要求：
定义一个方法，用来求出1-100之间所有数字的和值。

public static void main(String[] args) {
    System.out.println("结果是：" + getSum());
}

/*
三要素：
返回值： 有返回值，计算结果时一个int数字
方法名称： getSum
参数列表： 数据范围已经确定，是固定的，所以不需要告诉我任何条件，不需要参数
 */

public static int getSum() {
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    return sum;
}

10、练习题4

题目要求：
定义一个方法，从来打印制定次数的HelloWord。

public static void main(String[] args) {
    printCount(10);
}

/*
三要素
返回值类型： 只是进行一大堆打印操作而已，没有计算，也没有结果要告诉调用处
方法名称： printCount
参数列表： 到底要打印多少次？必须告诉我，否则我不知道多少次，没法打印。次数：int
 */
public static void printCount(int num) {
    for (int i = 0; i < num; i++) {
        System.out.println("Hello, World!" + (i+1));
    }
}

11、使用方法的注意事项

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

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

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;
        }
    }

12、方法的重载

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

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

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

方法重载与下列因素无关：
1、与参数的名称无关
2、与方法的返回值类型无关

public static void main(String[] args) {
        System.out.println(sum(10,20));      // 30  两个参数的方法
        System.out.println(sum(10,20,30));     // 60    三个参数的方法
        System.out.println(sum(10,20,30,40));   // 100  四个参数的方法
//        System.out.println(sum(10,20,30,40,50));    // 找不到任何方法来匹配，错误！
    }

    // 参数的多类型顺序不同
    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) {
        return a + b;
    }

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

    // 错误写法！与参数的名称无关
//    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) {
        return a + b + c;
    }

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

13、重载练习一

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

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.print("两个byte值是否相同：");
    boolean same;
    if (a == b) {
        same = true;
    } else {
        same = false;
    }
    return same;
}

public static boolean isSame(short a, short b) {
    System.out.print("两个short值是否相同：");
    boolean same = a == b ? true : false;
    return same;
}

public static boolean isSame(int a, int b) {
    System.out.print("两个int值是否相同：");
    return a == b;
}

public static boolean isSame(long a, long b) {
    System.out.print("两个long值是否相同：");
    if (a == b) {
        return true;
    } else {
        return false;
    }
}

14、重载练习二

判断哪些方法时重载关系

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){}  // 代码错误，与第三个冲突

15、重载练习三

byte short int long float double char boolean
String
在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载方式。

public static void main(String[] args) {
    myPrint(100);
    myPrint("Hello");
}

public static void myPrint(byte num) {
    System.out.println(num);
}

public static void myPrint(short num) {
    System.out.println(num);
}

public static void myPrint(int num) {
    System.out.println(num);
}

public static void myPrint(long num) {
    System.out.println(num);
}

public static void myPrint(float num) {
    System.out.println(num);
}

public static void myPrint(double num) {
    System.out.println(num);
}

public static void myPrint(char zifu) {
    System.out.println(zifu);
}

public static void myPrint(boolean is) {
    System.out.println(is);
}

public static void myPrint(String str) {
    System.out.println(str);
}