JAVASE-05：二维数组、递归和面向对象

绝世球王秃光光

于 2020-07-20 10:27:12 发布

阅读量188

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/Hannen/article/details/107457924

版权

JavaSE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

1. 数组（续）

a. 数组长度一旦定义好就固定了；

b. 数组不但可以存储基本数据类型，还可以存储引用数据类型，引用数据类型包括数组、类、接口，也就是说new出来的数据就是引用数据类型。

例3. 数组查表法根据索引查找对应星期

技巧：快速生成方法

getWeek(index,week);

先写方法名和返回值调用方法然后用alt+enter

return week[index];

或

String str = week[index];

return str;

package org.westos.KeTang;

import java.util.Scanner;

public class weekPP {
    public static void main(String[] args) {
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想查询的索引(0--6)：");
        int num = sc.nextInt();

        String day = getWeek(num, week);
        System.out.println(day);
    }

    private static String getWeek(int num, String[] week) {
        if (num >= 0 && num <= 6) {
            String str=week[num];
            return str;
        }else{
            return "输入的索引不正确，没有查到该元素";
        }
    }

}

...
// 这种形式也可以
getWeek(num, week);
    System.out.println(week[num]);
}

private static String getWeek(int num, String[] week) {
    if (num >= 0 && num <= 6) {
        return week[num];
    }else{
        return "输入的索引不正确，没有查到该元素";
    }
}

例4. 录入星期返回数值

“星期一”==“星期一” 想要判别两个字符串字面上的内容是否相同 == 判别不出来。
要判别两个字符串字面上的内容是否相同，使用字符串中的方法 equals()

package org.westos.KeTang;

import java.util.Scanner;

public class WeekHQ {
    public static void main(String[] args) {
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期：");
        String num = sc.nextLine();

        int day = getWeekHQ(num, week);
        System.out.println("这天对应的索引是：" + day);
    }

    private static int getWeekHQ(String num, String[] week) {
        int index = -1;
        for (int i = 0; i < week.length; i++) {
            if (num.equals(week[i])) {
                //return i;
                index = i;
                break;
            }
        }
        //-1 表示没有找到
        return index;
    }

}

1.1 二维数组

二维数组概述元素为一维数组的数组，数组嵌套数组

语法格式：

动态初始化–自己定义数组维度，让系统赋予其默认值

int[][] arr1 = new int[3][2];
//其他的定义方式

int arr2[][] = new int[3][4];

int[] arr3[] = new int[2][3];

第一行中，3表示二维数组长度，也就是说这个二维数组中可以放3个一维数组（这里的‘3’必须写），2表示二维数组中一维数组的长度（这里可写可不写，如果不写则不会初始化二维数组中的一维数组，二维数组内的元素是一维数组，一维数组是引用数据类型，默认初始化值为null，相当于arr[0]=null ，null[0]取不出来）。

	int[][] arr = new int[3][2];
    // 取出二维数组的元素。
	int[] one=arr[0];
	int[] two=arr[1];
	int[] three=arr[2];

    System.out.println(arr[0]);// 地址值：[I @ 1 b6d3586
    System.out.println(arr[1]);// 地址值：[I @ 4554617 c
    System.out.println(arr[2]);// 地址值：[I @ 74 a14482*
    System.out.println("==========================");

    System.out.println(one);// 地址值：[I @ 1 b6d3586
    System.out.println(two);// 地址值：[I @ 4554617 c
    System.out.println(three);// 地址值：[I @ 74 a14482*
    System.out.println("=================================");

    // 获取数组的长度---3
    System.out.println(arr.length);

    // 取出二维数组中，一维数组中存的值。现在默认是0
    System.out.println(arr[0][0]);
    System.out.println(arr[0][1]);
    System.out.println(arr[1][0]);
    System.out.println(arr[1][1]);
    System.out.println(arr[2][0]);
    System.out.println(arr[2][1]);

    // 赋值，给二维数组中的 一维数组中的 元素 赋值
    arr[0][0]=20;
    arr[0][1]=200;
    arr[1][0]=60;
    arr[1][1]=30;
    arr[2][0]=20;
    arr[2][1]=900;
    System.out.println(arr[0][0]);
    System.out.println(arr[0][1]);
    System.out.println(arr[1][0]);
    System.out.println(arr[1][1]);
    System.out.println(arr[2][0]);
    System.out.println(arr[2][1]);
    System.out.println("============================");

    // 数组中的最后一个元素的索引=数组的长度-1
    System.out.println(arr[arr.length-1][arr[arr.length - 1].length-1]);// arr[2][1]

