Java基础（第三期）：package管理类文件 && 关系和逻辑运算符 && 逻辑中断 && 三元运算符 && 函数方法的定义和使用 &&方法传参返回值 && 方法重载

持续更新中…
Java基础专栏：
Java基础：第一期
Java基础：第二期
Java基础第三期（当前）

Java基础（第三期）

一、package管理类文件

1、什么是package

在Java中，package（包）是用于组织和管理类和接口的一种机制。它可以将相关的类和接口组织在一起，并提供了命名空间的概念，以避免命名冲突。

包通过在源代码中使用package关键字来定义。一个Java源文件在开始时可以指定所属的包。例如，下面是定义一个包的示例：

java复制代码package com.example.mypackage;

这个包声明将把该源文件放置在com.example.mypackage包中。

包的优点包括：

• 组织性：包可以按照功能或领域对类进行分组，使代码更加有条理和易于维护。
• 封装性：包可以定义访问权限限制，控制类和接口对外部代码的可见性。
• 避免命名冲突：包提供了命名空间，避免不同包中的类和接口之间的命名冲突。
• 代码重用：通过导入其他包中的类和接口，可以实现代码的重用。

当深入学习后会使用到下面的方法：

要使用一个包中的类或接口，需要使用import语句将其引入到当前的源文件中。例如：

java复制代码import com.example.mypackage.MyClass;

这样可以在当前源文件中使用MyClass类。

总而言之，包是Java中用于组织和管理类和接口的一种机制，它提供了命名空间和封装性，并有助于代码的组织和重用。

1.1 如何创建包

第一步：

我们右击项目目录中模块里面的src文件夹，选择新建 → 软件包：

第二步：输入包的名：

说明：

包名为com.liujintao.test是一个符合Java命名规范的包名。但通常在实际开发中，包名的选择是基于以下原则：

1. 域名反转：com代表商业组织，liujintao可能是公司名、个人名或项目名。test可能表示这个包用于测试相关的代码。
2. 层次结构：包名通常根据层次结构来组织，并且可以反映出类所属的层次关系。例如，com.liujintao.test中的com大概率是顶级域名，liujintao可能是公司名、个人名或项目名，而test可能表示该包中包含一些用于测试的类或方法。

需要注意的是，包名的含义是根据开发者自己的需求和约定而确定的，并没有固定的规定。因此，具体的含义需要由包的作者或开发团队来解释。

第三步：回车，“取消复选框的勾选” → 点击重构 就完成了

• 以上就是创建包的方法，存放不同的class类文件。注意根据自己的需求来（符合规范）

二、赋值运算符

2.1拓展运算符的概念和拓展注意事项

    一、赋值运算符：
        1、基本的赋值运算符：
            = ： 将等号右边的给等号左边的

        2、拓展运算符：
            +=： 将符号左右两边的数据，做加法运算后，将结果赋值给左边的
            -=： 将符号左右两边的数据，做减法运算后，将结果赋值给左边的
            *-： 将符号左右两边的数据，做乘法运算后，将结果赋值给左边的
            /=:  将符号左右两边的数据，做除法运算后，将结果赋值给左边的
            %=:  将符号左右两边的数据，做取模运算后，将结果赋值给左边的

------------------------------------我是分割线------------------------------------------------
        二、拓展运算符的细节补充：
            1、下面代码报错：
            short x = 1;
            x = x + 1;

            2、下面代码不报错：
            short x = 1;
            x += 1;
    
            原因：
                第一个代码，由于byte 、short、char在做运算的时候，会自动转为int整数类型，然后你赋值给short，肯能报错
    
                第二个代码；由于是拓展运算符，内部会自动默认帮我们强制转换数据类型（刚好也是上面的解决方案）

2.2代码示例

package com.liujintao.operator;
public class OperatorDome1 {

