文章目录

• ​​Day 5​​

• ​​二维数组​​

• ​​二维数组的部分算法（遍历，求和，杨辉三角形）​​

• ​​递归​​

• ​​递归的经典算法（5的阶乘，斐波那契数列）​​
• ​​面向对象​​
• ​​类​​
• ​​对象​​
• ​​局部变量和成员变量的区别​​
• ​​相关的注意事项​​

Day 5

2019年4月5日。
这是我学习Java的第五天。
这一天，我学到了以下的知识。

二维数组

指的是数组中的元素是一维数组，数组嵌套数组。

格式1如下：

1.动态初始化1： 数据类型[][] 变量名 = new 数据类型[m][n];；

说明：
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选

注意事项：
A:以下格式也可以表示二维数组
  a:数据类型 数组名[][] = new 数据类型[m][n];
  b:数据类型[] 数组名[] = new 数据类型[m][n];
  这两种格式不推荐使用
B:注意下面定义的区别
  int x,y;
  int[] x,y[];  
  区别是:
   int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
    x=new int[3]; 
      y=new int[3][];

/*举例：
int[][] arr = new int[3][2];
    定义了一个二维数组arr
    这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
    每个一维数组有2个元素，可以通过arr[m][n]来获取
      表示获取第m+1个一维数组的第n+1个元素*/

格式2如下：

2.动态初始化2： 数据类型[][] 变量名 = new 数据类型[m][];;；

说明：
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。

/*举例：
  int[][] arr = new int[3][];
    arr[0] = new int[2];
    arr[1] = new int[3];
    arr[2] = new int[1];*/

格式3如下：

3.静态初始化： 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
  简化版:数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

说明：
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度

/*举例：
 int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
    int[][] arr = {{1,2,3},{5,6},{7}};*/

二维数组的部分算法（遍历，求和，杨辉三角形）

• 遍历
  思路：通过两层for循环来实现。
  外循环控制的是二维数组的长度，其实就是一维数组的个数。
  内循环控制的是一维数组的长度。
  代码如下：

  public class ArrayDemo {
 public static void main(String[] args) {
     int[][] arr = {{2, 4}, {10, 30}, {10, 30, 40}, {10, 1}};
     //二维数组的遍历
     for (int i = 0; i < arr.length; i++) {
         //System.out.println(arr[i]); //一维数组
         for (int j = 0; j < arr[i].length; j++) {
             System.out.println(arr[i][j]);
         }
     }
 }

}

• 求和
  思路：通过遍历进行数组中的每个数值的累加。
  需求：公司年销售额求和
  某公司按照季度和月份统计的数据如下：单位(万元)
  第一季度：22,66,44
  第二季度：77,33,88
  第三季度：25,45,65
  第四季度：11,66,99
  代码如下：

