Java基础知识
二维数组
一维数组：一维数组的元素是基本类型，引用类型。
二维数组：二维数组的元素是一维数组的数组，数组嵌套数组。
动态初始化：我们定义长度，系统默认初始值。
int[][] arr=new int[3][2];
定义了一个int类型的二维数组，数组长度是3，这个数组中放置了数字长度为2的一维数组。
int[][] arr=new int[3][ ];
后面[ ]不填的话，默认是一维数组的引用类型，即为null。
后面[ ]填的话，在创建二维数组的元素时，会初始化二维数组中的一维数组。
静态初始化：我们给数组赋初始值，系统计算长度。
int[][] arr={{1,2,3},{4,5,6},{7,8,9}};
数组中最后一个元素的索引=数组的长度-1
二位数组的遍历：外循环控制的是二维数组的长度，内循环控制的是一维数组的长度。
案例程序分析1：
public class test {
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++) {
System.out.println(arr[i]);
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
案例程序分析2：
public class test2 {
public static void main(String[] args) {
int[][] arr=new int[2][]; //null null
//手动创建两个一维数组
int[] minArr1=new int[3];
System.out.println(minArr1);//打印一维数组的地址：[I@1540e19d
int[] minArr2 = new int[2];
System.out.println(minArr2);//打印一维数组的地址：[I@677327b6
minArr2[1]=300;
//把上面的两个一维数组装到二维数组里面去
arr[0]=minArr1;
arr[1]=minArr2;
System.out.println(arr[0]);//打印数组的地址：[I@1540e19d
System.out.println(arr[1]);//打印数组的地址：[I@677327b6
arr[0][0]=100;
arr[0][1]=200;
System.out.println(minArr1[0]);//100
System.out.println(arr[1][0]);//0
System.out.println(arr[0][1]);//200
System.out.println(arr[0][0]);//100
System.out.println(arr[1][1]);//300
}
}
二维数组的遍历
案例程序分析3:
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度： 22,66, 44
第二季度：77, 33, 88
第三季度：25, 45, 65
第四季度：11, 66, 99
public class test3 {
public static void main(String[] args) {
//动态初始化
int[][] arr1 = new int[4][3];
arr1[0]=new int[]{22,66,44};
arr1[1]=new int[]{77,33,88};
arr1[2]=new int[]{25,45,65};
arr1[3]=new int[]{11,66,99};
int sum1=0;
//遍历
for (int a = 0; a < arr1.length; a++) {
for (int b = 0; b < arr1[a].length; b++) {
sum1+=arr1[a][b];
}
}
System.out.println(sum1);
System.out.println("==========================");
//遍历二维数组元素求和
//静态初始化
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++) {
//System.out.println(arr[i][j]);
sum+=arr[i][j];
}
}
System.out.println(sum);
}
}
案例程序分析4：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
package org.westos.demo2;
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入行数");
int n = scanner.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++){ //i为行数
for (int j = 1; j < i; j++) { //j为列数
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
}
//3.打印三角形
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();
}
}
}
参数传递
参数传递问题：基本类型作为参数传递，属于值传递，会把变量的值传递过去。
基本类型作为参数传递类型，形参的改变不影响实参。
引用类型作为参数传递，属于引用传递，传递的是地址值。
引用类型作为参数传递类型，形参的改变会影响实参。
案例程序分析5：
public class test {
public static void main(String[] args) {
//定义两个int边路
int a = 10;
int b = 20;
//输出变量的值
System.out.println("a: " + a + ",b: " + b); //1. 10 20
//调用方法，把 a 和 b 传过去
change(a, b);
//输出变量的值
System.out.println("a: " + a + ",b: " + b); //4. 10 20
//定义一个数组
int[] arr =new int[]{1, 2, 3, 4, 5};
//调用方法，把数组传过去
System.out.println("传递的arr"+arr);
change(arr);
//输出数组中第二个元素的值
System.out.println(arr[1]); //5. 4
}
public static void change(int a, int b) {
System.out.println("a: " + a + ",b: " + b); //2.a 10 b 20
a = b; //a 20
b = a + b;
System.out.println("a: " + a + ",b: " + b); //3.20 40
}
public static void change(int[] arr) {
System.out.println("收到的arr:" + arr);
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
参数传递图解：
递归
递归：在方法中调用方法本身的一种现象。
递归时需要注意：1.递归需要出口，不能是死循环，死递归会造成栈溢出。
2.递归次数不宜过多，过多也会有栈溢出的可能。
3.递归现象体现的是一种拆分合并的思想。
案例程序分析6：求5的阶乘。
public class test2 {
public static void main(String[] args) {
int num = 1;
for (int i = 5; i >= 1; i--) {
num *= i;
}
System.out.println(num);
System.out.println("==========================");
//采用递归的思想来计算5的阶乘
int r=jieCheng(5);
System.out.println("结果"+r);
}
public static int jieCheng(int i) {
if(i==1){
return 1;
}else{
return i*jieCheng(i-1);
}
}
}
案例程序分析7：
需求：兔子问题(斐波那契数列)
有一对兔子，从出生后第3个月起每个月都生一对兔子，
小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
public class test3 {
public static void main(String[] args) {
/*
月份 兔子的对数
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
*/
//采用递归来做
int sum=rabbit(20);
System.out.println(sum);
}
public static int rabbit(int i){
if(i==1||i==2){
return 1;
}else{
return rabbit(i-1)+rabbit(i-2);
}
}
}
面向对象
面向对象：基于面向过程。
面向对象的三大特征：封装，继承，多态。
事物-------------->类 .class
属性-------------->成员变量（成员属性）
功能-------------->成员方法（成员功能）
（1）定义一个类，public class person{}
（2）定义成员变量，定义在类中，方法外。
String name;
int age;
char sex;
（3）定义成员方法，public void sleep{};
public void eat{};
类，它是一个抽象概念，不能直接使用，要使用类中的属性和方法。
必须完成对类的实例化，所谓的实例化，就是创建该类对象。
怎样创建该类对象呢？使用关键词new来完成。
我们有了该类的对象后，对象才是一个类的具体表现，有了对象，才可以使用对象来调用类中的属性和功能了。
一个对象的内存图：
两个对象的内存图：
三个对象的内存图：
