Java基础(2)

2022/6/30 1:22:47

本文主要是介绍Java基础(2),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java基础(2)

方法

方法:一些语句集合在一起,有序的执行,实现某个功能

方法名:首字母小写加驼峰原则

设计原则:一个方法最好只执行一个功能,使其具有具有原子性。

方法定义

修饰符 返回值类型 方法名(参数){

方法体:具体用一些代码片段来实现功能

}

返回值类型:void表示没有返回值,其他类型均由return返回

参数:这里是形式参数,相当于一个占位符,也可以没有这个参数

值传递和引用传递

值传递:传递的是实参本身值的大小,方法中修改参数的值对实参没有影响。(Java中都是值传递)

引用传递:传递的是实参对象所在的内存空间的地址,方法中修改参数的值,就相当于修改内存地址中的值,是会影响实参的。

重载

重载:一个类中的可以有多个方法名相同而参数类型不同的方法

  1. 方法名必须相同

  2. 参数类型必须不同(可以是参数的数据类型不同,参数个数不同,参数顺序不同)

  3. 返回值类型可以相同也可以不同

命令行传参

使用doc窗口传参

public class Demo {
    public static void main(String[] agrs){
        for(int i=0;i<=agrs.length;i++){
            System.out.println("agrs["+i+"]:"+agrs[i]);
        }
    }
}
​
Doc命令:
//编译Java文件,使其变成.class文件(注意要在对应的包的下面执行)
D:\代码练习\untitled\src\comm>javac Demo.java  
//传参数的时候要退回到src下面进行操作
D:\代码练习\untitled\src\comm>java Demo this is lerry
错误: 找不到或无法加载主类 Demo
原因: java.lang.NoClassDefFoundError: comm/Demo (wrong name: Demo)
//注意在src目录下要写带包名的完整路径
D:\代码练习\untitled\src>java comm.Demo this is lerry
agrs[0]:this
agrs[1]:is
agrs[2]:lerry
​

可变参数

像一个方法中传入不确定个数的变量,相当于是传入了一个数组

  1. 在参数的数据类型后加... ,表示传入的参数数量可变

  2. 可变参数必须是最后一个传入的参数

  3. 这一系列传入的参数数据类型都相同

public class Demo {
    public static void main(String[] agrs){
        Max(1,2,3,4,5,6);
    }
    public static void Max(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
    }
}

递归

一个方法调用自己本身

递归头:调用什么时候结束

递归体:调用什么时候开始

public class Demo {
    public static void main(String[] agrs){
       System.out.println(f(5));
    }
    //计算阶乘
    public static int f(int n){
        if(n==1){
            return 1;
        }
        else{
            return n*f(n-1);   //在n!=1时调用自己
        }
    }
}
​

 

数组

数组的声明和创建

  1. 声明:数据类型[] 数组名; 例如:int[] a; //定义了一个int类型的数组a;

    此时会在栈里面压入一个a对象。

  2. 创建:将新定义的数组使用new赋值; 例如:a=new int[10]; //数组a里面可以存放十个数字

    此时会在堆里面创建一块区域给a,其中被分为10块,用来存放数组值

  3. 赋值:逐个给数组元素赋值; 例如:a[0]=1;a[1]=2;.... //默认值为0

    此时堆里的小块开始存入具体数值

注意:数组下标是从0开始的

数组三种初始化

  • 静态初始化:int[] a={1,2,3,4}; 其空间大小和数值将不再改变

  • 动态初始化(包括了默认初始化):int[] a=new int[10]; 空间大小不可变,数值需要后续赋值

  • 默认初始化:当在堆中分配了一片空间的时候,就会自动为其赋默认值

特点

  • 数组已经创建空间大小就是固定的,不可改变

  • 数组里的每个元素本身就是一个对象

  • 数组类型可以是基本类型,也可以是引用类型

  • 数组中所有元素的数据类型必须相同

数组越界

数组的合法区间为[0,length-1]

当超过这个区间时,就会报错“ArrayIndexOutOfBoundsException”,表示查找数组越界。

for(int i=0;i<a.length;i++){    //i=0~i=a.length-1 是合法的;不能使用i<=a.length,会越界
    System.out.println(a[i]);
}

数组使用

import java.util.*;
public class start {
    public  static  void  main(String[] agrs){
        int[] a={1,2,3,4,5};
​
        //for-each循环打印
        for(int i:a){
            System.out.print(i+" ");
        }
        System.out.println("");
​
        //作为传参
        int[] b=reverse(a);
        
        //普通for循环
        for(int i=0;i<b.length;i++){
            System.out.print(b[i]+" ");
        }
    }
​
    //反转
    public static int[] reverse(int[] a){
        int[] b=new int[a.length];
        for(int i=0;i<a.length;i++){
            b[a.length-1-i]=a[i];
        }
        //数组作为返回值
        return b;
    }
​
}

二维数组

  1. 定义:

    int[][] a={{1,2,3},{4,5,6},{7,8,9}};
    相当于定义了一个3行3列的数组:
          a[i][0] a[i][1] a[i][2]
      a[0]   1       2       3
      a[1]   4       5       6
      a[2]   7       8       9
  2. 使用:

    public class Arry01 {
        public static void main(String[] args) {
            int[][] a={{1,2},{3,4},{5,6}};
            //二维数组逐个打印
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++){
                    System.out.println(a[i][j]);
                }
            }
        }
    }

Arrays类

  1. Arrays.toString(a):将数组打印出来

  2. Arrays.sort(a):数组按升序排列

  3. Arrays.equals(a,b):两个数组判断是否相等,返回值为布尔值类型

  4. Arrays.swap(a,i,j):将数组中a[i]和a[j]元素交换

  5. Arrays.fill(a,7):将数组中所有元素赋值为7

冒泡排序

int temp=0;
        for(int i=0;i<arrays.length;i++){
            for(int j=0;j<arrays.length-1-i;j++){
                if(arrays[j+1]<arrays[j]){        //升序arrays[j+1]<arrays[j] 降序arrays[j+1]>arrays[j]
                    temp=arrays[j+1];
                    arrays[j+1]=arrays[j];
                    arrays[j]=temp;
                }
            }
        }

稀疏数组

int[][] a2=new int[count+1][3];
​
a2[0][0]=5;
a2[0][1]=5;
a2[0][2]=count;
​
int n=0;
for(int i=0;i<a1.length;i++){
    for(int j=0;j<a1[i].length;j++){
        if(a1[i][j]!=0){
            n++;
            a2[n][0]=i;
            a2[n][1]=j;
            a2[n][2]=a1[i][j];
        }
    }
}
​
稀疏数组:
        行          列               值
[0] 原数组行数    原数组列数   原数组中不为0的元素个数
[1] 不为0元素行   不为0元素列      不为0元素值
......




这篇关于Java基础(2)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程