java基础语法(下)

约定不等于承诺〃 2022-03-02 11:09 255阅读 0赞

1:方法(掌握)
(1)方法：就是完成特定功能的代码块。

  1. 注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
  3.      (2)格式：
  5.               修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
  7.                       方法体语句;
  9.                       return 返回值;
  11.               }
  15.               修饰符：目前就用 public static。后面再详细讲解其他修饰符
  17.               返回值类型：就是功能结果的数据类型
  19.               方法名：就是起了一个名字，方便我们调用该方法。

回忆方法的命名方式:

  1. 一个单词：首字母小写
  3.                                举例：name,main
  5.                       多个单词：从第二个单词开始，每个单词首字母大写
  7.                                举例：studentAge,showAllNames()
  11.               参数类型：就是参数的数据类型
  13.               参数名：就是变量名
  15.               参数分类：
  17.                       实参：实际参与运算的数据
  19.                       形参：方法上定义的，用于接收实际参数的变量
  21.               方法体语句：就是完成功能的代码块
  23.               return：结束方法
  25.               返回值：就是功能的结果，由return带给调用者。
  27.      (3)如何写一个方法呢?做到两个明确：
  29.               返回值类型：结果的数据类型
  31.               参数列表：要传递几个参数以及每个参数对应的数据类型
  33.      (4)方法调用
  35.               A:有明确返回值的方法调用
  37.                       a:单独调用:没有意义
  39.                       b:输出调用:不是很好，因为我们可能针对结果进行进一步的操作(我拿到结果还要继续参与其它的运算)。
  41.                       c:赋值调用:推荐方案
  43.               B:void类型修饰的方法
  45.                       a:单独调用
  51.      (5)方法的注意事项
  53.               A:方法不调用不执行
  55.               B:方法之间是平级关系，不能嵌套定义
  57.               C:方法定义的时候，参数是用，隔开的
  59.               D:方法在调用的时候，不用在传递数据类型
  61.               E:如果方法有明确的返回值类型，就必须有return语句返回。
  63.      (6)方法重载
  65.               在同一个类中，允许存在一个以上的方法同名，只要它们的参数个数或者参数类型不同即可。与返回值无关，只看方法名和参数列表。
  69.               参数列表不同：
  71.                       参数的个数不同。
  73.                       参数的对应的数据类型不同。

2:数组(掌握)
(1)数组：存储同一种数据类型的多个元素的容器或者集合。

  1. (2)特点(获取数组中的元素)：每一个元素都有编号，从0开始，最大编号是长度-1。
  3.               编号的专业叫法：索引
  5.      (3)定义格式
  7.               A:数据类型[] 数组名;
  9.               B:数据类型 数组名[];
  13.               推荐是用A方式，B方法就忘了吧。
  15.               但是要能看懂

举例：

  1. A:int[] a; 定义一个int类型的数组a变量
  3.               B:int a[]; 定义一个int类型的a数组变量
  7.      注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。
  9.      (4)数组的初始化
  11.               Java中的数组必须先初始化，然后才能使用。所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。数组的初始化方式有2种动态初始化和静态初始化。
  13.               A:动态初始化
  15.                       初始化只指定数组长度，由系统为数组分配初始值
  17.                       格式：数据类型[] 数组名 = new数据类型[数组长度];数组长度其实就是数组中元素的个数
  21.                       举例：int[] arr = new int[3];//定义了一个int类型的数组,这个数组中可以存放3个int类型的值.

详解: int[] arr = new int[3];

  1. /*
  3.                       左边：
  5.                                int:说明数组中的元素的数据类型是int类型
  7.                                []:说明这是一个数组
  9.                                arr:是数组的名称
  13.                       右边：
  15.                                new:为数组分配内存空间。
  17.                                int:说明数组中的元素的数据类型是int类型
  19.                                []:说明这是一个数组
  21.                                3:数组长度，其实也就是数组中元素的个数
  23.               */
  25.               B:静态初始化
  27.                        初始化时指定每个数组元素的初始值，由系统决定数组长度。
  29.                       格式：数据类型[] 数组名 = new 数组类型[]{元素1,元素2,……};
  33.                       举例：int[] arr = new int[]{1,2,3};//定义了一个int类型的数组,这个数组中可以存放3个int类型的值,并且值分别是1,2,3.
  35.                       简化版：int[] arr = {1,2,3};

