学习java基础第二天笔记

于 2021-03-14 21:40:47 发布
阅读量199 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52854229/article/details/114805210
版权

java方法

何谓方法

system.out.println()

system是一个类,out输出结果,println是方法

Java方法是语句的集合，它们在一起执行一个功能。

  • 方法是解决一类问题的步骤的有序组合

  • 方法包含于类或对象中

  • 方法在程序中被创建，在其他地方被引用

  • 设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

    public class methodDome01 {
    public static void main(String[] args) {
       int sum = add(1,2) ;
        System.out.println(sum);
    }


    //加法
    public static int add(int a, int b){
        return a+b;
    }
}

方法的定义和调用

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型∶方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。

方法名:是方法的实际名称。方法名和参数表共同构成方法签名。

参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

​ **形式参数:**在方法被调用时用于接收外界输入的数据。 —自己定义那种

​ **实参:**调用方法时实际传给方法的数据。 —编辑程序调用那块要用

方法体:方法体包含具体的语句，定义该方法的功能。

以下方法实例:

package method;


public class Demo02 {
    public static void main(String[] args) {
        int max = max(10,20);
        System.out.println(max);
    }

    //比大小
    public static int max(int num1,int num2){
        int result = 0;
        if(num1 == num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }

        else if(num1 > num2) {
            result = num1;
        }else
            result = num2;


        return result; //
    }
}

java只有值传递

方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

eg;就是同一个文件中,名字一模一样,但是参数值类型不一样

◆方法的重载的规则:

  1. 方法名称必须相同

  2. 方法的返回类型可以相同也可以不相同。

  3. 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)

  4. 仅仅返回类型不同不足以成为方法的重载。

    实现理论:

    1. 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法，如果匹配失败，则编译器报错。

    2. 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。

命令行传参

可变参数

递归

  • A方法调用B方法，我们很容易理解

  • 递归就是:A方法调用A方法!就是自己调用自己

  • 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

  • 递归结构包括两个部分:
    递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。

    递归体:什么时候需要调用自身方法。

eg:递归阶乘

package method;

public class Demo03 {
    public static void main(String[] args) {
	System.out.println(f(4));
    }
  // 3  3*f(3-1)*f(2-1)
    public static  int f(int n){
        if(n==1)
            return 1;
        else
            return n*f(n-1)  //大事化小小事化了
    }
}


边界条件:边界(上图f1的时候)
    前阶段:不停的调用
    返回阶段:返回的具体的值

数组

数组概述

数组的定义:

​ 数组是相同类型数据的有序集合.
​ 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
​ 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:
dataType[ ] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下:

dataType[ ] arrayRefVar = new dataType[arraysize];

数组的元素是通过索引访问的，数组索引从0开始。

获取数组长度: arrays.length

学习声明创建数组

package array;

public class arrayDemo01 {
    //变量类型   变量名字  = 变量的值
    public static void main(String[] args) {
    int [] nums;        //1.声明

        nums = new int[10]; //2.创建数组-----可以存放10个int类型数字

        //3.给数组元素赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        //计算全部元素和

        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println("总和为:"+sum);
    }
}

当已经给数组分配空间后,没有给赋值,那么默认该值为0

当给数组分配了10个空间,用第11个会发生报错–数组下标越界

内存分析

java内存:

      1. 堆: 
      2. 栈:

三种初始化

  • 静态初始化

    int[] a = {1,2,3};
Man[ ] mans = {new Man(1,1),new Man(2,2)};

    动态初始化

    int[] a = new int[2];a[0]=1;
a[1]=2;

    package array;

