day05.数组_方法

java

课前回顾:
  1.for循环:
    a.格式:
      for(初始化变量;比较;步进表达式){
          循环语句
      }
    b.执行流程:
      先初始化变量,比较,如果是true,就走循环语句
      走步进表达式,再比较,如果还是true,继续走循环语句
      走步进表达式,再比较,直到比较为false,循环结束
  2.while循环:
    a.格式:
      初始化变量;
      while(比较){
          循环语句
          步进表达式
      }
    b.执行流程:
      先初始化变量,比较,如果是true,就走循环语句
      走步进表达式,再比较,如果还是true,继续走循环语句
      走步进表达式,再比较,直到比较为false,循环结束
  3.do...while:
    a.格式:
      初始化变量
      do{
          循环语句
          步进表达式
      }while(比较);

    b.执行流程:
      初始化变量,走循环语句,步进表达式,比较,如果是true,继续循环,直到比较为false,循环结束
    c.特点:至少执行一次
  4.循环控制语句:
    break:结束循环
    continue:结束本次循环,进入下一次循环

  5.死循环:条件永远是true
  6.嵌套循环:循环中嵌套循环
    执行流程:先走外层循环,再走内存循环,内层循环就一直循环,直到内层循环完事,外层循环再进入下一次循环
            直到外层循环都结束了整体结束

  7.Random:
    a.概述:java自带的一个类
    b.作用:可以在指定的范围内随机
    c.使用:
      导包:import java.util.Random
      创建对象:Random 对象名 = new Random()
      调用方法:
              对象名.nextInt()在int取值范围内随机
              对象名.nextInt(int bound) 在0-(bound-1)之间随机
  8.数组:
    a.概述:是一个容器,数组本身属于引用类型
    b.作用:一次存储多个数据
    c.特点:
      定长
      既能存储基本类型数据,还能存储引用类型数据
    d.定义:
      动态初始化: 数据类型[] 数组名 = new 数据类型[长度]
      简化静态初始化: 数据类型[] 数组名 = {元素1,元素2...}
    e.获取长度:数组名.length
    f.索引:元素在数组中存储的位置
          唯一
          从0开始,最大索引为数组长度-1
      操作数组中的元素,一定是根据索引来操作
    g.存储元素
      数组名[索引值] = 值
    h.获取元素
      数组名[索引值]

      直接输出数组名:地址值
      数组中的元素是有默认值的:
        整数 0
        小数 0.0
        字符 '\u0000'
        布尔: false
        引用  null
     i.遍历:  将元素从数组中挨个拿出来
       数组名.fori

     j.两个异常:
       ArrayIndexOutOfBoundsException 数组索引越界异常 -> 操作的索引超出了数组索引范围
       NullPointerException 空指针异常 -> 如果引用类型为null,再操作


今日重点:
  1.知道内存中:栈  堆的作用
  2.理解数组扩容的过程
  3.知道方法是啥
  4.会定义方法:
    a.会无参无返回值方法定义和调用
    b.会有参无返回值方法定义和调用
    c.会无参有返回值方法定义和调用
    d.会有参有返回值方法定义和调用

晚自习所有人先干:
用最简单的需求,分别定义四种方法以及调用,直到给个需求,想定义一个啥样的方法就定义啥样的方法,并且能顺利调用执行为止
否则,其他的知识点,不要干

第一章.内存的说明

java

1.内存的概述:就是运行内存,说白了简单理解(内存条),只不过在java的世界里,将内存划分了5块
2.划分出来的哪五块:
  a.栈(Stack):
    专门运行方法的,所有的方法运行都会去栈内存中运行

  b.堆(Heap):
    放引用类型的数据
    而且我们每new一次,都会在堆内存中产生一个空间,堆内存会为这个空间分配一个地址值
    而且在堆中的数据都有默认值
    整数 0
    小数 0.0
    字符 '\u0000'
    布尔 false
    引用 null

  c.方法区(Method Area)
    可以理解为代码运行前的"预备区",所有的代码运行之前先加载到内存中,就先去方法区中做预备
    到时候真正执行起来,该去栈就去栈,该进堆的就去堆

  d.本地方法栈(Native Method Stack)
    专门运行本地方法的(方法声明上带native关键字)
    本地方法:可以理解为对java无法实现的功能进行功能上的扩容的
            本地方法是由C语言编写的,我们是看不到本地方法的具体实现的,因为c语言没对我们开源

  e.寄存器(pc Register):和CPU有关

