Java基础知识(下)

——我是LGM_Hakka，请多多指教。

代码块

代码块就是直接由{}括起来的代码。

局部代码块

概念：定义在方法中的代码块

作用：可以让局部代码块中的数据尽可能早的消失,提高内存利用率.

构造代码块

概念：定义在类中方法外代码块

作用：可以把构造方法中共性内容定义在构造代码块中。

静态代码块

   特点：随着类的加载而执行,仅执行一次。

   作用：给类进行初始化。

 

代码块的执行顺序

子父类中如果有 构造方法,构造代码块,静态代码块在创建对象时他们的执行顺序是怎么样的?  

1. 父类静态代码块
2. 子类静态代码块
3. 父类构造代码块
4. 父类构造方法
5. 子类构造代码块
6. 子类构造方法

注意：

代码块的执行顺序：静态代码块 –> 构造代码块 –> 构造方法

注意事项：

当创建多个对象的时候静态代码块只执行一次。因为class字节码文件对象只加载一次的前提下。

数组

一维数组

1、数组是存储同一种类型的多个元素的容器。

2、好处：数组中的元素会被自动从0开始编号，方便我们获取。

3、格式：（可以把[]写在数据类型的右边，也可以写在数组名的右边）

A、动态初始化：数据类型[]数组名 = new数据类型[数组长度];

   例如：int[] arr1 = new int[4];

B、(变形而已)动态初始化：数据类型 数组名[] = new 数据类型[数组长度];

   例如：int arr4[] = new int[4];

C、静态初始化：数据类型[] 数组名 = new 数据类型[]{元素1,元素2...};

   例如：int[] arr2 = new int[]{1,2,3,4};

D、静态初始化：数据类型[]数组名 = {元素1,元素2...};

   例如：int[] arr3 = {1,2,3,4};

4、对数组的操作（例如：int[] a = new int[10];）

• 数组的索引：0--9
• 数组的长度：10       可以通过【数组名.length】来获取。
• 数组的操作方法可以到API中查看Arrays类。

5、Java内存图：

  A、栈 ---- 存储局部变量使用。使用完毕，立马消失。

  B、堆 ---- 所有new出来的都在堆里面。

   a、每一个实体都有地址值

   b、每一个实体内的内容都有默认值

    整数：0    浮点数：0.0

    字符：'\u0000'

    布尔：false

    字符串：null

   c、在垃圾回收器空闲的时候被回收。

  C、方法区

  D、本地方法区

  E、寄存器

二维数组

1、格式：

 A、数据类型[][] 数组名 = new 数据类型[几个一维数组][一维数组里有几个元素];

例如：int[][] arr1 = new int[3][2];

B、数据类型[][] 数组名 = new 数据类型[几个一维数组][];

例如：int[][] arr2 = new int[4][];

C、数据类型[][]数组名 = {{元素1,元素2,...},{元素1,元素2,...},{元素1,元素2,...}};

例如：int[][] att3 = {{1,2,3},{1,2},{1,2,3,4}};

推荐使用C。

 

2、在二维数组中：

第一个[]表示行：表示有几个一维数组。

第二个[]表示列：表示一维数组中，有几个元素。

对数组的常见操作

对数组的常见操作有：遍历数组、数组排序、对数组求最值

------------遍历数组

一维数组的遍历

public class Array1 {
	public static void main(String[] args) {
	  //定义一个int数组
	  int[] arr = {54,65,78,24,32,16,95,12,0,32,12};
	  //遍历数组
	  for (int i = 0; i < arr.length; i++) {
		  System.out.println("arr[" + i + "] = " + arr[i]);
	  } 
	}
}

二维数组的遍历

public class Array2 {
	public static void main(String[] args) {
		//定义一个二维数组
		int[][] arrs = { { 12, 54, 35, 16, 19, 3 }, { 22, 65, 35, 12, 56 }, { 54, 78, 65, 98, 5 } };
		// 遍历二维数组
		for (int i = 0; i < arrs.length; i++) {
			for (int j = 0; j < arrs.length; j++) {
				//打印
				System.out.println("arr[" + i + "][" + j + "] = " + arrs[i][j]);
			}
			//打印完一组后，换行
			System.out.println("------------------");
		}
	 }
}

------------数组排序

一维数组排序