注意:不要数组初始化,不要动态和静态同时都进行.

如下格式:int[] arr = new int[3]{1,2,3};//错误

  1. (5)Java的内存分配
  3.               A:栈 存储局部变量
  5.               B:堆 存储所有new出来的
  7.               C:方法区(面向对象部分详细讲解)
  9.               D:本地方法区(系统相关)
  11.               E:寄存器(CPU使用)
  15.               注意：
  17.                       a:局部变量 在方法定义中或者方法声明上定义的变量。
  19.                       b:栈内存和堆内存的区别
  21.                                栈：数据使用完毕，就消失。
  23.                                堆：每一个new出来的东西都有地址
  25.                                    每一个变量都有默认值
  27.                                                  byte,short,int,long 0
  29.                                                  float,double 0.0
  31.                                                  char '\u0000'
  33.                                                  boolean false
  35.                                                  引用类型 null
  37.                                    数据使用完毕后，在垃圾回收器空闲的时候回收。
  39.      (6)深入数组——数组内存图
  45.                数组在内存之中到底是如何存储的.

A. 内存主要分为两块空间.

栈空间:

堆空间:

栈和堆的作用是用来存储数据的.不同的数据存储在不同的空间之中,方便管理这些数据.

B. int类型的变量开辟在栈空间之中.变量的值直接存储在该变量之中.

数组在内存之中存储的真正的方式:

int[] arr = new int[3];

数组变量arr仍然开辟在栈空间之中.

new int[3];在堆空间中开辟连续的3块int类型的空间 然后将第1个空间的地址返回赋值给arr变量

所以,数组变量arr之中存储的是数组在堆空间中的地址.

总结:

int 变量开辟在栈空间. 真实的值存储在这个变量之中.

int[]变量开辟在栈空间,真实的值(真正的数组)存储在堆空间之中. 变量中存储的是真实的值在堆空间中的地址

C:三个数组(两个栈变量指向同一个堆内存)

栈内存有2个引用指向同一个堆内存的空间。

无论是他们谁的操作，都是针对同一个地方。

int[] arr = new int[3] { 10, 20, 30 };

int[] newArr = arr;

newArr[0] = 100;

