java静态初始化二维数组_06、二维数组（动态初始化、静态初始化、二维数组的内存图、杨辉三角）、Java中的参数传递问题、递归（斐波那契数列）、面向对象（对象的内存图）...

1、二维数组

1、二维数组的动态初始化

package org.westos.demo;

public class ArrayDemo {

public static void main(String[] args) {

//二维数组

/*

二维数组的元素是一维数组，一维数组的元素是基本类型和引用类型。

*/

//动态初始化二维数组:由我们定义长度，由系统赋予默认值

//数据类型[][] 数组名 = new 数据类型[必选/二维数组长度][可选/一维数组长度];

int[][] array = new int[2][2];

}

}

package org.westos.demo;

public class ArrayDemo2 {

public static void main(String[] args) {

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

//2:必须写，代表二维数组的长度，即有多少行一维数组

//3:可选可不选，代表一维数组的长度，写与不写是有区别的

//取二维数组的元素，元素为一维数组

int[] arr0 = arr[0];

System.out.println(arr0);

//[I@1b6d3586

int[] arr1 = arr[1];

System.out.println(arr1);

//[I@4554617c

//取一维数组中存的值

int arr0_one = arr[0][0];

System.out.println(arr0_one);

//0

int arr0_two = arr[0][1];

System.out.println(arr0_two);

//0

int arr0_three = arr[0][2];

System.out.println(arr0_three);

//0

//给一维数组中的元素赋值

arr[0][0] = 10;

arr[0][1] = 20;

arr[0][2] = 30;

System.out.println(arr[0][0]);

//10

System.out.println(arr[0][1]);

//20

System.out.println(arr[0][2]);

//30

}

}

当第二个中括号不选时：

package org.westos.demo;

public class ArrayDemo3 {

public static void main(String[] args) {

//第二个[]不选的情况：

int[][] arr = new int[2][];

//初始化了二维数组，每一个一维数组的默认值为null(数组是引用类型，引用类型的默认值为null)

int[] arr0 = arr[0];

System.out.println(arr0);

//null

}

}

内存图：

当第二个中括号选上时：

package org.westos.demo;

public class ArrayDemo4 {

public static void main(String[] args) {

//第二个[]选的情况：

int[][] arr = new int[2][2];

System.out.println(arr[0]);

//[I@1b6d3586

System.out.println(arr[1]);

//[I@4554617c

//初始化二维数组，元素默认值为null，初始化每个一维数组，元素默认值为0

}

}

内存图：

二维数组的元素存放的是各个一维数组的地址值，引用。

手动初始化一维数组

package org.westos.demo;

public class ArrayDemo5 {

public static void main(String[] args) {

int[][] arr = new int[2][];

//null,null

//手动初始化一维数组

arr[0] = new int[2];

arr[1] = new int[3];

System.out.println(arr[0]);

//[I@1b6d3586

System.out.println(arr[1]);

//[I@4554617c

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[1][2]);

//一维数组元素默认值为0

}

}

二维数组的每个一维数组长度可以不一致。

以下格式也可以表示二维数组

a:数据类型 数组名[][] = new 数据类型[m][n];

b:数据类型[] 数组名[] = new 数据类型[m][n];

这两种格式不推荐使用

注意下面定义的区别

int x,y;

x,y都是int类型；

int[] x,y[];

区别是:

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

x=new int[3];

y=new int[3][];

y[0] = x

2、二维数组的静态初始化

package org.westos.demo2;

public class ArrayDemo {

public static void main(String[] args) {

//二维数组的静态初始化：由我们给元素赋值，由系统计算长度

int[][] arr = new int[][]{{10, 20}, {30, 40, 50}, {60}};

System.out.println(arr.length);

//3

System.out.println(arr[0][0]);

//10

System.out.println(arr[0][1]);

//20

System.out.println(arr[2][0]);

//60

System.out.println(arr[arr.length-1][arr[arr.length-1].length-1]);

//60

//简化版

double[][] array = {{1.0, 2.0}, {3.0f, 4}};

}

}