1.一个数组内存图

2.两个数组内存图

java

arr1和arr2是两个不同的空间,修改一个空间中的数据,不会影响另外一个空间中的数据

3.两个数组指向同一片内存空间

java

arr2是arr1直接给的,所以此时arr1和arr2的地址值是一样的,指向了同一片空间,修改一个数组的数据会影响另外一个数组

第二章.数组复杂操作

1.练习

java

数组扩容

需求:  arr1数组保存1,2,3   -> 将arr1数组扩容到5

java

public class Demo04Array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        //创建新数组,长度定为5
        int[] arr2 = new int[5];
        //遍历arr1,将arr1中的元素放到arr2中
        for (int i = 0; i < arr1.length; i++) {
            /*
              i = 0的时候,arr2[0] = arr1[0] -> 将arr1数组0索引上的元素放到arr2数组的0索引上
              i = 1的时候,arr2[1] = arr1[1] -> 将arr1数组1索引上的元素放到arr2数组的1索引上
              i = 2的时候,arr2[2] = arr1[2] -> 将arr1数组2索引上的元素放到arr2数组的2索引上
             */
            arr2[i] = arr1[i];
        }

        //将arr2的地址值给arr1
        arr1 = arr2;

        //遍历arr1
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
}

2.练习

java

数组合并

java

public class Demo05Array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        int[] arr2 = {4,5,6};

        int[] arr3 = new int[arr1.length+arr2.length];

        for (int i = 0; i < arr1.length; i++) {
            arr3[i] = arr1[i];
        }

        for (int i = 0; i < arr2.length; i++) {
            /*
              i = 0;arr3[3+0] = arr2[0]
              i = 1;arr3[3+1] = arr2[1]
              i = 2;arr3[3+2] = arr2[2]
             */
            arr3[arr1.length+i] = arr2[i];
        }

        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }

    }
}

第三章.二维数组

2.1 二维数组的定义格式

java

1.概述:数组中嵌套多个一维数组
2.定义:
  a.动态初始化:
    数据类型[][] 数组名 = new 数据类型[m][n]
    数据类型 数组名[][] = new 数据类型[m][n]
    数据类型[] 数组名[] = new 数据类型[m][n]

    m:代表的是二维数组的长度
    n:每一个一维数组的长度

    数据类型[][] 数组名 = new 数据类型[m][] -> 代表的是二维数组中的一维数组没有被创建

  b.静态初始化:
    数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...}
    数据类型 数组名[][] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...}
    数据类型[] 数组名[] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...}

  c.简化静态初始化:
    数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...}...}

java

public class Demo06Array {
    public static void main(String[] args) {
        int[][] arr1 = new int[3][3];

        String[][] arr2 = {{"张无忌","张三丰","张翠山"},{"赵敏","周芷若"},{"小龙女"}};
    }
}

2.2 获取二维数组长度

java

1.格式:
  数组名.length

java

public class Demo07Array {
    public static void main(String[] args) {
        int[][] arr = {{1,2},{1,2,3},{1,2,3,4}};
        System.out.println(arr.length);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].length);
        }
    }
}

2.3 获取二维数组中的元素

java

1.格式:
  数组名[i][j]

  i:代表一维数组在二维数组中的索引位置
  j:代表元素在一维数组中的索引位置

java

public class Demo08Array {
    public static void main(String[] args) {
        String[][] arr = {{"谢逊","殷天正","韦一笑","黛绮丝"},{"杨过","尹志平"},{"乔峰","段誉","虚竹"}};
        System.out.println(arr[0][0]);
        System.out.println(arr[1][0]);
    }
}

2.4 二维数组中存储元素

java

1.格式:
  数组名[i][j] = 值

  i:代表一维数组在二维数组中的索引位置
  j:代表元素在一维数组中的索引位置

java

public class Demo09Array {
    public static void main(String[] args) {
        int[][] arr = new int[3][3];

        arr[0][0] = 100;
        arr[0][1] = 200;
        arr[0][2] = 300;

        arr[1][0] = 1000;
        arr[1][1] = 2000;
        arr[1][2] = 3000;

        arr[2][0] = 10000;
        arr[2][1] = 20000;
        arr[2][2] = 30000;

        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
        System.out.println(arr[2][2]);
    }
}

