“本周学习Java的总结”

“本周学习Java的总结”

一、流程控制语句

1.1、流程控制语句的概述

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

1.2、顺序结构语句

总的来说：写在前面的代码先执行，写在后面代码的后执行

1.3、 选择结构语句

    选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，
逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
 Java语言提供了两种选择结构语句
     if语句
     switch语句

1.3.1、 if语句的执行机制

首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1。

1.3.2、if分支语句的格式

//if语句有三种格式

           //if语句格式1
          if(关系表达式){                       
                            
              语句体; 
              
           }
          //if语句格式2                                     
          if(关系表达式) {                                                                                
                语句1;
              
          }else {
              
               语句体2;
              
          }
          //if语句格式3
               
           if(关系表达式1) {
               
               语句体1;
               
           }else if (关系表达式2) {
               
               语句体2;
               
           }
                 …
           else {
               
               语句体n+1;
           }

1.3.3、if语句与三目运算符的区别

if语句第二种格式和三元运算符:
三元运算符的操作都可以使用if语句改进，反之不成立
什么时候不成立呢?
1.当if语句控制的语句体是一条输出语句的时候，就不成立。因为三元运算符是一个运算符，必须要
求有一个结果 返回。
2.而输出语句却不能作为一个返回结果。

1.3.4、Switch语句的执行机制

   执行流程首先计算出表达式的值其次，和case依次比较，一旦有
对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结
束。最后，如果所有的case都和表达式的值不匹配，就会执行default语
句体部分然后程序结束掉。

1.3.5、Switch语句的格式

//switch语句格式：
 switch(表达式) {
    case 值1：
               语句体1;
               break;
    case 值2：
               语句体2;
               break;
     ......
    default：
               语句体n+1;
               break;
 }

1.3.6、witch语句中表达式的类型

可以是byte，short，int，char
jdk5以后可以是enum（枚举），
jdk7以后可以接收String（字符串）。

1.3.7、Switch的注意事项和case的穿透性

注意事项
    1.case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
    2.default可以省略吗?可以省略。一般不建议。除非判断的值是固定的。(单选题)
    3.break可以省略吗?可以省略，一般不建议。否则结果可能不是你想要的
    4.default的位置一定要在最后吗?可以出现在switch语句任意位置。
    5.switch语句的结束条件:
    6.遇到break
    7.执行到程序的末尾


case的穿透性
  
        在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
    举例：
    public static void main(String[] args) {
             int i = 5;
             switch (i){
                 case 0:
                         System.out.println("执行case0");
                         break;
                 case 5:
                         System.out.println("执行case5");
                 case 10:
                         System.out.println("执行case10");
                 default:
                         System.out.println("执行default");
            }
     }

   上述程序中，执行case5后，由于没有break语句，程序会一直向后走，不会在判断case，也不会理会break，直接
运行完整体switch。

1.4、循环结构语句

1.4.1、循环语句描述

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

1.4.2、循环语句的组成

初始化语句：一条或者多条语句，这些语句完成一些初始化操作。
判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体。
循环体语句：这个部分是循环体语句，也就是我们要多次做的事情。

1.4.3、循环语句1–for

//for循环的格式

    for(初始化表达式①; 布尔表达式②; 步进表达式④){
             
          循环体③
    }

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

