二维数组
指的是数组中的元素是一维数组,数组嵌套数组。
格式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 ArrayDemo3 {
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.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];
//案例演示
//需求:公司年销售额求和
//某公司按照季度和月份统计的数据如下:单位(万元)
//第一季度: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 ArrayDemo4 {
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];
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; 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+1; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
递归
在Java中,指的是在方法中调用方法的这种现象,称之为递归。
注意事项:
-
递归要有出口,没有出口就是死递归,会造成栈溢出
-
递归的次数不宜过多,过多也会造成溢出
-
思想:拆分合并
递归的经典算法(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);
}
}
}
面向对象
是基于面向过程来说的。其特性如下:
-
概述:当需求单一,或者简单时,我们一步一步去操作没问题,并且效率也挺高。可随着需求的更改,功能的增多,发现需要面对每一个步骤很麻烦了。这时就开始思索,能不能把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的封装在一起。这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。
-
思想特点:
a:是一种更符合我们思想习惯的思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者,角色发生了转换 -
特征:封装(encapsulation),继承(inheritance),多态(polymorphism)
-
面向对象开发:就是不断的创建对象,使用对象,指挥对象做事情
-
类和对象的区别是:
a:类:是一组相关的属性和行为的集合
b:对象:是该类事物的具体体现
c:举例:
类——学生
对象——班长就是一个对象
类
类是一个抽象的概念,无法直接使用其属性和功能。要使用该类,就必须要对类进行实例化。所谓实例化,就是用关键字new来创建该类的对象。有了对象之后,通过对象调用类中的属性(成员变量)和功能(成员方法)。其中:
-
成员变量 :和以前定义变量是一样的,只不过位置发生了改变。在类中,方法外。且有默认值
-
成员方法:和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。
局部变量和成员变量的区别
-
局部变量:定义在方法中或方法声明上的变量(形参)
-
成员变量:定义在类中方法外的变量
它们的区别如下所示:
-
在类中的位置不同
成员变量:在类中方法外
局部变量:在方法定义中或者方法声明上 -
在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存 -
生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失 -
初始化值不同
成员变量:有默认初始化值
局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。
注意事项
-
只有一个类可用public修饰,一般用public装饰主类(有main方法的类)
-
变量的访问原则:遵循就近原则(方法中要访问一个变量,会先在局部位置找,找到就是用。如果找不到,就会去成员位置找,找到就使用)
-
如果有一个方法的形参,要一个class类型,那么就传一个该类的对象。
-
基本数据类型,作为参数传递,形参的改变,不影响实参。
-
引用数据类型,作为参数传递,形参的改变,会影响实参。