运算符

算数运算符

1.加减乘除（+、-、*、\）

1.1 实例代码


x
public static void main(String[] args) {
        System.out.println(12 + 30);
        int a = 123;
        int b = 122;
        System.out.println(a - b);      //1
        System.out.println(a * 10);     //1230
        int x = 10;
        int y = 3;
        int result1 = x / y;            //3
        System.out.println(result1);
        int result2 = x % y;            //1 取余数
        System.out.println(result2);
    }
//只保留两位小数：System.out.println(String.format("%.2f", f));

注意事项

一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种


xxxxxxxxxx
//int + double ---> double + double ---> double
public static void main(String[] args) {
        int x = 10;
        double result = x + 2.5;            //12.5
        System.out.println(result);
    }

2.算数运算中“+”常见的三种用法

2.1 第一种

对于数值来说，那就是加法


xxxxxxxxxx
public static void main(String[] args) {
        int a = 123;
        int b = 456;
        int c = a + b;
        System.out.println(c);      //579
    }

2.2 第二种

对于char类型来说，在计算之前，char会被提升成为int，然后再计算。char类型字符和int类型字符，之间对照关系表：ASCII、Unicode


xxxxxxxxxx
    public static void main(String[] args) {
        char a = 'A';
        char b = 'C';
        int c = a + b;
        System.out.println(c);      //132
    }

2.3 第三种

对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作


xxxxxxxxxx
    public static void main(String[] args) {
        String a = "A";
        String b = "C";
        String c = a + b;
        System.out.println(c);      //AC
        System.out.println(a + 123);//A123
    }

优先级问题


xxxxxxxxxx
    public static void main(String[] args) {
        String a = "Hello";
        System.out.println(1 + 2 + a + 3 + 4);  //3Hello34
        System.out.println(1 + 2 + a + (3 + 4));//3Hello7
    }

3.自增自减运算符

说明

自增运算符：++ 自减运算符：--

基本含义：让一个变量增长一个数字1，或者让一个变量降一个数字1 使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num或num++ 使用方式： 1.单独使用：不和其他任何操作混合，自己独立成为一个步骤。 2.混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。使用区别： 1.在单独使用的时候，前++和后++没有任何区别。也就是：++num和num++;是完全一样。 2.在混合使用，有很大区别。 A.如果是前++，那么变量立刻马上+1，然后拿着结果进行使用。（先加后用） B.如果是后++，那么首先使用变量本来的数值，然后再然变量+1。（先用后加）

注意事项

只有变量才能使用自增、自减操作。常量不可发现改变，所以不能使用。

3.1 单独使用

前++和后++


xxxxxxxxxx
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);   //  10
        ++num1; //单独使用，前++
        System.out.println(num1);   //  11
        int num2 = 10;
        System.out.println(num2);   //  10
        num2++; //单独使用，后++
        System.out.println(num2);   //  11
    }

前--和后--


xxxxxxxxxx
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);   //  10
        --num1; //单独使用，前--
        System.out.println(num1);   //  9
        int num2 = 10;
        System.out.println(num2);   //  10
        num2--; //单独使用，后++
        System.out.println(num2);   //  9
    }

3.2 混合使用

前++和后++


xxxxxxxxxx
//与打印操作混合使用
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(++num1);     //  11（混合使用前++，立刻+1变成11，然后打印结果11）
        System.out.println(num1);       //  11 后续使用num1，将会使用11
        System.out.println("==============");
        int num2 = 10;
        System.out.println(num2++);     //  10（混合使用后++，先打印原变量值10，然后进行+1，得到结果11）
        System.out.println(num2);       //  11 后续使用num2，将会使用11
    }

前--和后--


xxxxxxxxxx
//与打印操作混合使用
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(--num1);     //  9（混合使用前--，立刻-1变成9，然后打印结果9）
        System.out.println(num1);       //  9 后续使用num1，将会使用9
        System.out.println("==============");
        int num2 = 10;
        System.out.println(num2--);     //  10（混合使用后--，先打印原变量值10，然后进行-1，得到结果9）
        System.out.println(num2);       //  9 后续使用num2，将会使用9
    }