    public static void main(String[] args) {
        // 1、+= ：将符号左右两边的数据，做加法运算后，将结果赋值给左边的
        int num = 10;
        num += 20;
        System.out.println(num); // 输出结果为： 30

        // 2、-= ：将符号左右两边的数据，做减法运算后，将结果赋值给左边的
        int num1 = 20;
        num1 -= 10;
        System.out.println(num1); // 输出结果为：10

        // 3、*=：将符号左右两边的数据，做乘法运算后，将结果赋值给左边的
        int num2 = 10;
        num2 *= 10;
        System.out.println(num2); // 输出结果为：100

        // 4、/=：将符号左右两边的数据，做除法运算后，将结果赋值给左边的

        int num3 = 100;
        num3 /= 10;
        System.out.println(num3); // 输出结果为：10

        // 5、%=:  将符号左右两边的数据，做取模运算后，将结果赋值给左边的
        int num4 = 24;
        num4 %= 5;
        System.out.println(num4); // 输出结果为：4


        // 二、细节拓展问题:

        short x = 1;
        x = (short)(x + 1);
        System.out.println(x);

        short x1 = 1;
        x1 += 1;
        System.out.println(x1);

        // 如下代码：看得出原因吗？
        double z = 24.8;
        int y = 10;
        y += z;
        System.out.println(y); // 输出结果为：34
        // 原因：抓住拓展运算符默认自动强转类型，所以，赋值给 int 类型的y  结果强转后为：34
    }}

·切记不要忘记：除了 = 外：的拓展赋值运算符外，所有的运算都会自动帮我们强制转换数据类类型

普通的运算：

​ java

 short x = 1;
 x = (short)(x + 1);
 System.out.println(x);
// 需要自动强转

拓展的运算：

short x1 = 1;
x1 += 1;
System.out.println(x1);
// 内置强转，自动转换

☢ 这就是最需要注意的地方

三、关系运算符和比较运算符

3.1 关系运算符

如下图所列：

/*
    一、 关系运算符（比较运算符）：
            注意事项： 关系运算符的结果都是 boolean 类型，要么是 true  要么是 false，一定要区分 ==  和 =。
 */

3.1 .1代码示例

package com.liujintao.operator;
public class OperatorDemo2 {
    public static void main(String[] args) {
        System.out.println(10 > 20); // false
        System.out.println(10 >= 20); // false
        System.out.println(10 < 20); // true
        System.out.println(10 <= 20); //true
        System.out.println(10 == 20); // false
        System.out.println(10 != 20); // true
    }
}

3.2 逻辑运算符

3.2.1 java中的逻辑运算符的分类

符号	介绍	说明
&	逻辑与	并且，遇false则false
|	逻辑或	或者：遇 true 则 true
！	逻辑非	取反
^	逻辑异或	相同为 false ，不同为 true

​ 二、 逻辑运算符:
​ 1、作用：就是用来连接 布尔类型 的“表达式”，或者是值。
​ 2、应用场景：逻辑运算符，可以用来整合多个条件，为一个整体的逻辑。

3.2.2 逻辑与：

• 应用场景：范围性判断查找

package com.liujintao.operator;
public class OperatorDemo3 {
    public static void main(String[] args) {
    System.out.println(true & true); // true
    System.out.println(true & false); // false
    System.out.println(false & true); // false
    System.out.println(false & false); // false
        
    }
}

总结：逻辑与 & ： （并且的含义） 遇见false ，返回的就是false

3.2.3 逻辑或：

• 应用场景： 多个条件任选其一

package com.liujintao.operator;
    public static void main(String[] args) {
            System.out.println(true | true); // true
            System.out.println(true | false); // true
            System.out.println(false |  true); // true
            System.out.println(false |  false); // false
       
        }
}

总结； 逻辑或 | ：有true 则 true，全部为 false 则为 false

3.2…3 逻辑非：

• 应用场景：对一段逻辑整体做取反操作

package com.liujintao.operator;
        public static void main(String[] args) {
            System.out.println(!true); // false
            System.out.println(!false); // true
            
        }
}

总结： 逻辑非 ！ ：就是对其进行取反

3.2.4 逻辑异或：

• 应用场景：（用的比较少，判断是否为同类或者不同类）

package com.liujintao.operator;
            public static void main(String[] args) {
                    System.out.println(true ^ true); // false
                    System.out.println(true ^ false); // true
                    System.out.println(false ^ true); // true
                    System.out.println(false ^ false); // false
            }
}

总结：逻辑异或 ^: 相同的为：false， 不同的为： true

3.3 短路逻辑逻辑运算符（逻辑中断）

短路逻辑运算符（逻辑中断）：
      1. 单个 & 和 |：
      		`经过观察： 单个 & 和 | ： 无论左边和右边是否成立：都会进行代码的执行`
				+ 也就是说：单个 &  | ： 是没有短路效果的，不成立依旧是需要执行完毕。


      2. 双个 && 和 ||：
				`1、 && 具有短路效果： 左边为false，右边不在执行。左边为true，右边需要继续执行`

				`2、|| 具有短路效果： 左边为true，右边不在执行。左边为false，右边需要继续执行`

3.3.1 单个 & 和 | 的使用：

package com.liujintao.operator;

