Java笔记(第二周)

一.流程控制语句

1.顺序结构语句

最基本的:代码由上而下依次加载

2.选择结构语句

Ⅰ. if语句:

格式一:
      if(条件表达式){
             语句;
            }
    执行流程
            1)当前条件表达式成立,执行语句
            2)否则不成立,不执行语句;
    if的第一种格式:
            比较简单:应用场景,就是针对单个条件进行判断的
格式二:
        if(表达式){
            语句1;
        }else{
            语句2;
        }
    执行流程:
        1)判断表达式是否成立,如果成立,执行语句1,
        2)如果不成立,执行语句2;
    应用场景:
        就是针对两种情况进行判断;
格式三:
        if(表达式1){
            语句1;
        }else if(表达式2){
            语句2;
        }else if(表达式3){
            语句3;
            ...
            ...
        }else{
            语句n ;
        }
        执行流程:
            1)判断表达式1是否成立,如果成立,则执行语句1;
            2)如果不成立,继续判断表达式2是否成立,如果成立,执行语句2;
            3)如果表达式2不成立,继续判断表达式3是否成立,如果成立,执行语句3
            ...
            ...
            4)如果上面的条件表达式都不成立,则执行else中的语句n....

Ⅱ. switch语句:

  格式:
            switch(表达式){
            case 值1:
                语句1;
                break ;
            case 值2:
                语句2;
                break ;
            ...
            ...
            ...
            default:
                语句n;
                break ;
            }
    执行流程:
            1)判断表达式的值和case值1进行匹配,
            如果匹配成功,执行语句1,break结束
            2)如果case值1不匹配,继续和case后面的值2进行比较,如果匹配,语句2执行,break结束;
            ...
            ...
            3)如果上面的case的值都和switch中表达式的结果不匹配的,那么最终
            就执行default中的语句n,然后程序默认执行到末尾结束了,break结束;
            
  注意:
    1)switch中的表达式基本的能够使用的数据类型:
            byte,short,char,int
            JDK5以后,可以跟枚举 (enum)
            JDK7以后,可以是String类型
    2)
        (1)case语句后面的值只能是常量
            (在Java语言中,Java是一个强类型语言:结构和格式是非常严谨的)
            (在JavaScript前端语言中,是一个弱类型语言,case后面的值既可以是常量
            ,也能够是变量;)
        (2)case语句中的break 必须带上,否则会造成一个现象:case 穿透
                    由于某个case已经匹配了,此时如果没有break,那么就继续往下面中
                case的语句进行穿透,依次执行,遇见有case中有break的,那么switch结束!
            
         (3)switch的结束条件是什么?
                a)语句break结束
                b)程序默认执行到末尾!
         (4)default语句可以在语句中的任何位置,不影响程序的执行流程!
            default的执行,当前case中都没有匹配的话,执行default

3.循环结构语句

Ⅰ. for循环

for循环的格式
        for(初始化语句;条件表达式;控制体语句(步长语句)){
            循环体语句;
            例:for(int x = 1 ;x <= 10 ; x ++)
        }
    执行流程:
        1)初始化语句进行赋值,只执行一次
        2)然后判断条件表达式是否成立
            如果成立,执行循环体语句;----然后执行控制体语句(步长语句) (++/--)
        3)继续判断条件表达式是否成立,
            如果成立,执行循环体语句;----然后执行控制体语句(步长语句) (++/--)
        ...
        ...
        4)执行到条件表达式不成立,for循环语句结束!
水仙花数:指的三位数,而且每个位的立方和就是当前数据本身

Ⅱ. while循环

格式:
扩展格式:
            初始化语句;
            while(条件表达式){
                循环体语句;
                控制体语句(步长语句) ;
            }
    流程:
            1)初始化语句进行赋值
            2)判断条件表达式是否成立
                如果成立,执行循环体语句,控制体语句对变量进行自增或者自减
            3)继续判断条件表达式是否成立
                ....
                ....
            4)如果条件表达式不成立,while循环结束

Ⅲ. do-while循环

格式:
    初始化语句;
    do{
        循环体语句;
        控制体语句;
    }while(条件表达式) ;
    执行流程:
        1)初始化语句执行
        2)执行条件表达式,如果条件表达式不成立,循环体至少执行一次!
        如果条件表达式成立...然后控制体语句,依次判断;
        do-while循环和其他两个循环的最大的区别:循环体至少执行一次;

4. if语句格式二的嵌套方式以及与三元运算符的区别

Ⅰ.嵌套方式:

if(表达式){// a >b 
            if(表达式1){ //a>c
                语句1;
            }else{
                语句2;
            }
        }else{ 
            if(表达式2){//b>c
                语句3;
            }else{
                语句4;
            }
        }
        执行流程:
            1)先判断表达式是否成立,如果成立
            2)执行里面的if语句
                2.1)判断表达式1是否成立,如果成立,执行语句1
                2.2)不成立,执行语句2
            3)如果第一次进行比较表达式如果不成立,执行else中的if语句
                3.1)判断表达式2是否成立,如果成立,执行语句3
                3.2)否则不成立,执行语句4