赋值运算符

1.基本赋值运算符

1.1说明

就是一个等号“=”，代表将右侧的数据交给左侧的变量。

1.2实例代码


xxxxxxxxxx
    public static void main(String[] args) {
        int a = 30;
    }

2.复合赋值运算符

2.1说明

+= a += 1 相当于 a = a + 1 -= b -= 2 相当于 b = b - 2 *= c *= 3 相当于 c = c * 3 /= d /= 4 相当于 d = d / 4 %= e %= 5 相当于 e = e % 5

2.2实例代码


xxxxxxxxxx
    public static void main(String[] args) {
        int a,b,c,d,e;
        a = 1;
        b = 2;
        c = 3;
        d = 4;
        e = 5;
        a += 1;
        System.out.println(a);
        b -= 2;
        System.out.println(b);
        c *= 3;
        System.out.println(c);
        d /= 4;
        System.out.println(d);
        e %= 5;
        System.out.println(e);
    }

注意事项

1.只有变量才能使用赋值运算符，常量不能进行赋值。

2.复合赋值运算符其中隐含了一个强制类型转换。


xxxxxxxxxx
    public static void main(String[] args) {
        byte num = 30;
        //  num = num + 30;
        //  num = byte + int;
        //  num = int + int;
        //  num = int;
        //  num = (byte) int;
        num += 5;
        System.out.println(num);    //  35
    }

比较运算符

1.有哪些比较运算符

==	比较符号两边数据是否相等，相等结果是true。
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=	比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。
>=	比较符号左边的数据是否大于或者等于右边的数据，如果大于结果是true。
!=	不等于符号，如果符号两边的数据不相等，结果是true。

2.实例代码


xxxxxxxxxx
    public static void main(String[] args) {
        System.out.println(10 == 10); //  true
        System.out.println(10 < 10);  //  false
        System.out.println(10 > 10);  //  false
        System.out.println(10 <= 10); //  true
        System.out.println(10 >= 10); //  true
        System.out.println(10 != 10); //  false
    }

逻辑运算符

1.有那些逻辑运算符

与（并且） && 全都是true，才是true；否则就是false 或（或者） || 至少一个是true，就是true；全都是false，才是false 非（取反）！本来是true，变成false；本来是false，变成true

与“&&”，或“||”，具有短路效果：如果更具左边已经可以判断得到最终结果，那么右边的代码将被不在执行，从而节省一定的性能。

1.1注意事项

1.逻辑运算符只能用于boolean值。 2.与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。 3.与、或两种运算符，如果有多个条件，可以连续写。两个条件：条件A && 条件B 多个条件：条件A && 条件B && 条件C

2.实例代码


xxxxxxxxxx
    public static void main(String[] args) {
        System.out.println(true && false);  //  false
        System.out.println(3 < 4 && 10 > 5);//  true
        System.out.println("===============");
        System.out.println(true || true);   //  true
        System.out.println(true || false);  //  true
        System.out.println(false || false); //  false
        System.out.println("===============");
        System.out.println(true);           //  true
        System.out.println(!true);          //  false
    }

三元运算符

1.说明

一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反！、自增++、自减-- 二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值= 三元运算符：需要三个数据才可以进行操作的运算符。

格式：数据类型变量名称 = 条件判断 ? 表达式A : 表达式B;

流程：首先判断条件是否成立：如果成立为true，那么将表达式A的值赋值给左侧的变量；如果不成立为false，那么将表达式B的值赋值给左侧的变量；二者选其一。

注意事项： 1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。

2.实例代码


xxxxxxxxxx
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);
    }

方法入门

概述

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样实现了代码的复用性，也解决了代码冗余的现象。

方法的定义

定义格式：
```
xxxxxxxxxx
修饰符 返回值类型 方法名 (参数列表) {
    代码...
    return;
}
```
- 定义格式的解释：
  - 修饰符：目前固定写法public static
  - 返回值类型：目前固定写法void，其他返回值类型在后面学习。
  - 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
