Java基础4--循环--函数--数组

4-1，for循环嵌套练习

1，打印：

*****

*****

*****

*****

外循环控制行，内循环控制列。

for(int x=0;x<4;x++) {
	for(int y=0;y<5;y++) {
		System.out.print("*");
	}
	System.out.println();//换行
}

2，打印：

*****

****

***

**

*

//方法1：
int z = 5;
for(int x=1;x<=5;x++) {
	for(int y=1;y<=z;y++) {
		System.out.print("*");
	}
	System.out.println();
	z--;
}
//方法2：
int z=1;
for(int x=1;x<=5;x++) {
	for(int y=z;y<=5;y++) {
		System.out.print("*");
	}
	System.out.println();
	z++;
}
//方法3：
for(int x=1;x<=5;x++) {
	for(int y=x;y<=5;y++) {
		System.out.print("*");
	}
	System.out.println();
}

3，打印：

54321

5432

543

54

5

for(int x=1;x<=5;x++) {
	for(int y=5;y>=x;y--) {
		System.out.print(y);
	}
	System.out.println();
}

4，打印99乘法表

for(int x=1;x<=9;x++) {
	for(int y=1;y<=x;y++) {
		System.out.print(y+"*"+x+"="+y*x+"\t");
	}
	System.out.prtinln();
}

5，打印：

* * * * *

 * * * *

 * * *

  * *

   * 

for(int x=1;x<=5;x++) {
	for(int y=1;y<x;y++) {
		System.out.print(" ");
	}
	for(int z=x;z<=5;z++) {
		System.out.print("* ");
	}
	System.out.println();
}

4-2，常用转义字符：

\n:回车

\t:制表符

\b:退格

\r:按下回车键

Windows系统中回车符其实是由两个符号组成的：\r\n。

Linux中是\n。

应用：

打印: "Hello World"

应输入："\"HelloWorld"\"

打印：\Hello World\

应输入："\\Hello World\\"

 

4-3，break&continue

1，break的作用，跳出当前循环。还可以通过给循环定义名字，跳出指定的循环圈。

跳出指定循环圈示例：

a:for(int x=0;x<3;x++) {
	b:for(int y=0;y<4;y++) {
		System.out.println("x=" + x);
		break a;   //跳出名为a的循环圈
	}
}

break的作用范围：要么是switch语句，要么是循环语句。

记住：当break语句单独存在时，下面不要定义其他语句，因为执行不到。

break跳出所在的当前循环。

如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。

 

2，continue继续

作用范围：循环结构。

作用：结束本次循环，继续下次循环。

如果continue单独存在时，下面不要有任何语句，因为执行不到。

continue也可以像break那样，定义标记继续执行指定的循环圈。

 

4-4，函数-定义

1，定义：函数就是定义在类中的具有特定功能的一段独立小程序，函数也成为方法。

例如：

class Function{
	public static void main(String[] args) {
		int c = add(3,4);
		System.out.println("c=" + c);
	}
	int add(int a,int b) {
		return a+b;
	}
}

Main是函数,add也是函数。

 

4-5，函数-格式

1，格式（模版）

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

    执行语句;

    return返回值;

}

2，函数执行到return就结束，之后的语句都不执行，若后面有语句编译报错。

 

4-6，函数-细节-void

1，void:无返回值类型

2，特殊情况：

功能没有具体的返回值，这时return后面直接用分号结束。

注意：如果返回值类型是void，那么函数中的return语句可以省略不写。

 

4-7，函数-错误格式

1，必须注重提高代码的重复使用性。

2，函数的特点：

(1)定义函数可以将功能代码进行封装。

(2)便于对该功能进行复用。

(3)函数只有被调用才会被执行。

(4)函数的出现提高了代码的复用性。

(5)没有返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：

(1)函数中只能调用函数，不能在函数中定义函数。

(2)定义函数时，函数的结果应该返回给调用者，交由调用者处理。

 

4-8，定义思想错误

1，函数返回的结果应该交给调用者进行下一步处理，不要直接在函数内处理。

2，输出语句中的参数应该是一个具体的数值，不能是void类型的数据。

 

4-9，定义函数时的两个明确。

1，如何定义一个函数？通过两个明确完成。

明确一：这个功能的结果是什么？(其实就是明确函数的返回值类型)

明确二：这个功能实现过程中是否需要位置内容参与运算。(其实就是定义参数列表)明确参数的个数和参数的类型。

 

2，返回值类型和参数类型没有直接关系。

 

4-10，两个明确练习：

1，判断两个数是否相等：

明确一：返回值为boolean类型。

明确二：有两个未知整数参与运算。