在这里插入图片描述
a.如果没有定义第二个中括号中的值，不会初始化二维数组中的一维数组，二维数组内的元素是一维数组，一维数组是引用数据类型，默认初始化值为null，相当于arr [0]=null 所以null [0]取不出来；

int[][] arr = new int[3][];
System.out.println(arr);// 1b6d3586
System.out.println(arr[0]);// null
System.out.println(arr[1]);// null
System.out.println(arr[2]);// null

定义了的话初始化二维数组时还会去初始化一维数组，二维元素存的就是一位数组的地址值，会对分离二维数组为对应个数的一维数组，并用0覆盖掉null。

b.可以自己初始化三个一维数组放入二维数组中：

int[][] arr = new int[3][];

int[] one = new int[20];
System.out.println(one); // 地址值
int[] two = new int[12];
int[] three = new int[2];

arr[0] = one;
arr[1] = two;
arr[2] = three;

arr[0] = new int[2];
System.out.println(arr[0]);// 新的地址值
arr[1] = new int[2];
arr[2] = new int[2];

语法注意：

//定义了两个数组
//其中x 是一维数组，y 是个二维数组。
int[] x, y[];

/*
int[] x;
int[] y[];
*/

x=new int[2];
y=new int[2][5];

静态初始化

//二维数组的静态初始化
int[][] arr=new int[][]{{10,20,4},{20,1},{100,300,5}};

//简写格式
int[][] arr2 = {{10, 20, 4}, {20, 1}, {100, 300, 5}};

二维数组的遍历

int[][] arr = {{10, 20, 4}, {20, 1}, {100, 300, 5}};
//遍历二维数组
for (int i = 0; i < arr.length; i++) {
    //System.out.println(arr[i]);
    for (int k = 0; k < arr[i].length; k++) {
        System.out.println(arr[i][k]);
    }
}

例1.销售求和四个季度{22,66,44}，{77,33,88}，{25,45,65}，{11,66,99}

package org.westos.KeTang;

import java.util.Scanner;

public class ErWeiShuZu {
    public static void main(String[] args) {
        // 静态初始化
        int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};

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

        // 动态初始化
        int[][] agg = new int[4][3];
        agg[0]=new int[]{22, 66, 44};
        agg[1]=new int[]{77, 33, 88};
        agg[2]=new int[]{25, 45, 65};
        agg[3]=new int[]{11, 66, 99};
        
        int sum = 0;
        for (int m = 0; m < agg.length; m++) {
            for (int n = 0; n < agg[m].length; n++) {
                sum += agg[m][n];
            }
        }
        System.out.println(sum);

    }
}

例2.打印杨辉三角

1.第一个数和最后一个数都是1

2.从第三行开始从第二例开始中间的每一个数字=上一行的前一列和上一行的本列只和

package org.westos.KeTang;

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想打印的行数：");
        int n = sc.nextInt();
        int[][] arr = new int[n][n];

        // 1.收尾元素是1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = 1;
            arr[i][i] = 1;
        }

        //2.设置中间元素
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j < i; j++) {
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }

        //3.打印三角形
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"\t"); // 去掉ln同行打印
            }
            System.out.println();
        }
    
    }
}

2. 递归

JAVA中的递归指的是：在方法中调用方法本身的现象。

在编写递归时要注意：
1.递归要有出口，不然就是死递归，死递归就会造成’'栈溢出"StackOverflowError"；
2.递归次数不宜过多，也会造成栈溢出；
3.递归所体现的就是一种拆分合并的思想。

public static void main(String[] args) {
    show(10);
}

//StackOverflowError 栈溢出
private static void show(int num) {
    System.out.println("递归");
    num--;
    if(num>1){
        show(num);
    }else{
        return;
    }
}

例：阶乘

public static void main(String[] args) {
        //求5的阶乘
        int num=diGui(5);
        System.out.println(num);
    }

    private static int diGui(int i) {
         if(i==1){
             return 1;
         }else{
             return i*diGui(i-1);
         }
    }

在这里插入图片描述

例：不死神兔

月兔子

1 1

2 1

3 2

4 3

5 5

6 8

7 13

8 21

9 34

… …

菲波那切数列：从第三个数开始后面的每一个数等于它前面的两个数之和

第20个月兔子数？

public static void main(String[] args) {
    int sum = sumRabbit(20);
    System.out.println(sum);
}