注意事项
1. 方法定义的先后顺序无所谓
2. 方法的定义不能产生嵌套包含关系
3. 方法定义好了之后，不会执行的。如果想要执行，一定要进行方法的调用。
  调用方法：方法名称();
实例代码


xxxxxxxxxx
public class Method {
    public static void main(String[] args) {
        farmer();
        seller();
        cook();
        me();
    }
    public static void farmer() {
        System.out.println("播种");
        System.out.println("浇水");
        System.out.println("施肥");
        System.out.println("除虫");
        System.out.println("收割");
        System.out.println("卖给小商贩");
    }
    public static void seller() {
        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("炒菜");
        System.out.println("装盘");
    }
    public static void Me() {
        System.out.println("吃");
    }
}

第一章流程控制

概述

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果又直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要用过控制语句的执行顺序来实现我们要完成的功能。

顺序结构


xxxxxxxxxx
    public static void main(String[] args) {
        //顺序执行，根据编写的顺序，从上到下运行。
        System.out.println("播种");
        System.out.println("浇水");
        System.out.println("施肥");
        System.out.println("除虫");
        System.out.println("收割");
        System.out.println("卖给小商贩");
    }

第二章判断语句

if语句第一种格式：if


xxxxxxxxxx
if(关系表达式) {
    语句体;
}

执行流程
- 首先判断关系表达式结果是true还是false
- 如果是true就执行语句体
- 如果是false就不执行语句体


xxxxxxxxxx
    public static void main(String[] args) {
        if (1<2){
            System.out.println("你是对的！");//  1小于2，判断为true，打印"你是对的！"
        }
    }

if语句第二种格式：if ...else


xxxxxxxxxx
if(关系表达式) {
    语句体A;
}else{
    语句体B;
}

执行流程
- 首先判断关系表达式结果是true还是false
- 如果是true就执行语句体A
- 如果是false就执行语句体B


xxxxxxxxxx
    public static void main(String[] args) {
        int num = 13;
        //如果除以2能够得到余数0，说明是偶数，余数不是0，说明是奇数。
        if (num % 2 == 0) { 
            System.out.println("你是偶数！");
        } else {
            System.out.println("你是奇数！");
        }
    }

if语句第三种格式：if...esle if ...else


xxxxxxxxxx
if(关系表达式1){
    执行语句1;
}else if (关系表达式2){
    执行语句2;
}
...
}else if (关系表达式n){
    执行语句n;
}else {
    执行语句n+1;
}

执行流程
- 首先判断关系表达式1看其结果是true还是false
- 如果是true就执行语句1
- 如果是false就继续执行关系表达式2看其结果是true还是false
- 如果是true就执行语句体2
- 如果是false就继续判断关系表达式...看其结果是true还是false
- ....
- 如果判断结果全是false就执行else里面的执行语句

第三章选择语句--switch

switch语句格式：