​​public class ArrayDemo2 { public static void main(String[] args) { //数组长度过大会造成堆内存溢出 // int[] arr = new int[900000000]; //A: //案例演示 //需求：公司年销售额求和 //某公司按照季度和月份统计的数据如下：单位(万元) //第一季度：22, 66, 44 //第二季度：77, 33, 88 //第三季度：25, 45, 65 //第四季度：11, 66, 99 int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}}; //遍历二维数租，求和 int sum = 0; for (int i = 0; i < arr.length; i++) { //System.out.println(arr[i]); for (int j = 0; j < arr[i].length; j++) { sum += arr[i][j]; } } System.out.println("总销售额:" + sum); } } ​​

• 杨辉三角形
  需求：打印杨辉三角形(行数可以键盘录入)
  //
  //1
  //1 1
  //1 2 1
  //1 3 3 1
  //1 4 6 4 1
  //1 5 10 10 5 1
  //
  分析规律：
  1.每一行的第一个数和最后一个数都是1
  2.从第三行开始，中间的数等于我上一行的前一列的数和我上一行本列的数之和
  代码如下：

public class ArrayDemo {
     public static void main(String[] args) {
     int[][] arr=new int[n][n]; //定义一个数组，行列数都一样
     for (int i = 0; i < arr.length; i++) {
         arr[i][0]=1; //将每一行的第一个数，置成1
         arr[i][i]=1; //将三角形的每一行的最后一个元素置成1
     }

     //计算中间元素
     for (int i =2; i < arr.length; i++) {
         for (int j =1; j <= i-1; j++) {
             //第三行开始，中间的数等于我上一行的前一列的数和我上一行本列的数之和
            arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
         }

     }

     //遍历二维数组

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

 } }

递归

在Java中，指的是在方法中调用方法的这种现象，称之为递归。

注意事项：

1. 递归要有出口，没有出口就是死递归，会造成栈溢出
2. 递归的次数不宜过多，过多也会造成溢出
3. 思想：拆分合并

递归的经典算法（5的阶乘，斐波那契数列）

• 5的阶乘
  思路：将问题缩小化。即将求5！拆分成求4！与5相乘。
  随后，再将4！拆分成3！与4相乘。
  像这样层层简化问题，最后再合并，即可求取5！
  代码如下：

​​public class MyTest2 { public static void main(String[] args) { //求 5的阶乘 //用递归来做 int r= jieCheng(5); System.out.println("结果是"+r); } private static int jieCheng(int i) { if(i==1){ return 1; }else{ return i*jieCheng(i-1); } } } ​​

• 斐波那契数列
  需求：兔子问题(斐波那契数列)
  有一对兔子，从出生后第3个月起每个月都生一对兔子，
  小兔子长到第三个月后每个月又生一对兔子，
  假如兔子都不死，问第二十个月的兔子对数为多少？
  月份 兔子的对数
  1 1
  2 1
  3 2
  4 3
  5 5
  6 8
  7 13
  8 21
  规律：1 1 2 3 5 8 13 21 从第三个数开始，这个数等于前两个数之和 （斐波那契数列）
  代码如下：

   public class MyTest2 {
 public static void main(String[] args) {
     int sum = sumRabbit(20);
     System.out.println("兔子的对数" + sum);
 }

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

面向对象

是基于面向过程来说的。其特性如下：

1. 概述：当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
   可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
   这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
2. 思想特点：
   a:是一种更符合我们思想习惯的思想
   b:可以将复杂的事情简单化
   c:将我们从执行者变成了指挥者，角色发生了转换
3. 特征：封装(encapsulation)，继承(inheritance)，多态(polymorphism)
4. 面向对象开发：就是不断的创建对象，使用对象，指挥对象做事情
5. 类和对象的区别是：
   a:类：是一组相关的属性和行为的集合
   b:对象：是该类事物的具体体现
   c:举例：
   类——学生
   对象——班长就是一个对象

类

类是一个抽象的概念，无法直接使用其属性和功能。要使用该类，就必须要对类进行实例化。所谓实例化，就是用关键字new来创建该类的对象。有了对象之后，通过对象调用类中的属性（成员变量）和功能（成员方法）。
其中：

1. 成员变量 ：和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。且有默认值
2. 成员方法：和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。

对象

一个类可以创建很多对象，对象的调用方法如下所示：

1. 创建对象的格式：

类名 对象名 = new 类名();

2. 使用成员变量的格式：

对象名.变量名

3. 使用成员方法的格式：

对象名.方法名(...)

例子：定义一个学生类Student，且用测试类MyTest进行调用，如下所示：

• Student类代码如下：

public class Student {
    //成员变量
    private String name;
    private int age;
    //无参构造方法
    public Student(){}
    //有参构造方法
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    //成员方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println( name + "---" + age );
    }
}

• MyTest类代码如下：

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        String name = student.name;
        int age = student.age;
        System.out.println(name);
        System.out.println(age);
        System.out.println("-----------------------");
        Student student1 = new Student();
        student1.name = "王五";
        student1.age = 255;
        System.out.println(student1.name);
        System.out.println(student1.age);
        System.out.println("------------------------------");
        Student student2 = new Student();
        student2.name = "赵六";
        student2.age = 26;
    }
}

局部变量和成员变量的区别

• 局部变量：定义在方法中或方法声明上的变量（形参）
• 成员变量：定义在类中方法外的变量

它们的区别如下所示：

1. 在类中的位置不同
   成员变量：在类中方法外
   局部变量：在方法定义中或者方法声明上
2. 在内存中的位置不同
   成员变量：在堆内存
   局部变量：在栈内存
3. 生命周期不同
   成员变量：随着对象的创建而存在，随着对象的消失而消失
   局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4. 初始化值不同
   成员变量：有默认初始化值
   局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

相关的注意事项

1. 只有一个类可用public修饰，一般用public装饰主类（有main方法的类）
2. 变量的访问原则：遵循就近原则（方法中要访问一个变量，会先在局部位置找，找到就是用。如果找不到，就会去成员位置找，找到就使用）
3. 如果有一个方法的形参，要一个class类型，那么就传一个该类的对象。
4. 基本数据类型，作为参数传递，形参的改变，不影响实参。
5. 引用数据类型，作为参数传递，形参的改变，会影响实参。