JAVA重载|递归|数组|内存

重载Overload ****

方法重要的特性--->方法的重载

实现重载的3个条件 :

1.同一个类中的多个方法

2.方法名相同

3.参数列表不同 | 方法签名不同

参数个数
参数类型不同
不同类型的参数顺序不同

    public static void main(String[] args) {
        getsum(1,2);
    }
    public static void getsum(int x,int y){
        System.out.println(x+" + "+y+" = "+(x+y));
    }
    public static void getsum(double x,int y){
        System.out.println(x+" + "+y+" = "+(x+y));
    }
    public static void getsum(int x,double y){
        System.out.println(x+" + "+y+" = "+(x+y));
    }
    public static void getsum(int x,int y,int z){
        System.out.println(x+" + "+y+" + "+z+" = "+(x+y));
    }

• 注意：

1.调用函数时，先调用参数列表最匹配的，如果没有，参数类型可以向下兼容，但是如果有多个可以兼容的，那么同样也会报错

方法签名 : 方法的唯一标识 方法名+参数列表

重载方法如何调用 : 只根据实参决定

2. 问 :

方法的重载与修饰符是否由有关-->无关

方法的重载与返回值类型是否由有关-->无关

方法的重载与参数名是否由有关-->无关

3.面向对象的三大特性 : 封装 继承 多态

方法就是封装非常具体的体现

类中方法的重载就是多态的一种体现

递归 : 理解

方法内部自己调用自己

递归分类 :

直接递归 : a方法中调用a方法

间接递归 : a方法中调用b方法,b方法中调用方法

递归的实现满足的条件 :

1.递归前进段 : 从第一次调用方法,到临界条件之间,不停的自己调用自己的过程

2.递归后退段 : 达到临界条件之后,将结果返回给上一层的过程

3.临界条件 : 停止自己调用自己的条件

递归优缺点

递归的优点 :

恰当位置使用简单,灵活

递归的缺点 :

容易造成递归死循环,造成栈内存溢出的问题

递归题目的解题思路

    //递归实现1+2+3+.....+n
//1.终止条件-----》n==1
//2,递归关系-----》n项求和等于第n项加上前n-1项求和
    public static int sum(int n){
        if(n<=0){
            return -1;
        }
        if(n==1){
            return 1;
        }else{
            return (n+sum(n-1));
        }

    }

数组

变量和数组：

变量 : 存储单个数据
数组 ：存储多个数据

数组定义：

在内存中是一段连续的内存空间,线性序列

相同数据类型数据的有序集合

数组特点 :

• 1.引用数据类型 []

基本数据类型的数据为对应类型数据值 100 false 'a'

引用数据类型的数据为对象数据 new

• 2.定长,长度一旦确定不可改变

• 3.存储的多个数据要求类型相同

• 4.有序的,索引,根据根据索引区分数组中的每一个空间

索引 :

是数组连续内存空间中每一个空间得到唯一标识

根据索引操作数组中的数据 数组名[索引]

        //获取数组中的值
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        //System.out.println(arr1[3]);
        arr1[1] = 2000;
        System.out.println(arr1[1]);

索引从0开始每次+1

最后一个空间的索引为 : 数组名.length-1

长度 : 数组名.length

定义数组 :

数组的声明 :

数据类型 变量名; -->变量的声明

数组的声明 :

数据类型[] 数组名; --> 推荐

数据类型 数组名[];

数据类型 []数组名;

  //声明
        int[] arr1;
        char arr2[];
        boolean []arr3;

初始化 :

动态初始化 : 先创建数组后赋值

数据类型[] 数组名 = new 数据类型[长度];

数据类型 : 可以为任意数据类型(基本|引用)

长度 : 整数 0~n

        //动态初始化
        arr1 = new int[3];

静态初始化 : 创建数组的同时赋值

数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3....};

数据类型[] 数组名 = {数据1,数据2,数据3....};

        //静态初始化
        arr2 = new char[]{'a','b','c','d'};
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);

默认值 : 数组创建没有赋值,存在默认值

整数 : 0

小数 : 0.0

布尔 : false

字符 : 空字符

数组的遍历

for --> 在任意位置迭代

通过for的条件i控制数组的索引变化,在循环体中根据索引操作数组中的数据

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

foreach ---> 只能正向迭代

for(数据类型 变量名:数组名|集合名){

根据变量名是使用数组中的每一个数据

}

for(String str:arr){
            System.out.println(str);
        }

通过普通for循环对数组赋值

 //定义一个数组,为数组赋值,从前到后值为10,11,12,13,14,15
        int[] arr2 = new int[5];
        /*arr2[0] = 10;
        arr2[1] = 11;*/

        //for循环控制索引可以实现为数组赋值
        int num = 10;
        /*for(int i=0;i<=arr2.length-1;i++){
            arr2[i]=num++;
        }*/

增强for循环foreach不能对数组赋值，因为操作的是变量i不是数组的索引

//foreach只能遍历,不能赋值,因为i不是索引,只是for循环的局部变量
        for(int i:arr2){
            i=num++;
        }

        for(int i:arr2){
            System.out.println(i);
        }

赋值失败

JAVA内存分布