01_04_Java语言入门||01_Java基础语法||day04_IDEA、方法

第一章 开发工具Intellij IDEA

1.1 开发工具概述

1. 集成开发软件（IDE）：是一种专门用来提高Java（软件）开发效率的软件
2. 免费IDE：eclipse
3. 收费IDE：IDEA（使用最多）

1.2 IDEA安装

1. 下载地址:www.jetbrains.com
2. 下载Ultimate

1.3 IDEA项目结构（教学流程）

1. 选Empty project
2. 创建java项目，选JDK位置
3. 创建项目
4. src——>创建包cn.gxw.demo（全小写）

1.4 IDEA的Hello World

1. 创类HelloWorld
2. psvm + space——>main方法
3. sout + space——>输出语句
4. run
5. alt + 4——>弹出run运行框
   注：++.class++文件在项目目录里没有，它只负责++运行++程序，所以不显示

1.5 IDEA的基本配置

1. file->setting
2. 改字体：Editor->Font

1.6 IDEA的常用快捷键

1. ++alt + enter——>自动修复代码（eclipse：alt+/）++
2. ctrl + y——>光标处删除一行
3. ctrl + d——>光标处向下复制所在行内容
4. ctrl + alt + L——>格式化代码（自动对齐所有代码）：（eclipse：shift+ctrl+f）
5. ctrl + /——>单行注释
6. ctrl + shift + /——>多行注释
7. ++alt + Ins(insert)——>自动生成toString，get，set（eclipse：shift+alt+s）++
8. alt + shift + 上下键——>移动++代码行++

• 注：修改快捷键File->Setting->Keymap->Main menu->Code->Completion->Basic

1.6 IDEA项目的关闭打开，模块导入

1. 删除：项目右键Remove Module(模块)
2. 导入：Project Structure->Module->Import Module
3. 导入后：Setup SDK（软件开发工具包）

第二章 方法

2.1 回顾方法定义和调用

1. 简单格式：

定义：
    public static void 方法名称(){
        方法体;
    }
    调用：
    方法名称();
    ------------------------------
    例：
    public static void main(String[] args){
        pointMethod();
    }
    
    public static void pointMethod(){
        for(int i = 0 ; i < 5; i++){
            for(int j = 0; j < 20; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }

• 注： 5.fori——>for循环for(int i = 0; i < 5; i++)
• 注：定义无先后顺序
• 注：不能在一个方法内部再定义一个方法

2.2 方法定义格式

1. 方法：其实就是若干语句功能的集合

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

2. 定义标准格式：

//参数多个用,隔开
    //方法体写的是方法要做的事若干行
    访问修饰符 返回值类型 方法名称（参数类型 参数名称,...）{
        方法体;
        return 返回值;  //功能：停止及值返回给调用处
    }

• 注：return后面的++返回值++，必须和方法名称前面的返回值++类型对应++。
• 方法理解：

• 方法（工厂）——可能会有很多方法
• 奶牛工厂

• 原料：牛奶，饲料，水
• 产出物：奶制品

2.3 方法三种调用格式

1. 单独调用：方法名称（参数）;
2. 打印调用：System.out.println(方法名称(参数)); //先调用方法，方法再返回自己的返回值
3. 赋值调用：数据类型 变量名称 = 方法名称（参数）;

• 注：void不能打印和赋值

2.2 方法流程

1. 调用方法
2. 找到方法
3. 参数传递
4. 执行方法体
5. 带着返回值回到方法的调用处

2.4 对比有参和无参

1. 有参数：小括号当中有内容

• 当一个方法需要一些数据条件，才能完成任务的时候，就是有参数

2. 无参数：小括号当中没有内容

• 当一个方法不需要一些数据条件，能够独立完成，就是无参数

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);
    }
    public static void method2(){
        for (int i = 0; i < 10; i++) {
            System.out.println("HelloWorld!");
        }
    }

2.5 对比有返回值和无返回值

1. 有返回值：++求出++结果

1. 调用方法
2. 找到方法
3. 参数传递
4. 执行方法体
5. 带着返回值回到方法的调用处

2. 无返回值：++打印++结果