xxxxxxxxxx
switch(表达式) {
    case 常用值1:
        语句体1;
        break;
    case 常用值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

执行流程

首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。···
注意事项：
1. 多个case后面的数值不可以重复
2. switch后面小括号当中只能是夏磊数据类型：
```
xxxxxxxxxx
//基本数据类型：byte/short/char/int
 //引用数据类型：*String字符串、enum枚举*
```
3. switch语句格式可以很灵活：
  前后顺序可以颠倒，而且break语句还可以省略当省略break后，“匹配到那个case就从那个位置向下执行，直到遇到了break或者整体结束位置”


xxxxxxxxxx
    public static void main(String[] args) {
        int num =1 ;
        switch(num) {
            case 1:
                System.out.println("星期一");;
                break;
            case 2:
                System.out.println("星期二");;
                break;
            case 3:
                System.out.println("星期三");;
                break;
            case 4:
                System.out.println("星期四");;
                break;
            case 5:
                System.out.println("星期五");;
                break;
            case 6:
                System.out.println("星期六");;
                break;
            case 7:
                System.out.println("星期天");;
                break;
            default:
                System.out.println("输入有误，从新输入");
                break;
        }

第四章循环语句

循环概述

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体是，需要在核实的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

循环结构组成部分

初始化语句：在循环开始最初执行，而且只做唯一一次。
条件判断：如果成立，则循环继续；如果不成立，则循环退出。
循环体：重复要做的事情内容，若干行语句。
步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

循环语句--for

★特性：变量作用范围有限

格式：


xxxxxxxxxx
public static void main(String[] args) {
    for (int x=1; x<=10; x++){         //for(初始化表达式①;布尔表达式②;步进表达式④){
       System.out.println("输出");         //    循环体③
    }                                  //}
}

执行流程
- 执行顺序：①②③④>②③④>②③④...②不满足为止
- ①负责完成循环变量初始化
- ②负责判断是否满足循环条件，不满足则跳出循环
- ③具体执行的语句
- ④循环后，循环条件所涉及变量的变化情况

循环语句--while


xxxxxxxxxx
public static void main(String[] args) {
    int x = 1;                          //初始化表达式①
    while(x <= 5){                      //while（布尔表达式②）{
        System.out.println("输出");     //    循环体①
        x++;                            //  步进表达式④
    }                                   //  }
}

循环语句--do-while

★特性：至少会执行一次


xxxxxxxxxx
public static void main(String[] args) {
    int x = 1;                      //初始化表达式①
    do {                            //{
        System.out.println("输出"); //循环体①
        x++;                        //  步进表达式④
    }while(x <= 5);                 //}while（布尔表达式②）;
}

实列--100以内偶数相加


xxxxxxxxxx
public static void main(String[] args) {
    int y = 0;
    for (int x = 1; x <= 100; x++){
        if(x%2==0){                 //如果x当前为偶数
            y+=x;                   //x存入y
        }       
    }
    System.out.println(y);
}

*次数确定的场景多用 for 循环，否则多用 while 循环。

循环控制语句

`break条件控制语句

功能：

在switch语句中，一旦执行，整个switch语句立刻结束.
在循环语句当中，一旦执行，整个循环语句立刻结束，打断进程.


xxxxxxxxxx
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            //将第四次循环打断
            if (x == 4) {        //如果当前是第四次
                break;        //中断整个循环
            }
            System.out.println("输出" + x);//最后一次输出为3
        }
    }

continue循环控制语句

功能：

一旦执行，立刻跳过当前次循环剩余内容，马上进入下一次循环。


xxxxxxxxxx
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            //将第四次循环打断
            if (x == 4) {        //如果当前是第四次
                continue;        //跳过本次循环（第四次），执行下次循环(第五次)
            }
            System.out.println(x+"层到了");//结果没有输出第四层
        }
    }

死循环

功能：

永远停不下来的循环


xxxxxxxxxx
//死循环的标准格式：
//    while (true) {
//        循环体
//    }
    public static void main(String[] args) {
       while (true) {
            System.out.println("此语句无限循环");
       }
    }
//IDEA中按下 Ctrl+F2 结束进程

嵌套循环

功能：

嵌套循环，是指大循环包含小循环。如for循环里面还有一个for循环,总循环次数=外循环次数*内循环次数。


xxxxxxxxxx
public static void main(String[] args) {
    for (int x = 0; x < 24; x++) {                //控制小时
        for (int y = 0; y < 60; y++) {            //控制分钟
            //丰富输出
            if (x <= 5) {
                System.out.println("凌晨" + x + "点" + y + "分");
            } else if (x <= 8) {
                System.out.println("早上" + x + "点" + y + "分");
            } else if (x < 12) {
                System.out.println("上午" + x + "点" + y + "分");
            } else if (x == 12) {
                System.out.println("中午" + x + "点" + y + "分");
            } else if (x < 20) {
                System.out.println("下午" + (x - 12) + "点" + y + "分");
            } else {
                System.out.println("晚上" + (x - 12) + "点" + y + "分");
            }
        }
    }
}
//for中嵌套if判断语句 可能过度占用性能

IDEA开发工具的使用

常用简写语句

psvm：生成main方法


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

sout：输出语句


xxxxxxxxxx
System.out.println("输出语句");

5.fori：快速for循环


xxxxxxxxxx
for (int i = 0; i < 5; i++) { }

常用快捷键

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

方法定义格式

定义方法的完整格式


xxxxxxxxxx
修饰符 返回值类型 方法名称(参数类型 参数名称,....){
    方法体
    return 返回值;
}

结构

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

实例

定义一个两个int数字相加的方法；三要素：

返回值类型：int
方法名称：sum
参数列表：int a, int b


xxxxxxxxxx
public class void main(String[] args){
    sum/*方法名称*/(10,20/*需要放入a,b的值*/)
}
public class int/*返回值类型*/ sum(int a,int b/*参数：a,b用于接收值*/){
    System.out.println("方法可行！")
    int result = a +b ;
    
}

方法三种调用方式

单独调用：方法名称（参数）；
打印调用；
赋值调用；


xxxxxxxxxx
public class 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 class int sum(int a,int b){
    System.out.println("方法可行！")
    int result = a +b ;
   
} 
//注意：此前学习的方法，返回值类型为void，这种方法只能够单独调用，不能进行打印调用或赋值调用。

对比有参数和无参数

有参数：一个方法需要一些数值才能进行运算（任务）的时候，就是有参数。


xxxxxxxxxx
public static void main(String[] args) {
    method(10,20);//分别赋予a,b值
}
public static void method(int a ,int b) { //需要赋予a,b值才可进行运算
    int result = a + b; //两个数字相加 必须赋予a,b值才能运算
    System.out.println("结果是：" + result);
}

无参数：一个方法不需要任何数据条件，自己可以独立完成任务，就是无参数。


xxxxxxxxxx
public static void main(String[] args) {
    method();//括号留空 无参数 直接调用
}
public static void method() {//不需要什么参数(值)
    for (int i = 0; i < 10; i++) {//打印固定10次Hello,World。
    System.out.println("Hello,World" + i);
    }
}

★以上实例都为无返回值类型（void）

对比有返回值和无返回值

有返回值(int)：定义一个方法，用来求出两个数字之和。（getSum将运算结果返回给main方法）


xxxxxxxxxx
public static void main(String[] args) {
    System.out.println(getSum(10,20));
}
public static int getSum(int a ,int b) {//返回值类型为int
    return a * b;//返回运算结果
}

无返回值(void)：定义一个方法，用来求出两个数字之和。（getSum运算后直接打印结果）


xxxxxxxxxx
public static void main(String[] args) {
    getSum(10,20);
}
public static void getSum(int a ,int b) //返回值类型为Void(空)
    System.out.println("结果是"+a * b);//自己直接打印运算结果
}

★以上实例都为有参数类型

注意事项：

有返回值的方法(int、long、.....)可以单独调用、打印调用或者赋值调用。

无返回值的方法(void)，只能使用单独调用，不能使用打印调用或者赋值调用

方法三种调用方式（按住Ctrl键点击查看）

方法实操练习

练习1：比较两个数字


xxxxxxxxxx
public static void main(String[] args){
    System.out.println(Same(5,6));
    System.out.println(Same(6,6));
}
public static boolean Same(int a, int b){
    return a==b;
}
//比较两个数字：需要提供两个值，并返回比较结果。所以有参数也有返回值；

练习2： 1-100整数相加


xxxxxxxxxx
public static void main(String[] args) {
    System.out.println(Same());
}
public static int Same() {
    int x = 0;
    for (int i = 1; i <= 100; i++) {
        x += i;
    }
    return x;
}
//1-100相加：固定从1加到100,不需要提供参数。需要返回计算结果，所以有返回值。

练习3：打印指定次数


xxxxxxxxxx
public static void main(String[] args) {
    printCount(20);//指定打印次数为20次
}
public static void printCount(int n) {
    for (int i = 1; i <= n; i++) {
        System.out.println("Hello,World!" + i);
    }
}
//打印指定次数Hello,World。没有运算结果,所以无返回值。需要指定打印次数,所有有参数。

方法的注意事项

方法应该定义在类当中，不能在方法当中再定义方法。不能嵌套。
方法定义的前后顺序无所谓。
方法定义之后不会执行，希望执行需要调用：单独调用、打印调用、复制调用。
如果方法为有返回值类型，那么必须写上"return 返回值;"，不能没有。
return后面的返回值数据，必须和方法的返回值类型对应起来。
对于一个void无返回值的方法，return后面不能写返回值，只能写return(结束方法)。
对于方法当中最后一行的return可以省略不写。
一个方法当中可以有多个return语句，但是必须保证同时只有一个被执行。(比如 if 判断语句)

方法重载

方法重载的基本使用

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

方法的重载（OverLoad）：多个方法的名称一样，但是参数列表不一样。


xxxxxxxxxx
public static void main(String[] args) {
    System.out.println(sum(10));//10
    System.out.println(sum(10,20));//30
    System.out.println(sum(10,20,30));//60
}
public static int sum(int a) {
    System.out.println("有1个参数的方法执行！");
    return a;
}
public static int sum(int a, int b) {
    System.out.println("有2个参数的方法执行！");
    return a+b;
}
public static int sum(int a, int b, int c) {
    System.out.println("有3个参数的方法执行！");
    return a+b+c;
}
//对三个名称一样，参数列表不一样的方法；进行打印调用。

益处：只需要记住一个方法名称，就可以实现多个类似的功能

方法重载的注意事项

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


xxxxxxxxxx
public static void main(String[] args) {
    System.out.println(sum(200));
    System.out.println(sum(80,20));
    System.out.println(sum(20,10.10));
    System.out.println(sum(10.10,50));
}
public static int sum(int a) {
    System.out.println("参数int的方法执行！");
    return a;
}
public static int sum(int a, int b) {//跟上面比较：参数个数不同
    System.out.println("参数int,int的方法执行！");
    return a+b;
}
public static int sum(int a, double b) {//跟上面比较：参数类型不同
    System.out.println("参数int,double的方法已执行！");
    return a+(int)b;
}
public static int sum(double a, int b) {//跟上面比较：参数多个类型的顺序不同
    System.out.println("参数double,int的方法已执行！");
    return (int)a+b;
}

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


xxxxxxxxxx
public static void main(String[] args) {
    System.out.println(sum(200));
    System.out.println(sum(150));
    System.out.println(sum(100));
}
public static int sum(int a) {
    System.out.println("参数int的方法执行！");
    return a;
}
//错误示范 方法重载与参数的名称无关
public static int sum(int b) {
    System.out.println("参数int的方法执行！");
    return a;
}
//错误示范 方法重载与返回值类型无关
public static double sum(int a) {
    System.out.println("参数int的方法执行！");
    return a;
}

方法重载练习

练习1：四种不同参数


xxxxxxxxxx
public static void main(String[] args) {
    //在数值前加上（数据类型）后强行转换,以直接选择对应的执行方法。
    System.out.println(sum((byte)8,(byte)9));
    System.out.println(sum((short)16,(short)18));
    System.out.println(sum(25,25));//int类型直接输入即可
    System.out.println(sum(250L,250L));//long类型在尾部加上L
}
public static boolean sum(byte a, byte b) {
    System.out.println("参数byte,byte的方法已执行！");
    return a==b;
}
public static boolean sum(short a, short b) {
    System.out.println("参数short,short的方法已执行！");
    return a==b;
}
public static boolean sum(int a, int b) {
    System.out.println("参数int,int的方法执行！");
    return a==b;
}
public static boolean sum(long a, long b) {
    System.out.println("参数long,long的方法已执行！");
    return a==b; 
}

练习2：判断方法的正确


xxxxxxxxxx
    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) {}//代码错误：和第三行冲突
//实际判断依据为：方法名（open）和参数,以及参数排列顺序(int,double,...)。

练习3：实现重载的pri


xxxxxxxxxx
public static void main(String[] args) {
    myPrint(100);
    myPrint("Hellow");
    myPrint(100.1);
    myPrint(100.99999);
    myPrint("10_001_010_101_010_101");
    myPrint(100);
    myPrint(100);
    myPrint(100);
    myPrint(100);
    myPrint(100);
    myPrint(100);
}
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);
}
//按住Ctrl点击println可以看到实现重载的pri
//在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。

数组

数组的概念

数组的概念：是一种容器，同时可以存放多个数据值。

数组的特点：
1. 数组是一种引用数据类型
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化：
1. 动态初始化（指定长度）:在创建数组的时候，直接指定数组当中的数据元素个数
2. 静态初始化（指定内容）

数组的定义格式-动态初始化

动态初始化的格式：


x
数据类型[] 数组名称 = new 数据类型[数组长度];
/*从左到右依次解析含义：
左侧数据类型：数组当中保存的数据，是全部统一的类型。
左侧中括号：代表这是一个数组
左侧数组名称：给数组取的一个名字
右侧的new： 代表创建数组的动作
右侧的数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int的数字*/


public static void main(String[] args) {
    //创建一个数组，里面可以存放300个int数据
    //格式：数据类型[] 数组名称 = new 数据类型 数组长度
    int[] numA = new int[10];
    numA[0] = 1;
    numA[3] = 7;
    numA[9] = 9;
    System.out.println(numA[0] + numA[3] + numA[9]);
    //创建一个数组，能存放10个double类型的数据
    double[] numB = new double[10];
    numB[0] = 1.15;
    numB[3] = 100;
    numB[9] = 1;
    System.out.println(numB[0] * numB[3] + numB[9]);
    //创建一个数组，能存放5个字符串
    String[] numC = new String[5];
    numC[0] = "A";
    numC[3] = "B";
    numC[4] = "C";
    System.out.println(numC[0] + numC[3] + numC[4]);
}

运算符

算数运算符

1.加减乘除（+、-、*、\）

1.1 实例代码

注意事项

2.算数运算中“+”常见的三种用法

2.1 第一种

2.2 第二种

2.3 第三种

3.自增自减运算符

说明

注意事项

3.1 单独使用

3.2 混合使用

赋值运算符

1.基本赋值运算符

1.1说明

1.2实例代码

2.复合赋值运算符

2.1说明

2.2实例代码

注意事项

比较运算符

1.有哪些比较运算符

2.实例代码

逻辑运算符

1.有那些逻辑运算符

1.1注意事项

2.实例代码

三元运算符

1.说明

2.实例代码

方法入门

概述

方法的定义

注意事项

实例代码

第一章流程控制

概述

顺序结构

第二章判断语句

if语句第一种格式：if

if语句第二种格式：if ...else

if语句第三种格式：if...esle if ...else

第三章选择语句--switch

switch语句格式：

执行流程

第四章循环语句

循环概述

循环结构组成部分

循环语句--for

循环语句--while

循环语句--do-while

实列--100以内偶数相加

循环控制语句

`break条件控制语句

continue循环控制语句

死循环

嵌套循环

IDEA开发工具的使用

常用简写语句

常用快捷键

方法定义格式

定义方法的完整格式

结构

实例

方法三种调用方式

对比有参数和无参数

对比有返回值和无返回值

方法实操练习

练习1： 比较两个数字

练习2： 1-100整数相加

练习3： 打印指定次数

方法的注意事项

方法重载

方法重载的基本使用

方法重载的注意事项

方法重载练习

练习1： 四种不同参数

练习2： 判断方法的正确

练习1：比较两个数字

练习3：打印指定次数

练习1：四种不同参数

练习2：判断方法的正确

练习3：实现重载的pri