举例:比如控制台打印10次helloWorld
    
    public static void main(String[] args) {
   //控制台输出10次HelloWorld，不使用循环
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("HelloWorld");
          System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
//用循环改进，循环10次
//定义变量从0开始，循环条件为<10
    for(int x = 0; x < 10; x++) {
     
        System.out.println("HelloWorld"+x);
    }

 

1.4.4、循环语句2—while

//while循环语句格式：

  while(判断条件语句) {
     
      循环体语句;
  }
//扩展格式
    初始化语句;
    while(判断条件语句) {
        
        循环体语句;
        
        控制条件语句;
    }

1.4.5、for循环与while循环之间的区别

 for循环语句和while循环语句可以等价转换，但还是有些小区别的使用区别：
 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如
 果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使
 用效率

1.4.6、循环语句3–do…while

//do…while循环语句格式：

   do {
      
       循环体语句;
       
       }while((判断条件语句);
 
//扩展格式
   初始化语句;
   do {
        
       循环体语句;
       控制条件语句;

       } while((判断条件语句);
               
特点：无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。这样的

1.4.7、死循环

就是循环中的条件永远为true，死循环的是永不结束的循环
例如：
1.while(true){}。  ----格式
2.我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

1.5、 跳出语句

Java就提供了break，continue和return来实现控制语句的跳转和中断。
break 中断continue 继续return 返回

1.5.1、break关键字;

使用场景：
在选择结构switch语句中
在循环语句中

作用：
跳出单层循环
跳出多层循环

带标签的跳出
格式：标签名: 循环语句

1.5.2、continue关键字;

使用场景：
在循环中使用

作用：
结束本次循环，继续下一次的循环

1.5.3、return关键字;

使用场景:
在循环中
在方法中  （常用）

作用：
跳转出循环体，
结束一个方法，也就是退出一个方法。（常用）

二、方法是什么

2.1、方法概述

2.1.1、方法概述

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

2.1.2、方法的定义

//方法格式
 修饰符 返回值类型 方法名 （参数列表）｛
          代码（方法体）...
           return ;
  ｝
 /*
  定义格式解释：
  修饰符：目前固定写法 public static
  返回值类型 用于限定返回值的数据类型
  方法名 一个名称，为了方便我们调用方法
  参数类型 限定调用方法时传入参数的数据类型
  参数名 是一个变量，接收调用方法时传入的参数
  方法体 完成功能的代码
  return 结束方法以及返回方法指定类型的值
  返回值 程序被return带回的结果，返回给调用者
 */

2.1.3、如何去学一个方法

1） 明确返回值类型 
2） 明确有几个参数，以及参数的类型

2.1.4、有明确返回值的方法调用

有明确返回值的方法调用：
单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式

2.1.5、有明确返回值的方法的举例

// 键盘录入两个数据，返回两个数中的较大值
// 键盘录入两个数据，比较两个数是否相等
// 键盘录入三个数据，返回三个数中的最大值
package com.qf.FunctionDemo;

import java.util.Scanner;

public class functionDemo002 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //提示
        System.out.println("请输入第一个数据：");
        int x = sc.nextInt();

        System.out.println("请输入第二个数据：");
        int y = sc.nextInt();

        System.out.println("请输出第三个数据：");
        int z = sc.nextInt();
        //赋值调用方法best2()
        int max = best2(x, y);

        System.out.println("两个数据之间的最大值为：" + max);

        System.out.println("---------------------------------------------------");

        //实现best3()的调用
        int max1 = best3(x, y, z);
        System.out.println("三个数据之间的最大值为：" + max1);

        System.out.println("---------------------------------------------------");

        //实现best4()的调用
        boolean  m =best4(x,y);
        System.out.println("比较两个数是否相等："+m);

    }

    //比较两个数的大小，并找出最大值
    public static int best2(int a, int b) {
        int max = 0;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;
    }

    //比较三个数
    public static int best3(int a, int b, int c) {
        int max = 0;
        if ((a > b) && (a > c)) {
            max = a;
        } else if ((b > a) && (b > c)) {
            max = b;
        } else {
            max = c;
        }
        return max;
    }
   
    //比较两个数是否相等
    public static boolean best4(int a, int b) {
        boolean m = (a == b);

        return m;
    }

}

2.1.6、无明确返回值的方法调用

其实就是void类型方法的调用
只能单独调用

2.1.7、无明确返回值的举例

// 键盘录入一个数据m，输出对应的mm乘法表
package com.qf.FunctionDemo;

import java.util.Scanner;

public class functionDemo005 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);

        //提示
        System.out.println("请您输入您想要数字m");
        int m = sc.nextInt();

        mulitply(m);
    }


    //实现m乘m的乘法表
    public static void mulitply(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "x" + j + "=" + i * j + "\t");
            }
            System.out.println();
        }
    }

}


//写一个方法，接受一个整数，输出这个整数是几位数（返回值类型int)
package com.qf.FunctionDemo;

import javax.swing.*;
import java.util.Scanner;

public class functionTest003 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);

        //提示和接受数据
        System.out.println("请输入你的整数");
        int n = sc.nextInt();

        int x = math(n);
        System.out.println(x + "位数");

    }
    
    public static int math(int n) {
        int m = 1;
        //实现用户输入的整数，从而确定几位数的功能
//     while (n>=10){
//         n/=10;
//         m++;
//     }
        for (int i = 1; i < n; i++) {
            n /= 10;
            m++;
        }
        return m;
    }
}

2.1.8、方法定义的注意事项

方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要有return带回一个值

2.2、方法的重载