System.out.println (arr[0]);//100

  1. (7)数组的常见操作
  3.               A:遍历
  5.                       方式1：
  7.                                public static void printArray(int[] arr) {
  9.                                         for(int x=0; x<arr.length; x++) {
  11.                                                  System.out.println(arr[x]);
  13.                                         }
  15.                                }
  19.                       方式2：
  21.                                public static void printArray(int[] arr) {
  23.                                         System.out.print("[");
  25.                                         for(int x=0; x<arr.length; x++) {
  27.                                                  if(x == arr.length-1) {
  29.                                                          System.out.println(arr[x]+"]");
  31.                                                  }else {
  33.                                                          System.out.println(arr[x]+", ");
  35.                                                  }
  37.                                         }
  39.                                }
  41.               B:最值
  43.                       最大值：
  45.                                public static int getMax(int[] arr) {
  47.                                         int max = arr[0];
  51.                                         for(int x=1; x<arr.length; x++) {
  53.                                                  if(arr[x] > max) {
  55.                                                          max = arr[x];
  57.                                                  }
  59.                                         }
  63.                                         return max;
  65.                                }
  69.                       最小值：
  71.                                public static int getMin(int[] arr) {
  73.                                         int min = arr[0];
  77.                                         for(int x=1; x<arr.length; x++) {
  79.                                                  if(arr[x] < min) {
  81.                                                          min = arr[x];
  83.                                                  }
  85.                                         }
  89.                                         return min;
  91.                                }
  93.               C:逆序
  95.                       方式1：
  97.                                public static void reverse(int[] arr) {
  99.                                         for(int x=0; x<arr.length/2; x++) {
  101.                                                  int temp = arr[x];
  103.                                                  arr[x] = arr[arr.length-1-x];
  105.                                                  arr[arr.length-1-x] = temp;
  107.                                         }
  109.                                }
  113.                       方式2：
  115.                                public static void reverse(int[] arr) {
  117.                                         for(int start=0,end=arr.length-1; start<=end; start++,end--) {
  119.                                                  int temp = arr[start];
  121.                                                  arr[start] = arr[end];
  123.                                                  arr[end] = temp;
  125.                                         }
  127.                                }
  129.               D:查表
  131.                                public static String getString(String[] strArray,int index) {
  133.                                         return strArray[index];
  135.                                }
  137.               E:基本查找
  139.                       方式1：
  141.                                public static int getIndex(int[] arr,int value) {
  143.                                         for(int x=0; x<arr.length; x++) {
  145.                                                  if(arr[x] == value) {
  147.                                                          return x;
  149.                                                  }
  151.                                         }
  155.                                         return -1;
  157.                                }
  161.                       方式2：
  163.                                public static int getIndex(int[] arr,int value) {
  165.                                         int index = -1;
  169.                                         for(int x=0; x<arr.length; x++) {
  171.                                                  if(arr[x] == value) {
  173.                                                          index = x;
  175.                                                          break;
  177.                                                  }
  179.                                         }
  183.                                         return index;
  185.                                }

3:二维数组(理解)
(1)元素是一维数组的数组。

(2)格式：

A:数据类型[][] 数组名 = new 数据类型[m][n];

m表示这个二维数组有多少个一维数组

n表示每一个一维数组的元素个数

举例：

  1. int[][] arr = new int [3][2];
  3.      定义了一个二维数组arr
  5.      这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
  7.      每个一维数组有2个元素，可以通过arr[m][n]来获取

表示获取第m+1个一维数组的第n+1个元素

B:数据类型[][] 数组名 = new 数据类型[m][];

m表示这个二维数组有多少个一维数组

这一次没有直接给出一维数组的元素个数，可以动态的给出

举例：

  1. int[][] arr = new int[3][];
  3.      arr[0] = new int[2];
  5.      arr[1] = new int[3];
  7.      arr[2] = new int[1];

二维数组名配合一个编号，拿的是一维数组名

配合两个编号，拿的是二维数组元素

C:

基本格式:

数据类型[][] 数组名 = new 数据类型[][]{ {元素…},{元素…},{元素…}};

简化版格式：

数据类型[][] 数组名 = { {元素…},{元素…},{元素…}};

举例:

  1. int[][] arr = {
  2.    {1,2,3},{4,6},{6}};
  4.               D:数据类型[][] 数组名 = {
  5.    {...},{...},{...}};
  7.      (3)案例(掌握):
  9.               A:二维数组的遍历
  11.               B:二维数组的求和
  13.               C:杨辉三角形

4:两个思考题(理解)

  1. (1)Java中的参数传递问题
  3.               Java中只有值传递。
  7.               基本类型：形式参数的改变不影响实际参数
  9.               引用类型：形式参数的改变直接影响实际参数
  11.      (2)数据加密问题
  13.               综合的小案例。

发表评论

表情：
评论列表 （有 0 条评论，255人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java基础---基本语法(下)

    1、程序流程控制简介 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。其流程控制方式采用结构化程序设计中规定的三种基本流程结

    骑猪看日落骑猪看日落/ 0 赞/ 455 阅读

    相关 Java 基础语法

    一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。 - **对象**：对象是类的一个...

    小灰灰小灰灰/ 0 赞/ 2394 阅读