Ⅱ.区别:

 if...else:流程控制语句,范围比较广泛,不仅可以操作具体 数据值还可以操作语句
      而三元运算符--是运算符的一种,它只能操作具体的数据结果值,不能直接里面嵌套使用

Ⅲ.注意:

         三元运算符能够实现的---一定能够使用if...else实现而if...else...实现不一定能够使用三元运算符实现!实际开发中,业务场景逻辑判断---需要使用if格式2居多 

5. while循环和for循环的区别以及for循环的嵌套

Ⅰ.共同点:

都能够描述循环的思想,将重复度高的代码进行优化,解决冗余度问题

Ⅱ.不同点:

1)格式上不同
            for(初始化语句;条件表达式;控制体语句){
                    循环体语句;
            }
            初始化语句;
            while(条件表达式){
                循环体语句; 
                控制体语句;
            }
2)从内角度考虑,for循环使用完毕结束后,那么当前这个变量也就被释放掉了,而while不会,它始终
        可以访问到这个变量,所以相对来说说,for循环比较节省内存空间!
3)释放明确循环次数
        明确循环次数:优先采用for循环,其次再是while
                while循环:不明确循环次数,使用  
                实际开发中,for循环使用最多!
                while循环一般都是这样使用!
                while(true){ 死循环
                    //当达到某种条件,break;中断了 
                        }   

Ⅲ. for循环的嵌套

for(初始化语句1;条件表达式1;控制体语句1){
        循环体是for循环
        for(初始化语句2;条件表达式2;控制体语句2){
            循环体语句2;....
        }
    }       

6.死循环的应用

常见的两种格式
        for(;;){
            //业务操作
        }
        
        while(true){//恒成立   (使用居多)
            //业务操作..
            //当达到某种条件的时候,结束掉死循环,---使用 break ;(结束,中断)
        }

二.跳转控制语句

1. break

break;  中断,结束的意思    
应用场景:
        1)不能单独使用,报错
        2)只能在两个场景中使用
                switch语句自带了break关键字
            循环结构语句中
                for/while循环都可以用到        
        break早期的时候,在for循环嵌套中使用,使用"标签语句"
                break 标签名称; 结束指定的循环
                标签名称:外层循环/内层循环
                wc:for(xxx;xx;xx){
                    nc:for(xx;xx;xx){
                        
                    }
                }

2. continue

        属于跳转控制语句中的一种
        一般都在循环语句中使用的;
        表示结束当前循环,立即进入下一次循环了...

3. return

    return :返回结果   (结束方法去使用,但是很少单独使用)
    一般情况:return不会单独使用(很少单独使用)
    结合 Java中的有具体返回值类型的方法去使用
    实际开发中,
        只要看到return 关键字,肯定是当前方法中有具体返回值类型的时候,去使用!

三.方法

1.定义

   方法就是使用{}代码块将一些业务代码包裹起来,并为之起名字,称为"方法名"
    方法名,需要见名知意,满足"标识符的规则",

2.有返回值类型的方法

格式:固定写法
    定义方法
            权限修饰符 static  返回值类型 方法名(参数类型1 变量名1 ,参数类型2 变量名2.....){
                
                完成你的代码的业务逻辑:根据需求来完成操作
                
                return 结果;
            }   
            详细解释:
                    权限修饰符:现在固定使用public  :访问权限足够大的
                    现在写方法:必须带上static  前面的写法:public static
                    
                    返回值类型:就是数据类型----研究的就是基本数据类型
                    方法名: 给{}代码块起名字, 见名知意,遵循"标识符规则",小驼峰命名法
                            add(),求和
                            sum() ,求和
                    参数列表:
                        参数类型 ----:数据类型,现在使用的就是基本数据类型 
                        变量名 ---- :给当前形式参数起名字,见名知意,"小驼峰命名法"          
                     return 结果: 根据你的业务方法,返回值类型时什么类型,给你返回具体的结果
    调用方法:
        1)输出调用:不推荐
        2)赋值调用:推荐(int result = add(a,b) ;)
        3)单独调用:用不了
定义一个求两个数据之和的功能(方法)
        心中必须有两个明确
        1)明确返回值类型---数据类型:现在使用的就是基本数据类型
                int
        2)明确参数类型以及参数个数
            2个参数,分别都是int

3.定义有具体返回值类型的方法注意事项

1)方法和方法是平级关系,不能嵌套,只能在里面去调用
2)定义方法的时候需要两个明确
        a)明确返回值类型
        b)明确参数类型以及参数个数(形式参数类型和几个参数)     
3)在定义方法的时候,形式参数必须携带数据类型,因为Java
            是一个强类型语言!
4)在实际参数 main中,调用方法的时候,实际参数不需要携带数据类型,因为已经键盘录入,已经定义过了
5)实际参数和形参参数,传参时,数据类型需要一一对应!

4.没有返回值类型的方法

