黑马程序员————学习日记【3】 【Java基础编程2】

------- android培训、java培训、期待与您交流！ ----------

 

一、循环结构

 

1、

while:先判断条件，只有条件满足才执行循环体
do while:先执行循环体，再判断条件，条件满足，再继续执行循环体。
即：do while无论条件是否满足，循环体至少执行一次。

2、

3、

(1) 变量有自己的作用域。
      对于for,如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效。

      for语句执行完毕，该变量在内存中被释放。

(2) for 和while可以进行互换。如果需要定义循环增量，用for更为合适。

 

 

总结：什么时候用循环结构？         当要对某些语句执行很多次时，就使用循环结构。

 

4、练习

class ForTest
{
	public static void main(String[] args)
	{
		int x = 1;
		for(System.out.println("a");x<3;System.out.println("c"))
		{
			System.out.println("d");
			x++;
		}
	}
}

结果：adcdc    (注意运算顺序)

 

class ForTest
{
	public static void main(String[] args)
	{
		int x = 1;
		for(System.out.println("a");x<3;System.out.println("c"),x++)
		{
			System.out.println("d");
			//x++;
		}
	}
}
//多个表达式时，可用逗号隔开，如上。

 

 

for(int y=0; y<3; y++)
{

}

//--------------------------------------

int y=0;
for( ;y<3; )
{

}
//上面两者相同，但不建议第二种

 

 

  面试：

  无限循环的最简单表现形式:

  for(;;){}        对于for,不写条件表达式，默认为true

 

  while(true){}

 

 

/*
需求：获取1~100的和，并打印

*/

class ForTest
{
	public static void main(String[] args)
	{
	
		//1、定义变量用于存储不断变化的和
		int sum = 0;
		//2、定义变量，记录住不断变化的被加的数
		int x = 1;
		//3、定义循环，重复加法的过程
		while(x<=10)
		{
			sum = sum + x;
			x++;
		}
		System.out.println("sum="+sum);
		/*
		循环注意事项：
		一定要明确哪些语句需要参与循环，哪些不需要。
		*/
	}
}

上述用for来体现会更合适：

 

 

class ForTest
{
	public static void main(String[] args)
	{
		//用for来体现[更合适]
		int sum = 0;

		for(int x=0; x<=10; x++)
		{
			sum +=x;
		}
		System.out.println("for sum="+sum);
	}
}

/*
  其实这就是累加思想
  原理：通过变量记录住每次变化后的结果，通过循环的形式，进行累加的动作。
  即：（1）一个数不断的变大/变小，记录住这个不断变化的结果就是累加。
          （2）字符串的不断延长也是累加

结论：累加 =  变量 + 循环
  */

 

 

/*
需求：计算1~100之间7的倍数的个数，并打印

思路：
（1）先对1~100进行循环（遍历）通过循环的形式
（2）在遍历的过程中，定义条件，只对7的倍数进行操作
（3）因7的倍数不确定，只要符合条件，就通过一个变量来记录住这个变化的次数

步骤：
（1）定义循环语句，选择for语句
（2）在循环中定义判断，只要是7的倍数即可。使用if语句。条件：7的倍数 x%7==0；
*/


class ForTest
{
	public static void main(String[] arg)
	{
		int count = 0;
		for(int x=1; x<=100; x++)
		{
			if(x%7==0)
//				System.out.println("x="+x);
				count++;
		}
		System.out.println("count="+count);
	}
}

 计数器思想：

通过一个变量记录住数据的状态变化，也要通过循环完成。

 

结论：如果想要获取某一里面到底符合条件的有多少个，要想到计数器。

 

 

/*
需求：计算1~100之间偶数的个数，并打印
*/


class ForTest
{
	public static void main(String[] arg)
	{
		int count = 0;
		for(int x=1; x<=100; x++)
		{
			if(x%2==0)
//				System.out.println("x="+x);
				count++;
		}
		System.out.println("count="+count);
	}

}

 

//语句嵌套形式，其实就是语句中还有语句
//循环嵌套（面试）