2.5.二维数组的遍历

java

1.先遍历二维数组,将每一个一维数组拿出来
  再遍历每一个一维数组,将元素获取出来

java

public class Demo010Array {
    public static void main(String[] args) {
        int[][] arr = new int[3][3];

        arr[0][0] = 100;
        arr[0][1] = 200;
        arr[0][2] = 300;

        arr[1][0] = 1000;
        arr[1][1] = 2000;
        arr[1][2] = 3000;

        arr[2][0] = 10000;
        arr[2][1] = 20000;
        arr[2][2] = 30000;

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

2.6 二维数组内存图

java

public class Demo06Array {
    public static void main(String[] args) {
        int[][] arr1 = new int[3][];

        arr1[1] = new int[]{1,2,3};

        arr1[2] = new int[3];

        arr1[2][1] = 100;
    }
}

第四章.方法的使用

java

1.概述:拥有功能性代码的代码块,我们将来一个功能就应该定义一个方法
      将来开发一个功能就应该对应搞一个方法,而不是将所有的功能相关代码放在一个方法中
      到时候执行哪个功能就单独调用哪个方法

2.方法的通用定义格式:
  修饰符 返回值类型 方法名(参数){
      方法体
      return 结果
  }

3.在通用格式的基础上,分成四种方法
  a.无参无返回值方法
  b.有参无返回值方法
  c.无参有返回值方法
  d.有参有返回值方法

4.注意:
  a.方法不调用不执行
  b.方法之间是平级关系,不能互相嵌套
  c.方法的执行顺序只和调用顺序有关
  d.main方法是jvm自动调用

1.无参无返回值方法定义和调用

java

1.格式:
  public static void 方法名(){
      方法体
  }
2.注意:
  void关键字代表的是无返回值,如果此方法没有返回值,返回值类型上写void,就不要写具体的返回值数据类型了

3.调用:
  在其他方法中:方法名();

java

需求:
  定义一个方法,实现两个整数相加

java

public class Demo01Method {
    public static void main(String[] args) {
        //直接调用
        sum();
        System.out.println("250312所有的学生都是睡神");
        subtract();
    }

    /***
     * 无参无返回值方法定义
     */
    public static void sum() {
        int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println("sum = " + sum);
    }

    public static void subtract(){
        int a = 10;
        int b = 20;
        int subtract = a - b;
        System.out.println("subtract = " + subtract);
    }
}

2.方法定义各部分解释

java

1.方法的通用定义格式:
  修饰符 返回值类型 方法名(参数){
      方法体
      return 结果
  }

2.各部分解释:
  a.修饰符: 固定为public static
  b.返回值类型: 方法执行完毕之后最终返回的数据的数据类型
    比如:return 1 -> 返回值类型为int
        return 2.5 -> 返回值类型为double
        return "涛哥和三上...的故事" -> 返回值类型为String
  c.方法名:给方法取的名字 -> 见名知意
  d.参数:数据类型 变量名,数据类型 变量名 -> 用于接收别人传递过来的数据
  e.方法体:实现这个方法的具体代码
  f.return 结果 -> 方法运行之后最终的结果,将其返回 -> 返回值

3.有参数无返回值的方法定义和执行流程

java

1.格式:
  public static void 方法名(参数){
      方法体
  }

2.直接调用:
  方法名(具体得值)

java

需求:定义一个方法,实现两个整数的和

java

public class Demo02Method {
    public static void main(String[] args) {
        sum(10,20);
    }

    public static void sum(int a,int b){
        int sum = a+b;
        System.out.println(sum);
    }
}

4.无参数有返回值定义以及执行流程

java

1.格式:
  public static 返回值类型 方法名(){
      方法体
      return 结果
  }

2.调用:
  a.赋值调用: 数据类型 变量名 = 方法名()  -> 推荐使用
  b.打印调用: sout(方法名()) -> 不推荐使用

java

需求:定义一个方法,实现两个整数相加,将结果返回

java

public class Demo03Method {
    public static void main(String[] args) {
        int result = sum();
        System.out.println(result);
    }

    public static int sum(){
        int a = 10;
        int b = 20;
        int sum = a+b;
        return sum;
        //return a+b;
    }
}

5.有参数有返回值定义以及执行流程

java

1.格式:
  public static 返回值类型 方法名(参数){
      方法体
      return 结果
  }

2.调用:
  a.赋值调用: 数据类型 变量名 = 方法名(具体的值)

java

需求:定义一个方法,实现两个整数相加,将结果返回

java

public class Demo04Method {
    public static void main(String[] args) {
        int result = sum(10, 20);
        System.out.println("result = " + result);
    }
    public static int sum(int a,int b){
        int sum = a+b;
        return sum;
    }
}

6.形参和实参的区别

java

1.形参(形式参数):在定义方法的时候,形式上定义的参数,此时并没有值
2.实参(实际参数):在调用方法的时候,给形参传递的具体的值

7.参数和返回值使用的时机

java

1.参数:
  当想将一个方法中的数据传递到另外一个方法中,那么被调用方法需要定义参数,调用时传递想要传递过去的数据
2.返回值:
  调用方法时,想要此方法的结果,去参与其他操作,那么被调用的方法需要将自己的结果返回

java

public class Demo05Method {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //传递的是a和b所代表的值,不是a和b变量本身
        method(a,b);
        System.out.println("====================");
        int result = method02();
        System.out.println(result);
    }
    public static void method(int a,int b){
        int sum = a+b;
        System.out.println("sum = " + sum);
    }

    public static int method02(){
        int a = 10;
        int b = 20;
        int sum = a+b;
        return sum;
    }
}

1.问题描述:我们不可能将所有的代码都放到一个 main 方法中;我们也不可能将所有的方法放到一个类中;同理我们也不可能将所有的类放到同一个包中,所以将来开发需要用到一个开发模式 -> 三层架构
2.说白了:不同的包管理不同的类
java
com.atguigu.controller (表现层) -> 存放的是接受请求回响应的类(和页面打交道的)
com.atguigu.service(业务层) -> 存放业务处理的类
com.atguigu.dao(持久层) -> 存放和数据库打交道的类 -> 增删改查
com.atguigu.pojo -> 专门放javabean类的(实体类)
com.atguigu.utils -> 专门放工具类的
1
2
3
4
5

8.方法注意事项终极版

java