2.2.1、方法重载的概述

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

2.2.2、方法重载的特点

1) 与修饰符和返回值类型无关
2) 方法名必须相同
3) 参数类型相同，参数个数必须不同
4) 参数个数相同，参数类型必须不同

2.2.3、方法重载的举例

//模拟输出语句中的 println 方法效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法println。

 public class Method_Demo7 {
      public static void println(byte a) {
             System.out.println(a);
      }
      public static void println(short a) {
             System.out.println(a);
      }
      public static void println(int a) {
             System.out.println(a);
      }
      public static void println(long a) {
             System.out.println(a);
      }
      public static void println(float a) {
             System.out.println(a);
      }
      public static void println(double a) {
             System.out.println(a);
      }
      public static void println(char a) {
             System.out.println(a);
      }
      public static void println(boolean a) {
             System.out.println(a);
      }
      public static void println(String a) {
             System.out.println(a);
      }
  }

三、数组

3.1、数组概述

3.1.1、数组概述

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

3.1.2、数组的定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];

3.2、数组初始化

3.2.1、数组的初始化概述

Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

3.2.2、数组的初始化方式

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

3.3、动态初始化

初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

3.4、Java中的内存分配

    Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，
因为每一片区域都有特定的处理数据方式和内存管理方式。
  
  栈 存储局部变量
  堆 存储new出来的东西
  方法区（面向对象部分讲）
  本地方法区（和系统相关）
  寄存器（给CPU使用）

例子:在ArrayTest类中编写
int[] arr= new int[3];

1）将ArrayTest.class文件从方法区加载到栈内存中
2）在栈内存为arr开辟空间（int[] arr）
3）在堆内存为数组对象开辟空间，并划分4个格子（new int[3]）
4）系统默认初始化
5）对象创建完毕，将对象所在的地址值赋给arr

3.5、Java中静态初始化

初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};

3.6、数组常见的两个小问题

数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素时

3.7、数组的遍历

package com.cn.qf.array;

public class ArraayDemo7 {
    public static void main(String[] args) {
     int[] arr ={2,3,44,122,33,76,97,86,54,63};
     printArray(arr);
    }
    //自定义一个数组,静态初始化 ,将数组遍历(依次输出数组中的每一个元素),将遍历使用功能完成!
    //			输出的格式：[元素1,元素2，元素3....]
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == arr[arr.length - 1]) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

3.7.1、数组的互换

package com.cn.qf.array;

public class arrayDemo03 {
    public static void main(String[] args) {
        int[] arr = {12, 87, 69, 24, 65};

        System.out.println("逆序前");
        printArray(arr);

        System.out.println("_______________________________________");
        System.out.println("逆序后");
//        getArray(arr);
        getArray1(arr);
        printArray(arr);

    }

    //逆序
    /*互换
     * a=10
     * b=20
     * int temp;
     * temp =a;
     * a=b;
     * b=temp
     * */
    public static void getArray(int[] arr) {

        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }

    public static void getArray1(int[] arr) {
        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

    //遍历
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {

            if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }

        }
    }

}

3.7.2、数组的查询

package com.cn.qf.array;

public class ArrayDemo7 {
    public static void main(String[] args) {
        int[] arr = {10, 55, 30, 24, 17};
        int index = getIndex(arr, 30);
        System.out.println("查询30这个元素第一次在数组中出现的索引:" + index);

        System.out.println("_____________________________________________________________");

        int index2 = getIndex(arr, 100);
        System.out.println("查某元素第一次在数组中出现的索引:" + index2);
    }

    //int[] arr = {10,55,30,24,17} ;查询30这个元素第一次在数组中出现的索引,查询元素使用功能完成!
    public static int getIndex(int[] arr, int key) {
        int index = -1; //假定没有这个元素
        for (int i = 0; i < arr.length; i++) {
            if (key == arr[i]) {
                index = i;
                break;
            }
        }
        return index;
    }

    public static int getIndex1(int[] arr, int key) {

        for (int i = 0; i < arr.length; i++) {
            if (key == arr[i]) {
                return i;
            }
        }
        return -1;
    }
}

3.8、冒泡排序

package com.cn.qf.array;

public class ArrayDemo10 {
    public static void main(String[] args) {
        int[] arr = {98, 23, 43, 67, 32, 39, 65, 27};
        System.out.println("排序前");
        PrintArray(arr);

        System.out.println("排序后");
        sort(arr);
        PrintArray(arr);
    }