public class OpertatorDemo4 {
    public static void main(String[] args) {
        // 单个 &
        int x = 3;
        int y = 4;
        boolean result = ++x > 5 & y-- < 4;
        System.out.println(x); // 运行结果为： 3
        System.out.println(y); // 运行结果为： 4
        System.out.println(result); // 运行结果为： false

        System.out.println("----------------------------------------------");
        // 单个 |
        int a = 3;
        int b = 4;
        boolean result1 = ++a > 5 | b-- < 4;
        System.out.println(a); // 运行结果为：4
        System.out.println(b); // 运行结果为：3
        System.out.println(result1); // 运行结果为：false
    }
}

经过观察： 单个 & 和 | ： 无论左边和右边是否成立：都会进行代码的执行

• 也就是说：单个 & | ： 是没有短路效果的，不成立依旧是需要执行完毕。

3.3.2 成对出现的 && 和 ||

        // 双 &
        int x = 3;
        int y = 4;
        boolean result = ++x > 5 && y-- < 4;
        System.out.println(x); // 运行结果为： 4
        System.out.println(y); // 运行结果为： 4
        System.out.println(result); // 运行结果为： false

        System.out.println("----------------------------------------------");
        // 双 |
        int a = 3;
        int b = 4;
        boolean result1 = ++a > 5 || b-- < 4;
        System.out.println(a); // 运行结果为：4
        System.out.println(b); // 运行结果为：3
        System.out.println(result1); // 运行结果为：false

经过发现：

1、 && 具有短路效果： 左边为false，右边不在执行。左边为true，右边需要继续执行

2、|| 具有短路效果： 左边为true，右边不在执行。左边为false，右边需要继续执行

• 注意： 在实际使用的时候：用的最多的还是 && || !

四、三元运算符 && 运算符优先级

4.1 三元运算符语法格式：

判断条件 ？ 值1 ： 值2;

执行流程 :

  		1. 首先计算判断条件的值
  		1. 其次如果值为`true`，值1就是运算结果
  		1. 最后如果值为`false`， 值2就是运算结果

• 总结，根据判断条件，从两份数据中二者选其一

4.2 求最大值小练习

需求：键盘输入三个整数数字，求出最大值；

package com.liujintao.test;

// 1、导入Scanner模块（类）
import java.util.Scanner;
public class OperatorTest1 {
    /*
        需求： 键盘输入三个整数，求出最大值并打印在控制台
     */
    public static void main(String[] args) {


        // 2、通过Scanner类，创建实例对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入三个整数：");
        // 3、使用实例对象，获取输入的内容
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        int num3 = sc.nextInt();
        // 4、先计算出其中两个的最大值，然后再和第三个数字比较（得出最大值）
        int tempMax = num1 > num2 ? num1 : num2;
        int max = tempMax > num3 ? tempMax : num3;
        // 5、输出打印
        System.out.println("三个整数中最大值为：" + max);
    }
}

输出结果：

请输入三个整数：
10
20
30
三个整数中最大值为：30

• 如果是求最小值的话，直接将符号改变就可以了。

4.3 运算符优先级

• 只要记住 小括号 就可以了，括起来就是他最高。

五、方法的基本定义和使用

• 提前说一下，直接学习函数方法，更好的去书写规范的代码。

方法：（method） 一般具有独立功能的代码块，不调用就不执行。（不知道的就是一个大括号 {}）

方法的好处 ：可以将一部分的代码单独管理，进行分类管理。提高代码的复用性（想用就直接调用）

**注意：**方法与方法之间是平级关系，不允许嵌套定义。

5.1方法的定义

定义格式：

public static void 方法名() {
 // 这里面书写的是方法的内容（执行逻辑）
}

• 方法名：需要注意命名规范，最好做到见名知意。

举个例子：

public static void show() {
 .......
}

5.2 方法的调用

调用格式：

`方法名();`

• 方法名字加个小括号

如下：

`show();`

代码示例

package com.liujintao.method;

public class MethodDemo1 {
    /*
        方法(函数) 的定义和调用：

     */
    public static void main(String[] args) {
        // 2、方法函数一调用，原地返回结果
        eat();
    }

    // 1、平级关系，创建方法
    public static void eat() {
        System.out.println("我想说的是，怕什么，输了失败了，顺其自然就好，前提态度要好！");
    }
}

5.3方法的功能分类管理代码

package com.liujintao.method;

public class MethodDemo1 {
    // 定义 我的方法
    public static void me() {

        System.out.println("点菜");
        System.out.println("吃菜");
    }