public static boolean equals(int a,int b) {
	/* 方法1：
	if(a==b) {
		return true;
	} else {
		return false;
	}
	*/
	/* 方法2：
	return (a==b)?true:false;
	*/
	/* 方法3：
	if(a==b) {
		return true;
	}
	return false;
	*/
	//方法4：
	return a==b;
}

2，获取两个整数较大的数

明确一：返回值为int型。

明确二：两个int型整数参与运算。

public static int getMax(int a,int b) {
	/* 方法1：
	if(a>b)
		return a;
	else
		return b;
	*/
	//方法2：
	return a>b?a:b;
}

由于返回值是int型，不能直接写return a>b;它返回boolean型。

 

3，要注意什么使用if-else，什么时候使用连续if，应在满足需求的情况下最大限度的提高效率。还要注意&&与&，||与|的区别。

 

4-11，函数重载(overload)。

1，特点：

(1)在同一个类中。

(2)同名。

(3)参数个数或参数类型不同。

(4)函数重载和返回值类型无关。

(5)Java是严谨性的语言，如果函数出现调用的不确定性，编译会失败。

 

2，重载定义：

在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。

 

3，重载示例：

class FunctionDemo{
	public static void main(String[] args) {
		add(4,5);		//调用第一个函数
		add(4.4,5.5);	//调用第二个函数
		add(4,5,6);	//调用第三个函数
	}
	public static int add(int a,int b) {
		return a+b;
	}
	public static double add(double a,double b) {
		return a+b;
	}
	public static int add(int a,int b,int c) {
		return a+b+c;
	}
}

如果函数功能相同，则定义成同一个名字即可，用参数列表区分其不同。

 

重载练习：

打印99乘法表：

class FunctionTest{
	public static void main(String[] args) {
		printCFB(9);
		printCFB();
	}
	public static void printCFB(int num) {
		for(int x=1;x<=num;x++) {
			for(int y=1;y<=x;y++) {
				System.out.print(y+"*"+x+"="+y*x+"\t");
			}
			System.out.println();
		}
	}
	public static void printCFB(){
		printCFB(9);
	}
}

4-12，数组-定义

1，概念：同一种类型数据的集合，其实就是一个容器。

好处：自动从0开始编号，方便操作。

格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

    例如：int[] arr = newint[5];

格式2：元素类型[] 数组名 = new 元素类型[]{元素,元素,元素,...};

    例如：int[] arr = newint[]{2,3,4};

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

注意：数组建立是必须明确长度。

 

4-13，内存空间的划分：

Java内存空间的划分一共分为5块：

寄存器：CPU负责处理。

本地方法区：与所在系统相关，运行本地系统平台上的内容。

方法区：加载类中的方法，变量等。

栈内存：运行方法。

堆内存：对象的存放，有地址引用。

 

1，栈内存：存储的都是局部变量(方法中定义的变量)，而且变量所属的作用域一旦结束，该变量就自动释放。

为什么方法要进栈呢？因为局部变量都在方法里，方法不进栈，局部变量就无法进栈。

 

2，堆内存：

存储的是数组和对象(其实数组就是对象)。凡是new建立的都在堆中。堆里面存实体，实体是存储多个数据的地方。

堆内存特点：

例：int[] arr = new int[3];在内存中的图解：

1,局部变量都在方法里，main函数先进栈。

2,然后数组通过new在堆中建立实体，这时数组进入堆内存。

3,在堆中开辟一片内存空间，里面存放了三个数据，若没有给三个元素赋值，则在堆中给三个元素初始化为0（堆中的数据都有一个默认的初始值）。

若arr = null，即arr为空值，此时不再引用堆中的元素，堆中的数组变为垃圾，Java的垃圾回收机制自动不定时的回收垃圾。

 

特点：

(1)每一个实体都有一个首地址。

(2)堆内存中的每一个变量都有默认的初始化值，根据类型的不同而不同，整数是0，小数是0.0或0.0f，boolean是false，char是’\u0000’。

(3)垃圾回收机制(释放堆内存)。

 

4-14，数组-常见问题

1，int[] arr = new int[3];

    System.out.println(arrp[3]);

报错：ArrayIndexOutOfBoundsException;

当访问到数组不存在的角标时，就会产生这个异常。

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

    arr= null;

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

报错：NullPointerException

当引用变量没有任何实体指向时，还在用其操作实体，就会产生该异常。

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

    System.out.println(arr);

打印出：[I@C17164

其中：

[:这个代表的是这个实体是一个数组。

I:代表这个数组的元素的类型是int型。

@:源码中用@作为连接两部分的符号。

17164:由windows用哈希算法算出的数组地址值，把二进制的值用十六进制表示。