    //冒泡排序
    //两两比较，然后最大值往右移，直到最大值在最大索引处
    public static void sort(int[] arr) {
        //控制比较的次数
        for (int i = 0; i < arr.length - 1; i++) {
            //控制两两比较的次数
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;

                }
            }
        }
    }

    //遍历数组
    public static void PrintArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == arr[arr.length - 1]) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
    }


}

四、面向对象

4.1、面向对象概述

4.1.1、面向过程

我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后
我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，
完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直
接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程
完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言

4.1.2、面向对象

面向对象是基于面向过程的编程思想

 特点：
  是一种更符合我们思想习惯的思想
  可以将复杂的事情简单化
  将我们从执行者变成了指挥者
  角色发生了转换

 /* 举例
   买电脑
    面向过程
              1）先去电脑城看电脑
              2）货比三家，选择合适的电脑
              3）与卖讨价还还价
              4）付钱，拿下电脑 
              5）等待收货

    面向对象
             1）找一个懂行的人去帮你买电脑
             2）等待收货
   
    吃饭  
      面向过程
              1）先去买菜
              2）讨价还价，买下菜
              3）切菜、洗菜、炒菜
              4）开吃
      面向对象
              1）点外卖
              2）开吃
  */
      

4.2、类与对象关系

类：是一组相关的属性和行为的集合 
对象：是该类事物的具体体现 
举例： 类 学生 对象 班长就是一个对象

4.2.1、类的定义

现实世界的事物 属性 人的身高，体重等 行为 人可以学习，吃饭等
Java中用class描述事物也是如此 成员变量 就是事物的属性 成员方法 就是事物的行为 定义类其实就是定义类的成
员(成员变量和成员方法)

4.2.2、成员变量与局部变量的区别

在类中的位置不同
  成员变量 类中方法外
  局部变量 方法内或者方法声明上
  
在内存中的位置不同
  成员变量 堆内存
  局部变量 栈内存
  
生命周期不同
  成员变量 随着对象的存在而存在，随着对象的消失而消失
  局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
  
初始化值不同
  成员变量 有默认的初始化值
  局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

4.2.3、形参问题

实际参数：定义在方法里的参数，调用时传递给方法的参数
形式参数：定义的方法时的使用的参数

基本类型作为形式参数
 当基本数据类型做为形参时，形参的改变不会影响到实际参数
 
引用类型作为形式参数
  当引用数据类型做为形参时，形参的改变会影响到实际参数（除String类型外）

4.2.4、匿名对象

匿名对象：就是没有名字的对象。
 是对象的一种简化表示形式
 匿名对象的两种使用情况
 对象调用方法仅仅一次的时候
 作为实际参数传递

4.3、面向对象三大特征之一—— 封装

4.3.1、封装的概述

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：
    隐藏实现细节，提供公共的访问方式
    提高了代码的复用性
    提高安全性。

封装原则：
   将不需要对外提供的内容都隐藏起来。
   把属性隐藏，提供公共方法对其访问。
   

4.3.2、private关键字

是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。

private最常见的应用：
  把成员变量用private修饰，外界将不能直接通过对象名访问属性
  提供对应的getXxx()/setXxx()方法，以便外界通过方法访问私有属性
  

4.3.3、this关键字

方法被哪个对象调用，this就代表那个对象

4.3.4、构造方法

构造方法作用概述
    给对象的数据进行初始化
    
构造方法格式
   方法名与类名相同
   没有返回值类型，连void都没有
   没有具体的返回值

构造方法注意事项
   如果你不提供构造方法，系统会给出默认构造方法
   如果你提供了构造方法，系统将不再提供
   构造方法也是可以重载的

构造方法的分类
  有参构造方法
  无参构造方法

4.3.5、一个标准类的写法

一个基本类的标准写法
  类
 成员变量
 构造方法
 无参构造方法
 带参构造方法
 成员方法
  getXxx()
  setXxx()
 给成员变量赋值的方式
 无参构造方法+setXxx()
带 参构造方法

4.3.6、类的初始过程

Student s = new Student();在内存中做了哪些事情?

1）将Student.class文件从方法区加载到栈内存区
2）在栈内存为s开辟空间
3）在堆内存为学生对象开辟空间
4）对学生对象的成员变量进行默认初始化
5）对学生对象的成员变量进行显示初始化
6）通过构造方法对学生对象的成员变量赋值
7）学生对象初始化完毕，把对象地址赋值给s变量