    // 这是main方法（主函数方法）
    public static void main(String[] args) {
        farmer();
        cook();
        me();
    }

    // 定义农民方法
    public static void farmer() {
        System.out.println("除草");
        System.out.println("耕地");
        System.out.println("插秧");
        System.out.println("浇水");
        System.out.println("收割");
    }

    // 定义厨师方法
    public static void cook() {
        System.out.println("买菜");
        System.out.println("切菜");
        System.out.println("炒菜");
    }
}

这样使用，修改bug能够清楚管理的区域。

• 复用性：可以实现多调用方法，这是可行的。

注意： 方法的执行顺序取决于调用的顺序，和定义的位置没有关系

5.4小练习：

需求：定义一个方法，方法中定义两个整数变量，求出最大值并打印在控制台。

package com.liujintao.test;

import java.util.Scanner;
public class MethodTest {
    public static void main(String[] args) {
        //2、调用方法
        getMax();
    }

    // 1、定义计算最大值方法
    public static void getMax() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        int max = num1 > num2 ? num1 : num2;
        System.out.println("最大值为：" + max);
    }
}

• 主函数法方法里面：直接调用方法就好了，我们只需要负责定义方法！

5.5 方法调用的内存问题

方法的两个阶段：

待命：（方法区）

执行：（栈内存）

• 方法没有被调用的时候，在方法区中的字节码文件中存放。
• 方法被调用的时候，需要进入到栈内存中运行。

注意：源文件里面有的，字节码里面都有

• 主方法被虚拟机自动调用

• 方法被执行栈调用

看图理解：

图解说明：

1. 当我们代码编写完毕后，所有的方法都是放在方法区里面的字节码文件中。
2. 当我们执行代码的时候，我们的主函数（方法）会被虚拟机自动调用，然后再我们的执行栈中执行。
3. 主方法里面的逻辑代码，包括我们自己定义的方法此时会被执行栈调用。
4. 执行完后将会出栈，就先弹夹一样，用一个就空一个位置。
5. 直到主方法里面的所有逻辑代码执行完毕，结束程序。

看看下面的方法代码执行流程：

就好比于编译完，所有的方法都放在任务队列中，按照执行的顺序排队，然后我们的执行栈会根据顺序调用我们任务队列（方法区）中的方法。直到任务队列中没有了需要执行的方法，此时执行栈也就结束了任务了。

六、带参数的方法和方法的返回值

6.1带参数的方法定义格式

public static viod getNUm(数据类型 变量名1， 数据类型 变量名2) {
 // 方法体
}

// 调用传递变量参数
getNUm(数据1， 数据2);

形参：形式参数，在定义方法的时候，所声明的参数。

实参：实际参数，调用方法的时候，所传入的参数。

package com.liujintao.test;
public class MethodTest {
 public static void main(String[] args) {
     // 2、 调用方法：传入参数（实参）
     getMax(10, 20); // 返回结果： 30
 }

 // 1、定义带参数的方法（同时定义形参，接受实参）
 public static void getMax(int num1, int num2) {
     int sum = num1 + num2;
     System.out.println(sum);
 }
}

例如我们使用传参的形式定义两个求最大值和最小值的方法：

package com.liujintao.test;
import java.util.Scanner;
public class MethodTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        // 对应传递参数
        getMin(num1, num2);
        getMax(num1, num2);
    }

    // 定义一个求最小值的方法
    public static void getMin(int x, int y) {
        int min = x > y ? y : x;
        System.out.println("this min ：" + min);
    }


    // 定义一个求最大值的方法
    public static void getMax(int a, int b) {
        int max = a > b ? a : b;
        System.out.println("this max:" + max);
    }


}

执行结果为：

100
200

this min ：100
this max:200

6.2 带返回值的方法

为什么我们需要有带返回值的方法？

因为：
我们经常会根据一个方法产出的结果，来去组织另外一段代码逻辑，为了拿到这个方法的结果，就需要定义带有返回值的方法。

定义格式：

public static 数据类型 方法名(数据类型 变量名1， 数据类型 变量名2， ...) {
 return 数据值（返回值）;
}

• 注意：有返回值了，就不能直接写 void了，需要给定方法的数据类型。
• void：可以理解为他没有返回值。

6.3 代码示例

package com.liujintao.test;
public class MethodTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
       int result = getMax(a, b);
       System.out.println(result); // 返回结果为： 30
    }

    public static int getMax(int x, int y) {
        int max = x > y ? x : y;
        return max;
    }
}