public class arrayDemo02 {
    public static void main(String[] args) {
        //静态初始化:创建+赋值
        int [] a = {1,2,1,3,4,5,6};
        System.out.println(a[1]);

        //动态初始化:
        int [] b = new int[10];
        b[0] = 1;
        System.out.println(b[0]);
        //已经分配空间但是没有赋值,这时候默认是0
    }
}

    数组的默认初始化
    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的四个基本特点

  • 其长度是确定的数组一旦被创建，它的大小就是不可以改变的。
  • 其元素必须是相同类型,不允许出现混合类型。(同为int类型不能越界)
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型
  • 数组对象本身是在堆中的。

数组边界

  • 下标的合法区间:[0, length-1]，如果越界就会报错;(从0开始的)

    .length ---- 是获取上文数组的长度的一个值,经常用在循环遍历数组的时候,恰好把数组遍历一遍

    public static void main(String[] args) {
int[ ] a=new int[2];
system.out.println(a[2]);
}

    报错提示::::ArraylndexOutOfBoundsException :数组下标越界异常!
    小结:

    • 数组是相同数据类型(数据类型可以为任意类型)的有序集合数.组也是对象。
    • 数组元素相当于对象的成员变量
    • 数组长度的确定的，不可变的。如果越界，则报:ArrayIndexOutofBounds

数组使用

遍历数组方法

package array;

public class arrayDemo03 {
    public static void main(String[] args) {
    
        int[] arrays = {1,2,3,4,5};
        //打印全部元素数组
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("========================");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("和为:" + sum);
        System.out.println("============================");

        //找最大元素
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if(arrays[i]>max)
                max = arrays[i];
        }
        System.out.println("最大的值max为:" + max);
        
    }
}

数组打印和翻转实例

package array;

public class arrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
//增强for循环
//        for (int array : arrays) {  //娶不到下标
//            System.out.println(array);
//        }
        printArray(arrays);
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }


    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);
        }
    }


    //翻转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
            //让进来的i依次给到新定义的j,最后让i++,j--
        }

        return result;//结果返回去
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

  • 二维数组

    int a[][] = new int[2][5];

    解析:以上二维数组a 可以看成一个两行五列的数组。
    思考:多维数组的使用?

package array;

public class arrayDemo05 {
    public static void main(String[] args) {
//     [4][2]
/*      1,2   array[0]
        3,4   array[1]
        5,6   array[2]
        7,8   array[3]
 */
        int[][] array = {{1,2},{3,4},{5,6},{7,8}};
        printArray(array[0]);
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
    }
}

Arrays类

冒泡排序

最出名的排序 —两两比较,取出大的

冒泡排序的代码是两次循环,外层冒泡轮数,内层依次比较,江湖中人人皆知

package array;

import java.util.Arrays;

public class arrayDemo07 {
    public static void main(String[] args) {
    int[] a = {1,2,3,4,5,6,7};
    int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }


    //冒泡排序
    //1. 比较数组中,两个相邻的元素,,如果第一个数比第二个大,我们就交换他们的为位置
    //2.每一次比较都会产生出一个最大的或者最小的数字
    //3. 依次循环,知道结束
    public static int[] sort(int[] array){
        int temp = 0;
        //外层循环,判断我们这个要走多少次(length-1)
        for (int i = 0; i < array.length-1; i++) {
            //内层循环,比较两个数大小,,第一个比第二个大就交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                //-1,是因为数组下标从0开始,-i是因为,,上一步产生出最大的数字就要拿走,会使其减少一个
                if(array[j+1] > array[j]){  //如果从小到大就改大鱼号即可
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;  //借助第三变量交换位置
                }
            }
        }
        return array;
    }
}

稀疏数组

是一个数据结构

package array;

public class arrayDemo08 {
    public static void main(String[] args) {
        //1.创建二维数组  11*11    0没有棋子---1:黑棋----2:白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }


        //转化为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j] != 0){//遍历二维数组,遇到0则加sum
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数:" + sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组  将非0 的值存放在稀疏数组中
        int count =0 ;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][0] = j;
                    array2[count][0] = array1[i][j];
                }
            }
        }
        //输出数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t");
        }
    }
}
LA-ZY
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值