class Test
{
	public static void main(String[] args)
	{
		for(int x=0; x<3; x++)
		{
			for(int y=0; y<4; y++)
			{
				System.out.print("*");
			}
			System.out.println();//只有一个功能就是换行
		}
	}
}

 结果：     结论：外循环控制行数，内循环控制每一行的列数，即每一行中元素的个数

class Test
{
	public static void main(String[] args)
	{
		/*
		
		*****
		****
		***
		**
		*
		发现图形有很多行，每一行有很多列
		要使用嵌套循环 原理：大圈套小圈

		*/
		for(int x=0; x<5; x++)//x<5:因为外循环控制行数，一共5行
		{
			for(int y=x; y<5; y++)
			{
				System.out.print("*");//切记此处无  ln
			}
			System.out.println();//此处功能是换行
		}
	}
}

结果：

 

class ForForTest
{
	public static void main(String[] args)
	{
		/*
		
		*
		**
		***
		****
		*****
		
		不是规律的规律：尖朝上，可以改变条件。让条件随着外循环变化。
						尖朝下，可以初始化值，让初始化值随着外循环变化。
		*/
		for(int x=0 ;x<5 ;x++)
		{
			for(int y=0; y<=x; y++)
			{
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

结果： 

 

class ForForTest
{
	public static void main(String[] args)
	{
		/*
		
		九九乘法表
		1*1=1
		1*2=2 2*2=4
		1*3=3 2*3=6 3*3=9
		
		*/
		for(int x=1;x<=9;x++)
		{
			for(int y=1;y<=x;y++)
			{
				System.out.print(y+"*"+x+"="+y*x+"\t");
			}
			System.out.println();
		}
	}
}

结果是： 

 

 5、

 

 下面的小细节记住就行：

class OtherDemo
{
	public static void main(String[] args)
	{
		w:for(int y=0; y<3; y++)
		{
			q:for(int x=0; x<3; x++)
			{
				System.out.println("y="+y);
				break w;
			}
		}
		//标号 w 和 q 只能用于循环上，是给循环起名字的一种方式。
	}
}

 求偶数的一种算法：

class OtherDemo
{
	public static void main(String[] args)
	{
		//continue:只能作用于循环结构  特点：结束本次循环，继续下一次循环
		
		for(int x=1; x<=10; x++)
		{
			if(x%2==1)
				continue;
			System.out.println("x="+x);
		}
	}
}

 

 

class OtherDemo
{
	public static void main(String[] args)
	{
		//continue:只能作用于循环结构  特点：结束本次循环，继续下一次循环
		
		w:for(int x=0; x<3; x++)
		{
			for(int y=0; y<4; y++)
			{
				System.out.println("x="+x);
				continue w;
			}
		}
		/*
		记住：
		（1）break和continue语句作用的范围
		（2）break和continue单独存在时，下面可以有任何语句，因为都执行不到。
		*/
	}
}

/*
----*
---* *
--* * *
-* * * *
* * * * *

*/
class ForForTest2
{
	public static void main(String[] args)
	{
		for(int x=0; x<5; x++)
		{
			for(int y=x; y<5; y++)
			{
				System.out.print("-");
			}
			for(int z=0; z<=x; z++)
			{
				System.out.print("* ");//注意("* ")里面有空格
			}
			System.out.println();
		}
	}
}

 结果是：   如果将上面（“-”）改为（“ ”）结果是：

 

 

class ForForTest2
{
	public static void main(String[] args)
	{
		for(int x=0; x<5; x++)
		{
			for(int y=x+1; y<5; y++)
			{
				System.out.print(" ");
			}
			for(int z=0; z<=x; z++)
			{
				System.out.print("* ");//注意("* ")里面有空格
			}
			System.out.println();
		}
	}
}

结果是：   和上面的结果比，整体左移了，去掉了和边界之间的空位。

 

 6、

 

class FunctionDemo
{
	public static void main(String[] args)
	{
		/*
		int x = 4;
		System.out.println(x*3+5);

		int x = 6;
		System.out.println(x*3+5);
		*/

//		int x = getResult(4);
//		System.out.println("x="+x);

		getResult(5);
	}
	/*
	发现以上的运算，因为获取不同数据的运算结果，代码出现重复。
	为了提高代码的复用性，对代码进行抽取
	将这个部分定义成一个独立的功能，方便日后使用
	java中对功能的定义是通过函数的形式来体现的

	需要定义功能，完成一个整数的*3+5的运算

	
	1、先明确函数定义的格式
	  
	 修饰符 返回值类型 函数名（参数类型  形式参数1，参数类型  形式参数2，.....）
	 {
		执行语句;
		return 返回值;
	 }


	 当函数运算后，没有具体的返回值时，此时用一个特殊的关键字来标识。
	 该关键字就是void，代表的是函数没有具体返回值的情况。
	 当函数的返回值类型是void时，函数中的return语句可以省略不写。
	*/

	public static int getResult(int num)
	{
		System.out.println( num * 3 + 5);
//		return;  可以省略
	}

}

 

public static void get(int a,int b)
{
	System.out.println(a+b);
	return;
}
//这个功能定义思想有问题，
//因为只为完成加法运算，至于是否要对和进行打印操作，那是调用者的事，不要在该功能中完成。

class FunctionTest
{
	public static void main(String[] args)
	{
		draw(5,6);
		printHr();
		draw(8,9);
		printHr();
	}
	/*
	定义一个功能，用于打印矩形。
	思路：
	1、确定结果：没有，因为直接打印。所以返回值类型void
	2、有未知内容吗？有，两个，因为矩形的行和列不确定。
	*/
	public static void draw(int row,int col)
	{
		for(int x=0; x<row; x++)
		{
			for(int y=0; y<col; y++)
			{
				System.out.print("*");
			}
			System.out.println();
		}
	}
	public static void printHr()
	{
		System.out.println("--------------------------");
	}
}

class FunctionTest
{
	public static void main(String[] args)
	{
		print99();
	}

	/*
	定义一个打印99乘法表功能的函数
	*/
	public static void print99()
	{
		for(int x=1; x<=9; x++)
		{
			for(int y=1; y<=x; y++)
			{
				System.out.print(y+"*"+x+"="+y*x+"\t");
			}
			System.out.println();
		}
	}
}

 

/*
什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同
那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数

*/
class FunctionOverload
{
	public static void main(String[] args)
	{
		add(4,5);
		add(4,5,6);
	}
	//定义一个加法运算，获取两个整数的和
	public static int add(int x,int y)//定义函数名重在体现函数的功能
	{
		return x+y;
	}

	//定义一个加法，获取三个整数的和
	public static int add(int x,int y,int z)
	{
		return x+y+z;
	}
}

 

class FunctionOverload
{
	public static void main(String[] args)
	{
		print99(4);	
	}
	public static void print99(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();
		}
	}
	//打印99乘法表
	public static void print99()
	{
		print99(9);
	}
	
}

结果是：

将print99(4); 改为print99();               结果就是九九乘法表如下：

 

也可将上面的求和进一步优化如下：

class FunctionOverload
{
	public static void main(String[] args)
	{
		add(4,5,6);
	}
	
	//定义一个加法运算，获取两个整数的和
	public static int add(int x,int y)//定义函数名重在体现函数的功能
	{
		return x+y;
	}

	//定义一个加法，获取三个整数的和
	public static int add(int x,int y,int z)
	{
		return add(x,y)+z;
	}
}

 

/*

void show(int a,char b,double c){}


a.
void show(int x,char y,double z){} //不

b.
int show(int a,double c,char b){}//重载，参数类型不同，参数是有顺序的。注意：重载和返回值类型无关

c.
void show(int a,double c,char b){}//重载，同上

d.
boolean show(int c,char b){}//重载，参数个数不同

e.
void show(double c){}//重载，同上

f.
double show(int x,char y,double z){}//不，这个函数不可以和给定函数同时存在于一个类中

*/