Java肝货基础，分享出来和大家共同进步

驾驭命运的舵是奋斗。不抱有一丝幻想，不放弃一点机会，不停止一日努力。

方法

• java中，方法类似于c语言中的函数

  public static void main(String[] args)
  {
      //这个是main方法
  }
  
  public static int add(int a,int b){
  	return a+b;
      //这个是自己创建的方法
  }
  

方法的重载

• 方法的名字必须相同
• 参数列表必须不同(参数个数 参数类型 参数排列顺序)
• 方法的返回类型可以相同可以不同
• 仅仅返回类型不同不足以称为方法的重载

命令行传参

可变参数

• 在方法声明中，在指定参数类型后面加一个省略号（…）
• 一个方法中,只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在他的前面声明

public class Demo1 {
    public static void main(String[] args) {
        //方法重载
        ptintMax(1,2,3,4,5,6,9,8,7,0);
        ptintMax(new double[]{1,9,8,7,6,5,10,4,3,2,1});
    }

    public static void ptintMax(double...numbers) {//可变参数
        if(numbers.length==0){
            System.out.println("No Numbers Pass");
            return;
        }
        double result=numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if(result<numbers[i]){
                result=numbers[i];
            }
        }
        System.out.println("the maxNumber is:"+result);
    }
}

递归

• 面试笔试高频出现
• 递归包括两部分
  1. 递归头:什么时候不调用自身方法。如果没有头将陷入死循环
  2. 递归体：什么时候需要调用自身方法

实现简易版计算机

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Demo1 demo1=new Demo1();
        while(true){
            Scanner scanner=new Scanner(System.in);
            System.out.print("请输入第一个数：");
            double num1=scanner.nextDouble();
            System.out.print("请输入 + - * / EOF 其中的一个运算符 :");
            String ch=scanner.next();
            System.out.print("请输入第二个数: ");
            double num2=scanner.nextDouble();
            if(ch.equals("EOF")){
                break;
            }
            switch (ch){
                case "+":
                    System.out.println(num1 + ch + num2+"="+ demo1.addNum(num1,num2));
                    break;
                case "-":
                    System.out.println(num1 +ch+ num2+"="+demo1.subNum(num1,num2));
                    break;
                case "*":
                    System.out.println(num1+ch+num2+"="+demo1.mulNum(num1,num2));
                    break;
                case "/":
                    if(num2==0){
                        System.out.println("除数输入不合法！");
                    }
                    else {
                        System.out.println(num1+ch+num2+"="+demo1.divNum(num1,num2));
                    }
                    break;
                default:
                    System.out.println("输入有误");
                    break;
            }
        }
    }
    public  static  double addNum(double num1,double num2){
        return  num1+num2;
    }
    public  static double subNum(double num1,double num2){
        return  num1-num2;
    }
    public  static  double mulNum(double num1,double num2){
        return  num1*num2;
    }
    public  static double divNum(double num1,double num2){
            return num1/num2;
    }
}

数组

数组小知识点

• 数组是相同(不允许出现混合类型)数据类型(可以是任意数据类型(包括基本类型和引用类型))的有序集合
• 数组也是对象，数组的元素相当于对象的成员变量
• 下标的合法区间是[0,length-1]
• 数组的长度是确定的，不可变的，如果越界，则会报错;ArrayIndexOutOfBounds
• 数组对象本身是在堆中的

//数组的声明与创建
int[] a=new int[10];

数组的使用

• For Each循环
• 数组做方法入参
• 数组做返回值

 //for each的简单使用
public class Demo1 {
    public static void main(String[] args) {
       int[] a={1,2,3,4,5,6,7,8};
        for (int i : a) {  //a代表数组；int i代表数组中的每一个元素
            System.out.println(i);
        }
        //没有下标，适合打印输出
    }
}

//下面以一个简单的例子来说明数组做方法入参以及数组做返回值
public class Demo1 {
    public static void main(String[] args) {
       int[] a={1,2,3,4,5,6,7,8};
       printArray(a);
       //数组反转
        System.out.println("反转之后");
        int[] reverse=reverse(a);
        printArray(reverse);
    }
    public  static  void printArray(int[] arr){//数组做方法入参
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

    public  static int[] reverse(int[] arr){//这里数组既作为方法了形参，又作为了方法返回值
        int[] result=new int[arr.length];
        for(int i=0, j=arr.length-1;i<arr.length;i++,j--){
            result[j]=arr[i];
        }
        return result;
    }
}

二维数组

图例分析

• 通过下面这张我自己画的图片，我相信大家因该堆二维数组有了一个初步的理解了吧。

代码分析

public class Demo1 {
    public static void main(String[] args) {
        int [][] arr={{1,2,3},{4,5,6},{7,8,9}};//二维数组的声明&&创建
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}
//输出结果
1	2	3	
4	5	6	
7	8	9	

稀疏数组

• 当一个数组中大部分元素为0或者为同一个值的时候，可以使用稀疏数组来保存该数组

• 稀疏数组的处理方法

  1. 记录数组一共有几行几列，有几个不同的值
     2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 代码演示

public class Demo1 {
    public static void main(String[] args) {
        int[][] arr=new int[11][11];
        arr[1][2]=1;
        arr[2][3]=2;
        for (int[] ints : arr) {
            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(arr[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("************************************");
        //构建并输出稀疏数组
        int[][]  arr2=new int[sum+1][3];
        arr2[0][0]=11;
        arr2[0][1]=11;
        arr2[0][2]=sum;
        int row=1;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(arr[i][j]!=0){
                    arr2[row][0]=i;
                    arr2[row][1]=j;
                    arr2[row][2]=arr[i][j];
                    row++;
                }
            }
        }
        for (int[] ints : arr2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("----------------------------------");
        //读取稀疏数组
        int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
        }
        for (int[] ints : arr3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

java内存分析

• 堆

  1. 存放new的对象和数组
  2. 可以被所有的线程共享，不会存放别的对象引用

• 栈

  1. 存放基本变量类型(包含这个基本类型的具体数值)
  2. 引用对象的变量(会存放这个引用在堆里面的具体地址)

• 方法区

  1. 可以被所有的线程共享
  2. 包含了所有的class和static变量

• 通过声明并且创建一个数组来简单说明内存分配,应该能大致知道数组声明和创建在栈和堆中是如何分配了

小结

这篇博客当中包含许多代码，如果小伙伴有那点不懂或者自己写的代码有错误的都可以在评论区里面留言，我会和大家一起探讨解决的。下一篇博客我讲重点的写面向对象的知识，是重点！！！在后续我也会把我之前自己在学习c语言的时候整理的细节知识点和自己做题时碰到的知识点错题都整理一下分享给大家！以及c语言数据结构相关的知识我也会在后续整理出来分享给需要的小伙伴的！

---

只会幻想而不行动的人，永远也体会不到收获果实时的喜悦