1. 调用方法
2. 找到方法
3. 参数传递
4. 执行方法体
5. 直接结束

• 注：有返回值：三种调用方式都可以。无返回值：++只能使用单独调用++。

public static void main(String[] args) {
        int num = getSum(20, 7);
        System.out.println("求和结果：" + num);
        System.out.println("==============");
        printSum(33, 9);
    }

    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.6 方法练习题

1. 定义一个方法，用来判断两个数字是否相同

public static void main(String[] args) {
        System.out.println(isSame(5, 8));   //false
        System.out.println("============");
        System.out.println(isSame(8, 8));   //true
    }

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

1. 求1-100的求和

public static void main(String[] args) {
        System.out.println("1-100求和值：" + getSum());
    }

    /*
    三要素：
    返回值：int
    方法名称：getSum
    参数列表：无(题目数据范围已经确定，所以不需要参数)
     */

    public static int getSum() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {    //注：1-100所以不能i = 0
            sum += i;
        }
        return sum;
    }

1. 定义一个方法，打印指定次数的Hello World

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

    /*
    三要素：
    返回值：void（只是打印操作，没有计算）
    方法名称：printCount
    参数列表：int a(打印次数)
     */
    public static void printCount(int a) {
        for(int i = 0; i < a; i++){
            System.out.println("HelloWorld");
        }
    }

2.7 方法注意事项

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

2.8 方法重载的基本使用（Overload）

1. 对于功能类似的方法来说，因为参数列表不一样，却需要记住不同的方法名称（麻烦）
2. 方法的重载（Overload）

• ++多个方法的名称一样，参数列表不一样++
• 好处：只需要记住一个方法名，就可以实现类似的功能

• 注：方法重载与下列因素相关

• 参数个数不同
• 参数类型不同
• 参数的多类型顺序不同

• 注：方法重载与下列因素无关

• 参数的名称
• 与方法的返回值无关

public static void main(String[] args) {
        System.out.println(sum(1, 4));
        System.out.println(sum(1, 4, 8));
        System.out.println(sum(1, 4, 7, 3));
        //sum(1, 3, 4, 5, 6);   //错
    }

    //两个参数的
    public static int sum(int a, int b) {
        return a + b;
    }
    //public static int sum(int x, int y) { //错：参数的名称无关
    //    return a + b;
    //}

    //三个参数
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
    //public static double 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;
    }
    
    //参数类型不同===============================
    public static int sum(double a, double b) {
        return (int)(a + b);
    }
    
    //参数的多类型顺序不同=======================
    public static int sum(int a, double b) {
        return (int)(a + b);
    }
    public static int sum(double a, int b) {
        return (int)(a + b);
    }

2.9 方法重载练习题

1. 两个类型是否相同（参数类型分别为：byte，short，int，long），在main方法中测试

public static void main(String[] args) {
        byte a = 3;
        byte b = 4;
        System.out.println(isSame(a, b));
        System.out.println("============");
        System.out.println(isSame((short) a, (short) b));
        System.out.println("============");
        System.out.println(isSame(10, 10));
        System.out.println("============");
        System.out.println(isSame(10L, 10L));
    }

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

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

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

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

1. 判断下列哪个是正常的重载关系(方法重载：方法名相同，参数不同)

1. public static void open(){}; //correct（参数不重样）
2. public static void open(int a){}; //correct（参数不重样）
3. static void open(int a, int b){}; //error：与viii冲突（和访问修饰符无关）
4. public static void open(double a, int b){}; //correct（参数不重样）
5. public static void open(int a, double b){}; //error：与vi冲突
6. public void open(int i, double d){}; //error：与v冲突（与static和参数名称无关）
7. public static void OPEN(){}; //correct++但是并不是有效的方法重载++
8. public static void open(int i, int j){}; //error：与iii冲突（和参数名称无关）

2. 实现方法重载的println方法

• 注：shift + f6（用到的地方跟着一起变）

public static void main(String[] args) {
        myPrint(10);
        myPrint('f');
        myPrint("hello");
        myPrint(12.4f);
        myPrint(59L);
    }

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

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

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

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

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

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

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

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

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