private static int sumRabbit(int n) {
    if (n == 1 || n == 2) {
        return 1;
    } else {
        return sumRabbit(n - 1) + sumRabbit(n - 2);
    }
}

3. 调用方法时的参数传递：

在调用方法时，有时需要进行参数传递，有两种情况：

一种是基本数据类型作为参数传递，属于值传递，就是把实参的值传过去，形参的改变不影响实参。在栈中将方法调用执行完毕后弹栈，值不变；

int a = 10;
int b = 20;
System.out.println("1.a: " + a + ",b: " + b); // a10  b20
// 调用方法：把 a 和 b 传过去
change(a, b);
System.out.println("4.a: " + a + ",b: " + b);// a10 b20

public static void change(int a, int b) {
        System.out.println("2.a: " + a + ",b: " + b); // 传入的数据是 a10 b20
        a = b;
        b = a + b;
        System.out.println("3.a: " + a + ",b: " + b);
    	// 在栈中将方法调用执行后运算结果为a20 b40
    }

一种是引用数据类型作为参数传递，属于引用传递，传递的是地址值，形参的改变影响实参。在栈中将方法调用执行，对堆内的空间直接影响。

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr); // 地址值：[I@1540e19d
// 调用方法 ，把数组传递过去
change(arr);
// 打印数组中第二个元素的值。
System.out.println(arr[1]); // 4

public static void change(int[] arr) {
        System.out.println(arr); // 地址值：[I@1540e19d，和上面一样
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] % 2 == 0) {
                arr[x] *= 2; // 为数组中的偶数乘2
            }
        }
}

内存图：
在这里插入图片描述

4. 面向对象

4.1 面向过程思想概述：
我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。
一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索。
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

4.2 面向对象思想特点：
a:是一种更符合我们思想习惯的思想懒人思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者，角色发生了转换

4.3 特征：

封装 encapsulation
继承 inheritance
多态 polymorphism

4.4 面向对象开发：就是不断的创建对象，使用对象，指挥对象做事情。

现实描述一个事物	JAVA中的class 类
属性	成员变量（成员属性）
功能	成员方法（成员功能）

class定义一个类，’类‘体现的就是封装的思想，封装成员属性和成员功能，类是Java语言的最小单位。

成员变量（成员属性）：定义在类中，方法外的变量。

成员方法（成员功能）：以前怎么定义方法现在一样，但是可以去掉static，也可以不去

package org.westos.demo;

public class Person {
    // 成员变量--属性
    String name = "张三";
    int age = 23;
    char sex = '男';

    // 成员方法--功能。
    public void eat() {
        System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
    public void talkLove(String name) {
        System.out.println("跟" + name + "谈恋爱 ");
    }
    
}

定义好类就是想要使用它，可以建立一个测试类，提供一个主方法作为入口，在主方法中使用这个类；
类，本身是一个抽象的概念，不能直接去使用，必须要对类进行实例化，实例化之后才能进行使用；
实例化就是创建该类的对象，然后使用该类的对象，去调用类中的属性和功能；

怎么创建对象？可以使用一个关键字new来完成类的实例化；
创建该类的对象的语法：类名对象名=new 类名()

public static void main(String[] args) {
    // 创建该类的对象的语法： 类名 对象名=new 类名();
    Person p = new Person();
    // 通过对象名，调用类中的属性和方法;
    
    // 1.调用成员变量，获取成员变量的值;
    String mingzi = p.name;
    int age = p.age;
    char ch = p.sex;
    System.out.println("姓名：" + mingzi);
    System.out.println("年龄：" + age);
    System.out.println("性别：" + ch);

    // 2.调用成员方法
    p.eat();
    p.sleep();
    p.talkLove("刘亦菲");

 

    Person p2 = new Person();
    // 3.设置成员变量的值
    p2.name = "王祖贤";
    p2.age = 17;
    p2.sex = '女';
    System.out.println(p2.name);
    System.out.println(p2.age);
    System.out.println(p2.sex);

    p2.sleep();
    p2.eat();
    p2.talkLove("紫霞仙子");

}

绝世球王秃光光

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVASE-05：二维数组、递归和面向对象

1. 数组（续）a. 数组长度一旦定义好就固定了；b. 数组不但可以存储基本数据类型，还可以存储引用数据类型，引用数据类型包括数组、类、接口，也就是说new出来的数据就是引用数据类型。例3. 数组查表法根据索引查找对应星期技巧：快速生成方法getWeek(index,week);先写方法名和返回值调用方法然后用alt+enterreturn week[index];或String str = week[index];return str;package org.westo
复制链接

扫一扫