• 注意点：有返回值的，一定需要去接收返回值

七、定义方法的通用格式

定义注意的格式：

1、明确数据类型(没有话直接写 void)

2、确定需要的参数个数

3、注意接收返回值

调用注意的格式：
1、 类型为 void 的话，可以直接调用方法

2、 类型为非 void 类型的话，推荐使用变量接收（类型需注意）

通过伪代码：最直观的体现出来：

    // 1、厨师在厨房，等待老板指挥
    public static 盘子 厨师(米, 油, 菜) {
        盘子 p = 米 + 油 + 菜;
        return p
    }
    // 2、拿好盘子和材料，叫厨师帮我炒菜！
    盘子 p = 厨师(镉大米, 地沟油, 烂白菜);

	// 3、端盘子上桌吃饭
	System.out.println("这饭店没点实力，真开不起来！")

实际参数：是厨师所需要的材料

形式参数：是厨师得到的材料

7.2 方法练习

看完上面的伪代码。我们在看下面的练习(能够掌握，那就证明函数方法学习的非常棒了)

需求1、设计一个方法，计算出三个小数的最大值

/**
 * 需求：设计一个方法，计算出三个小数的最大值
 * */
package com.liujintao.test;
//  1、 导入Scanner类
import java.util.Scanner;
public class MethodTest {
    public static void main(String[] args) {
        // 2、通过导入的 Scaner 创建实例对象
        Scanner sc = new Scanner(System.in);
        // 3、 通过实例对象，获取键盘输入的内容 (注意是小数类型)
        double num1 = sc.nextDouble();
        double num2 = sc.nextDouble();
        double num3 = sc.nextDouble();

        // 5、调用方法，让它帮我们实现求最大值的需求：
        double result = getMax(num1, num2, num3);

        // 6、 输出我们需要求的最小数
        System.out.println("最大的小数为：" + result);
        /*
            输出结果为：
                12.1
                12.2
                12.3
                最大的小数为：12.3
         */

    }

    // 4、 定义求最大值的方法
    public static double getMax(double x, double y, double z) {
        double tempMax = x > y ? x : y;
        double max = tempMax > z ? tempMax : z;
        return max;
    }
}

需求2、设计一个方法，计算出2个整数的和

/**
 * 需求：设计一个方法，计算出2个整数的和
 * */
package com.liujintao.test;
import java.util.Scanner;
public class MethodTest {
    public static void main(String[] args) {
        // 上面的代码块已经有详细说明了，这里就不重复写；
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数：");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();

        // 调用方法
        int result = getSum(num1, num2);
        System.out.println("两个整数的和为：" + result);

        /*
            运行结果为：
                10
                20
                两个整数的和为：30
         */
    }

    // 定义需求所需要的方法；
    public static int getSum(int x, int y) {
        int sum = x + y;
        return sum;
    }
}

7.2关于方法常见问题

1、当方法的类型为 void 的时候，就没必要书写return了。

2、 要写的话 直接为空 return;，不要写具体返回的内容就行

3、没有返回值，写return直接报错

4、当方法中，遇到 return ，直接结束方法，写到return后面，直接报错啦。

八、方法重载

8.1 什么是方法重载呢？

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。 调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。 方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数或参数的顺序不同的方法。

• 调用方法的时候，java虚拟机会自动的帮我们匹配相应参数的方法

• 简单记

1、同一个类中，方法名不同，参数不同的方法

2、个数不同，类型不同，顺序不同

• 判断是否方法重载：只看方法名和参数，和返回值无关

package com.liujintao.overload;
    /*
        方法重载：
            在一个类中定义多个同名不同参数的方法
            调用方法的时候，java虚拟机会自动的帮我们匹配相应参数的方法
            只看方法名和参数个数，和返回值无关。
     */
public class OverloadDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int z = 30;
        handleAdd(x, y, z);  // 此时调用形参为三个的那个方法
        handleAdd(x, y);  // 此时调用形参为二个的那个方法
    }

    public static void handleAdd(int a, int b) {
        System.out.println("is two");
    }
    public static void handleAdd(int a, int b, int c) {
        System.out.println("is three");
    }
}

• 参数类型不同、个数不同、方法名相同、顺序位置不同（方法重载）

8.2 方法重载的好处

• 不需要写多个方法名，可以重复使用

按住对内置的方法按住 Ctrl + 左键 查看 java源代码。就知道了，内部也是使用了方法重载。

到此：Java基础（第三期）的内容就到此结束，下期再见！
java基础：第二期