  1.方法不调用不执行
  2.方法之间是平级关系,不能互相嵌套
  3.方法的执行顺序只和调用顺序有关
  4.main方法是jvm自动调用
  5.void不能和[return 结果]共存,但是void能和[return]共存
    void:代表无返回值
    return 结果:代表有返回值 -> 先将结果返回,然后结束方法
    return:仅仅代表结束方法,不代表有返回值
  6.方法的调用必须完全匹配(参数个数,类型,顺序等)
  7.一个方法中只能有一个返回值,不要连续写多个return

作为初学者:
1.先定义,再调用
2.没有返回值的-> 直接调用
3.有返回值的 -> 赋值调用

day05.数组_方法 ​

第一章.内存的说明 ​

1.一个数组内存图 ​

2.两个数组内存图 ​

3.两个数组指向同一片内存空间 ​

第二章.数组复杂操作 ​

1.练习 ​

2.练习 ​

第三章.二维数组 ​

2.1 二维数组的定义格式 ​

2.2 获取二维数组长度 ​

2.3 获取二维数组中的元素 ​

2.4 二维数组中存储元素 ​

2.5.二维数组的遍历 ​

2.6 二维数组内存图 ​

第四章.方法的使用 ​

1.无参无返回值方法定义和调用 ​

2.方法定义各部分解释 ​

3.有参数无返回值的方法定义和执行流程 ​

4.无参数有返回值定义以及执行流程 ​

5.有参数有返回值定义以及执行流程 ​

6.形参和实参的区别 ​

7.参数和返回值使用的时机 ​

8.方法注意事项终极版 ​

day05.数组_方法

第一章.内存的说明

1.一个数组内存图

2.两个数组内存图

3.两个数组指向同一片内存空间

第二章.数组复杂操作

1.练习

2.练习

第三章.二维数组

2.1 二维数组的定义格式

2.2 获取二维数组长度

2.3 获取二维数组中的元素

2.4 二维数组中存储元素

2.5.二维数组的遍历

2.6 二维数组内存图

第四章.方法的使用

1.无参无返回值方法定义和调用

2.方法定义各部分解释

3.有参数无返回值的方法定义和执行流程

4.无参数有返回值定义以及执行流程

5.有参数有返回值定义以及执行流程

6.形参和实参的区别

7.参数和返回值使用的时机

8.方法注意事项终极版