像下面这个需求:
            需要将直接输出在控制台的,并没有具体的返回值类型结果,定义方法的时候
            还必须遵循java的格式,这个时候Java语法规定,
            使用void关键字填充这个格式
            权限修饰符 静态修饰符 void 方法名(形式参数列表){
                //里面业务逻辑
                要么输出/类似于数组中(数据进行互换:排序)
            }
    定义格式:
            public static void 方法名(形式参数列表){
                //完成的业务逻辑,输出等等操作,
                但是不能有return (必须和有具体返回值类型的方法一块使用)
            }
没有具体返回值类型的方法调用:
            输出调用 :用不了
            赋值调用 :用不了
            单独调用:推荐
两个明确:
    1)明确返回值类型
            没有具体返回这里类型---使用void (关键字)
    2)明确参数类型以及参数个数
            没有参数,

四.方法重载(Over Load)

1.概念

     当方法的功能都是相同的,我们可以定义同名的方法
      参数列表不同,跟返回值无关,可以提高这个功能的扩展性

2.定义

方法重载: 为了提供某个功能的扩展性
            方法名相同,参数列表不同,与返回值无关     
            参数列表不同:
                1)参数个数不同
                2)参数类型不同
                3)考虑参数类型的顺序

五.数组

1.数组的定义

   数组就是能够存储同一种数据类型的容器!容器,必须满足里面的元素是同一种类型的元素
   举例:
            存储的int类型,那么就不能出现其他数据类型的元素,否则编译报错
定义格式:
        1)数据类型[] 数组名称; (推荐第一种方式)
        2)数据类型 数组名称[] ;
        举例
            int[] arr ; //定义了一个int类型的数组,arr变量
            int arr[] ;//定义了int类型的arr数组
        数组本身就属于引用数据类型,里面存储的元素内容,
        可以方法同一种类型的基本类型元素或者同一类型的引用类型!(后期研究引用类型)

2.数组的初始化

Ⅰ.动态初始化:

我们给定数组的长度,数组的元素内容由系统默认初始化!
            默认初始化:系统给定的
                根据我们数组中存储的数据类型来判定
                    举例:int类型的默认值就是0
                        double的默认值0.0
                            ...
  格式:       
    数据类型[] 数组名称 = new 数据类型[数组长度] ; (推荐)
    数据类型 数组名称[] = new 数据类型[数组长度] ;

Ⅱ.静态初始化:

  我们给定元素的内容,由系统来默认分配长度  
  格式:
        (推荐)数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
        数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;     
    简化格式:推荐使用简写格式
        数据类型[] 数组名称 = {元素1,元素2,元素3....} ;
        数据类型 数组名称[] = {元素1,元素2,元素3....} ;

Ⅲ.注意

创建数组的时候,不能既动态初始化了,还静态初始化了(动静结合:不行!)
    数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
        int[] arr = new int[3]{1,2,3} ; 错误！

3.数组的应用

Ⅰ.数组的遍历

就是将数组中的元素一一输出
例:
  定义一个数组,静态初始化,将数组中的元素按照下面格式输出
  int[] arr = {11,22,33,44,55} ;
    [元素1, 元素2, 元素3, 元素4 ....元素n] ,使用方法调用完成
    public static void printArray(int[] array){ //形式参数数一个数组
        for(int x = 0 ; x < array.length ; x ++){//最大的角标值= 数组的长度-1 ;
            System.out.println(array[x]) ;
        }
    }

Ⅱ.数组的最值问题

已知一个数组,静态初始化了
        int[] arr = {69,87,52,13,24} ;
        求arr数组中的最大值,使用方法完成!
        最值问题:
            最大值/最小值
            可以参照物方式---假设思想

Ⅲ.数组的逆序

   就是将数组中的一个元素和最后一个元素互换,将数组中的第二个元素和倒数第二个元素进行互换
   分析:
            arr[0]和arr.length-1互换
            arr[1]和arr.length-1-1 换行
            ...
            ...
            保证数组的长度 arr.length/2
            先将原始数组---进行遍历---
        逆序之前:
            输出([元素1, 元素2, 元素3, 元素4...元素n])
            调用逆序的方法(完成逆序)
        逆序之后:
            输出([元素1, 元素2, 元素3, 元素4...元素n])

4.数组中常见的异常:

运行时期异常 
            1)数组角标越界异常---程序运行的时候出现异常    ArrayIndeexOutOfBoundsException 类名  
              出现这个异常原因:我们访问了数组中不存在的索引值报错
              解决方案:
                      改变索引值     
            2)实际开发中,经常会出现 空指针异常 NullPointerException
                 就是当前 我们在访问某个对象的时候,对象已经是null
                  然后还要使用对象中的某个功能---出现空指针了   
            解决方案:
                    对当前这个对象进行非空判断

5.数组的排序

Ⅰ.冒泡排序

思想:两两比较,将较大的值往后放,第一次比较完毕之后,最大值出现在最大索引处,依次这样比较
            规律:
                两两比较,大的往后放
                第一次比较,有0个不比
                第二次比较,有1个不比..
                比较的次数:数组长度-1次