3、例题

1、二维数组的遍历

package org.westos.demo3;

public class ArrayDemo {

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.print("\n");

}

}

}

2、二维数组求和

package org.westos.demo3;

public class ArrayDemo2 {

public static void main(String[] args) {

//二维数组的求和

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++) {

for (int j = 0; j < arr[i].length; j++) {

sum += arr[i][j];

}

}

System.out.println("四个季度的营业额为" + sum);

//四个季度的营业额为641

}

}

3、杨辉三角

package org.westos.demo3;

import java.util.Scanner;

public class ArrayDemo3 {

public static void main(String[] args) {

//杨辉三角

Scanner sc = new Scanner(System.in);

System.out.println("请输入杨辉三角的行数：");

int n = sc.nextInt();

int[][] arr = new int[n][];

for (int i = 0; i < arr.length; i++) {

arr[i] = new int[i + 1];

arr[i][0] = arr[i][i] = 1;

if (i > 1) {

for (int j = 1; j < i; 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 < arr[i].length; j++) {

System.out.print(arr[i][j] + "\t");

}

System.out.print("\n");

}

}

}

4、Java中的参数传递问题

package org.westos.test;

public class MyDemo {

public static void main(String[] args) {

int a = 10;

int b = 20;

System.out.println("a: " + a + ",b: " + b);

//a: 10,b: 20

change(a,b);

System.out.println("a: " + a + ",b: " + b);

//a: 10,b: 20

int[] arr = {1,2,3,4,5};

change(arr);

System.out.println(arr[1]);

//4

}

private static void change(int a, int b) {

System.out.println("a: " + a + ",b: " + b);

//a: 10,b: 20

a = b;

//a=20

b = a + b;

//b=40

System.out.println("a: " + a + ",b: " + b);

//a: 20,b: 40

}

private static void change(int[] arr){

for(int x = 0 ; x < arr.length ; x++){

if(arr[x]%2 == 0){

//如果数组元素是偶数，乘以二

arr[x] *= 2;

}

}

//arr = {1,4,3,8,5}

}

}

参数的传递问题：

基本类型作为参数传递，属于值传递，会把这个变量的值传过去；

引用类型作为参数传递，属于引用传递，传递的是地址值；

基本类型作为参数传递，形参的改变不会影响实参；

引用类型作为参数传递，形参的改变会影响实参。

2、递归

在方法的定义中调用方法本身的现象。

注意事项：

递归要有出口；(if n == ?) return x；不然会造成栈溢出

递归次数不宜过多，过多也会有栈溢出的可能；

java.lang.StackOverFlowError

求5的阶乘。

递归实现

package org.westos.demo;

public class DiguiDemo {

public static void main(String[] args) {

//5! = 5 * 4 * 3 * 2 * 1 = 120

int num = 5;

int result = method(num);

System.out.println("5的阶乘为" + result);

//5的阶乘为120

}

public static int method(int i) {

if (i == 1) {

return 1;

}

return i * method(i - 1);

}

}

递归体现的是拆分合并的思想。

循环实现

package org.westos.demo;

public class DiguiDemo2 {

public static void main(String[] args) {

//使用循环计算5!

int num = 5;

int result = 1;

for (int i = num; i > 0; i--) {

result *= i;

}

System.out.println("5的阶乘为" + result);

//5的阶乘为120

}

}

斐波那契数列

从第三个数开始，等于前两个数之和。

非递归做法：

package org.westos.demo;

public class FiboTest {

public static void main(String[] args) {

int[] arr = new int[12];

arr[0] = arr[1] = 1;

for (int i = 2; i < arr.length; i++) {

arr[i] = arr[i-1] + arr[i-2];

}

System.out.println("12个月后的兔子个数为" + arr[arr.length-1]);

//12个月后的兔子个数为144

}

}

递归做法：

package org.westos.demo;

public class FiboDemo {

public static void main(String[] args) {

int num = 12;

int result = method(num);

System.out.println("12个月后的兔子个数为" + result);

//12个月后的兔子个数为144

}

public static int method(int n) {

if (n == 1 || n == 2) {

return 1;

}

return method(n - 1) + method(n - 2);

}

}

空间优化：

package org.westos.demo;

public class FiboTest2 {

public static void main(String[] args) {

int a, b;

a = b = 1;

for (int i = 3; i <= 12; i++) {

int temp = b;

b = a + b;

a = temp;

}

System.out.println("12个月后的兔子数量为" + b);

//12个月后的兔子数量为144

}

}

3、面向对象

1、面向对象概述

面向对象：基于面向过程，把这些过程封装起来，去调用。

面向对象，将我们的角色从之前的执行者变为了指挥者，需要用到某个功能时，调用某个类即可。

面向对象的三大特征：

封装

继承

多态

类和对象的概念：

类：抽象的，是一组具有相同属性和行为的集合；

对象：具体的，是该类事物的具体体现。

如何定义一个类：使用关键字class。

定义一个Person类：

package org.westos.demo;

//使用关键字class定义一个类

public class Person {

//事物--------对应Java中-------类

//属性------------------------成员变量

//功能------------------------成员方法

//定义成员变量，在方法外

String name = "张三";

int age = 22;

char gender = '男';

//定义成员方法

public void sleep() {

System.out.println("睡觉");

}

public void eat() {

System.out.println("吃饭");

}

public void playGame(String game) {

System.out.println("玩" + game);

}

}

package org.westos.demo;

public class PersonTest {

public static void main(String[] args) {

//在测试类中使用定义的Person类的属性和功能

//类是一个抽象的概念，不能直接使用，要使用，我们必须完成对类的实例化

//所谓实例化，就是创建该类对象

//如果创建该类的对象，使用关键字new来完成

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

Person person = new Person();

//对象才是一个类的具体表现，有了该类的对象后，就可以使用对象来调用类的属性和功能

//当然，一个类可以创建它的很多对象

String name = person.name;

int age = person.age;

char gender = person.gender;

System.out.println("name = " + name + ", age = " + age + ", gender = " + gender);

//name = 张三, age = 22, gender = 男

person.eat();

//吃饭

person.sleep();

//睡觉

person.playGame("LOL");

//玩LOL

System.out.println("============================");

Person person1 = new Person();

//再创建一个Person类的对象

person1.name = "李四";

person1.age = 30;

person1.gender = '女';

//重新设置属性的值

System.out.println(person1.name);

//李四

System.out.println(person1.age);

//30

System.out.println(person1.gender);

//女

}

}

定义一个手机类

package org.westos.demo;

/**

* 手机类：

* 成员变量：品牌、价格、颜色

* 成员方法：打电话、发短信

*/

public class Phone {

String brand;

double price;

String color;

public void call(String name) {

System.out.println("给" + name + "打电话");

}

public void sendMessage(String name, String content) {

System.out.println("给" + name + "发短信，内容是" + content);

}

}

package org.westos.demo;

public class PhoneTest {

public static void main(String[] args) {

Phone phone = new Phone();

//创建对象

String brand = phone.brand;

double price = phone.price;

String color = phone.color;

//输出成员变量的值

System.out.println("品牌：" + brand + ", 价格：" + price + ", 颜色：" + color);

//品牌：null, 价格：0.0, 颜色：null

//给成员变量赋值

phone.brand = "小米";

phone.price = 4999.0;

phone.color = "深空灰";

System.out.println("品牌：" + phone.brand + ", 价格：" + phone.price + ", 颜色：" + phone.color);

//品牌：小米, 价格：4999.0, 颜色：深空灰

//调用成员方法

phone.call("Tom");

//给Tom打电话

phone.sendMessage("Candy", "下午两点见");

//给Candy发短信，内容是下午两点见

}

}

2、对象的内存图

一个对象的内存图

两个对象的内存图

三个对象的内存图