06_Java basic VI

二维数组

二维数组定义格式

格式1

数据类型变量名 = new 数据类型m;

m表示这个二维数组有多少个一维数组

n表示每一个一维数组的元素个数

格式2 灵活性

数据类型 a = new 数据类型m;

a[0] = new 数据类型[一维数组中包含的元素个数];

...

a[m] = new 数据类型[一维数组中包含的元素个数];

格式3

数据类型变量名 = new 数据类型{{元素…},{元素…},{元素…}};

简化版格式：数据类型变量名 = {{元素…},{元素…},{元素…}};

举例：int arr = {{1,2,3},{4,6},{6}};

  /*
  定义一个三维数组，并初始化之。
  写一个打印函数，负责打印三维数组中的数据，并测试。
 
 三维数组，联想三维空间
  */
 
 public class homework04 {
 
     public static void main(String[] args) {
 
         int[][][] array = {{{1, 2}, {3, 4}}, {{5, 6 }, {7 ,8}}};
 
         for(int i = 0; i < 2; i++){
 
             for(int j = 0; j < 2; j++){
 
                 for(int k = 0; k < 2; k++)
                {
                     System.out.print(array[i][j][k]);
                }
                 System.out.println();
            }
             System.out.println();
        }
    }
 }

  
  
  /*
  杨辉三角形：
 1
 1 1
 1 2 1
 1 3 3 1
 1 4 6 4 1
 
  */
 
 public class TriangleYang {
 
     public static void main(String[] args) {
 
         int n = 5;
         int[][] tri = triangleYang(n);
         printArray(tri);
    }
 
     //打印输出数组
     public static void printArray(int [][]a){
 
         for(int i = 0; i < a.length; i++)
        {
             for( int j=0 ;j < a[i].length; j++){
                 System.out.print(a[i][j] + " ");
            }
             System.out.print("\n");
        }
    }
 
     //构建杨辉三角
     public static int[][] triangleYang(int n){
 
         int [][]tri = new int[n][];
         //当杨辉三角的函数为1，或2的固定值
         if(n == 1)//杨辉三角只有一行
        {
             tri[0] = new int[1];
             tri[0][0] = 1;
        }else if(n == 2){   //杨辉三角只有两行
             tri[0] = new int[1];
             tri[0][0] = 1;
 
             tri[1] = new int[2];
             tri[1][0] = 1;
             tri[1][1] = 1;
        }
 
         //杨辉三角大于等于两行
         tri[0] = new int[1];
         tri[0][0] = 1;
 
         tri[1] = new int[2];
         tri[1][0] = 1;
         tri[1][1] = 1;
         for(int i=2 ; i < tri.length; i++)
        {
             tri[i] = new int[i + 1];//[0, i-1]
             tri[i][0] = 1;
             tri[i][i] = 1;
 
             //a[i][j] = a[i-1][j-1] + a[i-1][j]
             for(int j = 1; j < tri[i].length -1; j++)
            {
                 tri[i][j] = tri[i-1][j-1] + tri[i-1][j];
            }
        }
         return tri;
    }
 }

递归

递归思想

方法定义中调用方法本身的现象（方法自己调用自己）

递归注意实现

要有出口，否则就是死递归（调用自己的这个过程，在满足一定条件的时候会终止）
次数不能太多，否则就内存溢出（递归的深度，不能太深）
构造方法不能递归使用（留着到类的时候思考）

递归核心的核心思想（汉诺塔问题）

64个盘片移动序列怎样？没有办法解决
假设前63个盘片，已经移动完毕，第64盘片
假设前62个盘片，已经移动完毕，第63盘片
假设前61个盘片，已经移动完毕，第62盘片
.....
假设前2个盘片，已经移动完毕，第3盘片
假设前1个盘片，已经移动完毕，第2盘片

有些问题？随着问题规模的增大，变得无法解决，但是同一个问题规模不是很大的时候，我们是知道问题的解。

递归的算法：分而治之

算法思路：把大规模的问题，转化为相似的多个小规模问题

递归在某些情况下可以转化为循环

较复杂的问题从递归转化到循环，借助一个工具——栈

1.在栈内存中，内存的分配单位，是以方法为单位的
2.换句话说，每一个方法的运行的时候，在栈内存上，会给每一个调用的方法，分配一片只属于该方法的存储空间。
3.在这片只属于方法这片的存储空间中，
- 1.局部变量表（该方法中定义的局部变量）
- 2.方法的返回地址

在栈空间中，这片只属于方法的存储空间，叫做栈帧。

何时，给方法分配栈帧空间？程序运行时，方法被调用

栈帧何时被回收？方法执行完毕之后，栈帧立马被系统回收。

类与对象

客观世界的组成：

1.对象
2.对象之间的相互关系

对象：对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。

一个对象：

1.由一组属性 java中数量 -> 变量（与之前学习的局部变量不同，定义的位置不同）表征对象外观
2.操作（功能）组成。操作就是行为 -> 方法表征对象的行为

类

类是用来生成对象的模板

人：两个研究，一个鼻子，一张嘴巴，两个（有这些属性）人这个类别有很多共有的属性
每个人类（对象）：鹰钩鼻，嘴巴长歪了
每个个体（对象）属性值不同

同一个类可以有多个对象：多个对象的属性值可以不同

一个学生类： id name age
学生对象：
- （张三这个具体的学生对象），id = 1，name = "张三"， age = 18
- （李四这个具体的学生对象），id = 2，name = "李四"， age = 19

类和对象关系

类就是我们程序员自定义的数据类型类（属性（量），行为：方法，操作）

对象：类比于 int i i表示一个具体的int类型的实例，对象就是我们自定义类型的一个实例

面向过程

面向过程：代码单位是函数(相当于我们java语言中的方法) 方法或者说函数：代表的是行为

如果用面向过程的语言来解决一个实际问题：把一个静态的问题转化为一系列的动作，把动作用函数表示。

比如：司机开车

系安全带
插钥匙
打火
打转向灯，打喇叭
......

用函数描述着一系列的动作

面向对象

比如司机开车

创建司机对象
创建车对象
司机发送消息给车对象，让车启动

在面向对象中

发送消息，就相当于方法调用，调用一次方法，就像对于是给这个对象发送了此命令

如：System.out.println();