public class Array3 {
	public static void main(String[] args) {
		// 定义一个int数组
		int[] arr = { 54, 65, 78, 24, 32, 16, 95, 12, 0, 32, 12 };
		// 遍历数组
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				// 判断大小，调换位置
				if (arr[j] > arr[j + 1]) {
					// 定义第三方变量，用于数据调换位置
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		// 遍历数组，输出排序后的数组元素
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}

二维数组排序

public class Array4 {
	public static void main(String[] args) {
		// 定义一个二维数组
		int[][] arrs = { { 12, 54, 35, 16, 19, 3 }, { 22, 65, 35, 12, 56 }, { 54, 78, 65, 98, 5 } };
		// 遍历二维数组
		for (int i = 0; i < arrs.length; i++) {
			// 遍历一维数组中的元素
			for (int j = 0; j < arrs[i].length; j++) {
				// 遍历一维数组中的元素
				for (int y = 0; y < arrs[i].length; y++) {
					if (arrs[i][j] < arrs[i][y]) {
						int temp;
						temp = arrs[i][y];
						arrs[i][y] = arrs[i][j];
						arrs[i][j] = temp;
					}
				}
			}
		}
		for (int i = 0; i < arrs.length; i++) {
			// 遍历数组中的元素
			for (int j = 0; j < arrs[i].length; j++) {
				System.out.print(arrs[i][j] + "  ");
			}
			// 打印完一组后，换行
			System.out.println();
		}
	}
}

---------对数组求最值

一维数组求最值

public class Array5 {
	public static void main(String[] args) {
		// 定义一个int数组
		int[] arr = { 54, 65, 78, 24, 32, 16, 95, 12, 0, 32, 12 };
		// 定义一个变量,用于存储最大值
		int max = arr[0];
		// 定义一个变量,用于存储最小值
		int min = arr[0];

		// 遍历数组
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
			if (arr[i] < min) {
				min = arr[i];
			}
		}
		// 打印最大值
		System.out.println("最大值为：" + max);
		// 打印最小值
		System.out.println("最小值为：" + min);
	}
}

二维数组求最值

public class Array6 {
	public static void main(String[] args) {
		// 定义一个二维数组
		int[][] arrs = { { 12, 54, 35, 16, 19, 3 }, { 22, 65, 35, 12, 56 }, { 54, 78, 65, 98, 5 } };
		// 定义一个变量，用于存储最大值
		int max = arrs[0][0];
		// 定义一个变量，用于存储最小值
		int min = arrs[0][0];

		// 遍历二维数组
		for (int i = 0; i < arrs.length; i++) {
			// 遍历一维数组中的元素
			for (int j = 1; j < arrs[i].length; j++) {
				// 若大于最大值，则赋值给最大值
				if (arrs[i][j] > max) {
					max = arrs[i][j];
				}
				// 若小于最小值，则赋值给最小值
				if (arrs[i][j] < min) {
					min = arrs[i][j];
				}
			}
		}
		// 打印最大值
		System.out.println("最大值" + max);
		// 打印最小值
		System.out.println("最小值" + min);
	}
}

方法（函数）

方法的基础知识

1、概述：定义在类中，有特定功能的一段小程序。

2、方法的格式：

  修饰符 返回值类型 方法名(形参类型 形式参数1,形参类型 形式参数2...)

  {

   方法体;

   reutrn 返回值;

  }

解释：

  A、修饰符 public ，static等

  B、返回值类型 程序最终结果的数据类型

  C、方法名 其实就是方法的名称,方便我们调用。

  D、参数

   形参类型 数据类型

   形式参数 就是接收实际参数的变量

   实际参数 就是实际参与操作的变量(常量)

  E、方法体 就是按照正常的逻辑完成功能的代码。

  F、返回值 就是程序的最终结果

  G、reutrn 返回值 哪里调用程序，return就把结果返回到哪里。

3、方法的特点：

  A:方法与方法之间是平级关系。不能在方法中定义方法。

  B:运行特点 方法只有被调用才执行。

 

4、方法的调用

  A：有明确返回值

   a、单独调用 一般没有意义。

   b、输出调用 但是如果想拿结果继续操作，就有问题了。所以，不好。

   c、赋值调用 推荐方式。

  B：void类型

   单独调用

参数传递的问题

方法的形式参数可以传递的数据有：

1、基本数据类型（8种基本数据类型）

        形式参数的改变对实际参数没有影响。

2、引用数据类型

        形式参数的改变将直接影响实际参数。（String类型除外）

3、在Java中只有值传递，基本数据类型传递的是实际的数值，引用数据类型传递的是内存地址值。

方法的重载

1、方法重载是在同一个类中进行的。

2、方法重载的条件：

• 方法名相同
• 参数列表不同(个数不同,对应的类型不同)
• 与返回值类型无关
• 可以相互调用

举例：

   publicstatic int sum(){...}

   public static int sum(inta,int b){...}

   public static int sum(inta,int b,int c){...}

   public static int sum(floata,float b){...}

   publicstatic void sum(char a){...}

等等。

3、虽然当方法写的形参类型大，当传入的实参类型小时会自动转换。

     但是，建议：方法写的是什么类型的形参，就用什么类型的实参进行调用。

方法的调用与结束

1、方法只有被调用后才会执行。

2、那方法被调用后是怎么结束的呢？

无论是方法有无返回值，Java都会在最后默认添加一句【return;】，用于方法的结束。

只是在无返回值类型的方法中，return;是隐藏的。当然我们也可以手动添加。