Java基础语法（2）----语句、函数和数组

  

一、程序流程控制语句

       A:顺序结构 代码按照顺序从上往下执行。
       B:选择结构 根据以下选择或者判断做出不同的执行。
  a:选择结构
  b:判断结构
       C:循环结构 把某些事情做很多次。 

     1、 判断结构：if语句体现。
格式1：
if(条件表达式)
{
    语句体;
}
    执行顺序：
根据条件表达式的返回值是true还是false决定程序的流程。
如果是true，就执行语句体；
如果是false，就什么都不做。

  注意：
        A:条件表达式：无论条件表达式是简单还是复杂，结果必须是boolean类型。
B:if语句后面可以不写{},但是，如果这样的话，它就只能控制后面的一条语句，
 如果想控制多条，就必须加{}。

  推荐：无论是控制一条还是多条，请都加上{}。

C:在if语句的{}前面不要写分号,否则，会对程序的结果有影响。
 一般来说：出现{}的时候，就不会有分号，有分号的时候，不会有{}
  作用域：
定义的变量的作用域，在它所属的那对{}内有效。 

        格式二：            

if(条件表达式)
{
语句体1;
}
else
{
语句体2;
}
执行流程：
如果条件表达式为true，就执行语句体1；
否则，就执行语句体2；
特殊：
可以和条件表达式在某些情况下进行替换。
一般是在赋值的情况下可以。

格式三：                                

if(条件表达式1)

{
语句体1;
}
else if(条件表达式2)
{
语句体2;
}
...
else
{
语句体n;
}
执行流程：
如果条件表达式1为true，就执行语句体1；
如果条件表达式2为true，就执行语句体2；
...
否则，就执行语句体n；

D:注意事项
a:什么时候时候哪一种if语句。
第一种格式在判断条件为一种情况下使用。
第二种格式在判断条件为两种情况下使用。
第三种格式在判断条件为多种情况下使用。
b:每一种if语句其实都是一个整体，如果有地方执行了，
   其他的就不执行了。
c:如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，
   但是，如果是控制多条语句，就必须写上大括号。
   这里建议：永远写上大括号。
d:大括号和分号一般不同时出现。

e:作用域：
所有变量的定义只在它所属的大括号内有效。

(3)案例：
A:根据键盘录入的成绩，判断等级。

/*
	对分数分等级，分数通过键盘录入。
*/

import java.util.Scanner;

class IfTest2 
{
	public static void main(String[] args) 
	{
		//封装键盘录入
		Scanner sc = new Scanner(System.in);

		//提示键盘录入分数
		System.out.println("请输入分数；");
		int score = sc.nextInt();

		String level;
		//判断结构
		if(score>=90 && score<=100)
		{
			level = "A等";
		}
		else if(score>=80 && score<90)
		{
			level = "B等";
		}
		else if(score>=70 && score<80)
		{
			level = "C等";
		}
		else if(score>=60 && score<70)
		{
			level = "D等";
		}
		else if(score>=0 && score<60)
		{
			level = "E等";
		}
		else
		{
			level = "分数有误";
		}
		
		System.out.println(score+"----"+level);
	}
}

B:根据键盘录入的月份，输出该月份所对应的季节。

/*
	一年有12个月，每个月分别对应于不同的季节。
	请根据给定的月份，输出对应的季节。

	春：3,4,5
	夏：6,7,8
	秋：9,10,11
	冬：1,2,12

	思路：
		A:请根据给定的月份,那么,就从键盘录入。
		B:根据每个月份进行判断。
*/
import java.util.Scanner;

class IfTest3 
{
	public static void main(String[] args) 
	{
		//封装键盘录入
		Scanner sc = new Scanner(System.in);

		//提示
		System.out.println("请输入月份(1-12)：");
		int month = sc.nextInt();

		//判断
		/*
		if(month == 1)
		{
			System.out.println("冬季");
		}
		else if(month == 2)
		{
			System.out.println("冬季");
		}
		else if(month == 3)
		{
			System.out.println("春季");
		}
		else if(month == 4)
		{
			System.out.println("春季");
		}
		else if(month == 5)
		{
			System.out.println("春季");
		}
		else if(month == 6)
		{
			System.out.println("夏季");
		}
		else if(month == 7)
		{
			System.out.println("夏季");
		}
		else if(month == 8)
		{
			System.out.println("夏季");
		}
		else if(month == 9)
		{
			System.out.println("秋季");
		}
		else if(month == 10)
		{
			System.out.println("秋季");
		}
		else if(month == 11)
		{
			System.out.println("秋季");
		}
		else if(month == 12)
		{
			System.out.println("冬季");
		}
		else
		{
			System.out.println("月份有误");
		}
		*/
		//由于month==1，month==2，month==12都是冬季，
		//而这三个都是条件表达式，那么，我们就可以使用逻辑运算连接起来。
		if(month==1 || month==2 || month==12)
		{
			System.out.println("冬季");
		}
		else if(month==3 || month==4 || month==5)
		{
			System.out.println("春季");
		}
		else if(month==6 || month==7 || month==8)
		{
			System.out.println("夏季");
		}
		else if(month==9 || month==10 || month==11)
		{
			System.out.println("秋季");
		}
		else 
		{
			System.out.println("月份有误");
		}

		//假如我还要判断这个月份是上半年还是下半年
		/*
		if(month==1 || month==2 || month==3 || month==4 || month==5 || month==6)
		{
			System.out.println("上半年");
		}
		else if(month==7 || month==8 || month==9 || month==10 || month==11 || month==12)
		{
			System.out.println("下半年");
		}
		else
		{
			System.out.println("月份有误");
		}
		*/

		//用范围判断改进
		if(month>=1 && month<=6)
		{
			System.out.println("上半年");
		}
		else if(month>=7 && month<=12)
		{
			System.out.println("下半年");
		}
		else
		{
			System.out.println("月份有误");
		}
	}
}

2、选择语句：switch语句

（1）用于做选择使用的，一般用于几个常量的判断。

switch会把几个常量值直接加载到内存，在判断的时候效率要比if高。所以，针对几个常量的判断，一般选择switch语句。

（2）格式：

switch(表达式)
{
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
...
default:
语句体n;
break;
}

A：针对格式的解释

switch：表示这里使用的是switch语句，后面跟的是选项。

表达式：byte,short,int,charJDK5以后可以是枚举，JDK7以后可以是字符串。

case：表示这里就是选项的值，它后面的值将来和表达式的值进行匹配。case后面的值是不能够重复的。

break：switch语句执行到这里就结束了。

default：当所有的case和表达式都不匹配的时候，就走default的内容。

B：执行流程

进入switch语句后，就会根据表达式的值去找对应的case值。

如果最终没有找到，那么就执行default的内容。

C：注意事项：

a、default整体可以省略吗？

可以，但不建议。

b、default的位置可以放到前面吗？

可以，一般不省略，它相当于if的else语句，可以控制所有的非正常情况。不建议省略。

c、break可以省略吗？

可以，但不建议。default在最后，break是可以省略的，case后面的break可以省略，但是可能结果会有问题。

d、switch语句什么时候结束呢？

就是遇到break或者执行到程序的末尾。

2、循环语句

（1）循环的组成

A：循环体，就是要做的事情。

B：初始化条件。一般定义的是一个初始变量。

C：判断条件。用于控制循环的结束。

D：控制条件。用于控制变量的变化，一般都是一个++/- -操作。

（2）循环的分类

A：for

for（初始化条件；判断条件；控制条件）

{

循环体；

}

执行流程：

先执行初始化条件----->执行判断条件------>根据判断条件的返回值：

true：执行循环体； 

false：就结束循环---->最后执行控制条件。返回到b继续。

B：while

初始化条件；

while（判断条件）

{

循环体；

控制条件；

}

执行流程：

先执行初始化条件----->执行判断条件------>根据判断条件的返回值：

true：执行循环体；

false：就结束循环---->最后执行控制条件。返回到b继续。

C:do...while
初始化条件;
do{
循环体;
控制条件;
}while(判断条件);

执行流程：
a:先执行初始化条件;
b:执行循环体和控制条件;
c:执行判断条件
d:根据返回值
true:返回b。
false:就结束循环。

注意：
a:一般使用for循环或者while循环。而且这两种循环是可以等价转换的。
b:do...while循环至少执行一次循环体。

案例：1、打印出所有的水仙花数。

/*
	打印出所有的"水仙花数"。
	所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：
	153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。 
	

	思路：
		A:"水仙花数"是指一个三位数，告诉我们范围了。100-999
		B:153=1的三次方＋5的三次方＋3的三次方通过这个例子
			一个数据的个位立方+十位立方+百位立方=该数据
		C:如何获取个位，十位，百位的数据？
			对于任意的数据x。获取个位怎么办呢?

			153：

			个：153%10 = 3
			十：153/10%10 = 5
			百：153/10/10%10 = 1
			千：x/10/10/10%10 -- .........
*/
class FlowerDemo 
{
	public static void main(String[] args) 
	{
		for(int x=100; x<1000; x++)
		{
			//x就是任意数据

			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;

			if((ge*ge*ge+shi*shi*shi+bai*bai*bai)==x)
			{
				System.out.println(x);
			}
		}
	}
}

2、打印出九九乘法表

/*
	需求：
	九九乘法表：

	1*1=1
	1*2=2 2*2=4
	1*3=3 2*3=6 3*3=9
	1*4=4 2*4=8 3*4=12 4*4=16
	...
	1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

	转义字符：
		\n	换行
		\r	回车
		\t	tab键位置
*/
class ForForTest 
{
	public static void main(String[] args) 
	{
		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();
		}
	}
}

打印结果：

附加：break和continue

有时候，我们需要对循环进行一些控制终止，这个时候就出现了两个关键字：break和continue

（1）特点：

A：它们都必须在循环中（break还可以在switch中） 一般在循环的判断中。

B：如果单独使用break和continue，后面是不能有语句的。

（2）区别：

A：break 结束当前循环。

B：continue 结束本次循环，进入下一次循环。

（3）如何退出嵌套循环： 用带标签的循环。

格式：

标签名：for（）{

for（）{

if（）{

  break 标签名；

}

}

}

//针对这种需求，java提供了一种方案：带标号的结束。
		//首先，定义一个标号，接着，使用break或者continue结束到此标号即可。
		//格式：
		//名字: for(){...}
		wc:for(int x=0; x<3; x++)
		{
			for(int y=0; y<4; y++)
			{
				System.out.print("*");
				break wc;
			}
			System.out.println();
		}

		System.out.println("over");
	}
}

二、函数

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

（2）函数的格式：

修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，.....）

{

执行语句；

return 返回值；

}

返回值类型：函数运行后的结果的数据类型。

函数名 其实就是函数的名称，方便我们调用。

参数：
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。

函数体 就是按照正常的逻辑完成功能的代码。
return：用于结束函数。 哪里调用程序，return就把结果返回到哪里。
返回值：该函数运算的最终结果，该结果会返回给调用者。

（3）函数的特点：

A：函数与函数之间是平级关系。不能在函数中定义函数。

B：运行特点 函数只有被调用时才执行。

C：定义函数可以将功能代码进行封装
D：便于对该功能进行复用
E：函数只有被调用才会被执行
F：函数的出现提高了代码的复用性
G：对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：
函数中只能调用函数，不可以在函数内部定义函数。定义函数时，函数的结果应该返回给调用者，交由调用者处理。

（4）函数的调用

A：有明确返回值

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

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

c：赋值调用 推荐方式。

B：void类型 单独使用

（5）函数重载

（1）概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

（2）重载的特点： 与返回值类型无关，只看参数列表。

（3）重载的好处：方便阅读，优化了程序设计。

A：函数名相同，参数列表不同（个数不同，对应的类型不同）。与返回值类型无关。

B:举例：
public static int sum(int a,int b){...}
public static int sum(int a,int b,int c){...}
public static int sum(float a,float b){...}

三、数组

（1）概念：存储同一种类型数据的集合。其实数组就是一个容器。

（2）数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

（3）一维数组格式：

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

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

示例：

A:int[] arr = new int[3];
B:int arr[] = new int[3];
C:int[] arr = new int[]{1,2,3};
D:int[] arr = {1,2,3};

注：推荐使用A和D。

二维数组格式：

A：int[][] arr = new int[3][2];

定义了名称为arr的二维数组
  二维数组中有3个一维数组
  每一个一维数组中有2个元素
  一维数组的名称分别为arr[0], arr[1], arr[2]
  给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

B：int[][] arr = new int[3][];

  二维数组中有3个一维数组
  每个一维数组都是默认初始化值null
 可以对这个三个一维数组分别进行初始化
  arr[0] = new int[3];
  arr[1] = new int[1];
  arr[2] = new int[2];

C：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组
  二维数组中的有三个一维数组
 每一个一维数组中具体元素也都已初始化
 第一个一维数组 arr[0] = {3,8,2};
 第二个一维数组 arr[1] = {2,7};
 第三个一维数组 arr[2] = {9,0,1,6};
  第三个一维数组的长度表示方式：arr[2].length;

（4）数组内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

             Java中内存中存储的方式有5种：

                 A：栈内存    用于存储局部变量，当数据使用完后所占空间会自动释放。

                 B：堆内存    所有new出来的都在堆里面

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

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

                                     整数：0
     浮点数：0.0
     字符：'\u0000'
     布尔：false

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

                  C：方法区     D：本地方法区    E：寄存器

  （5）数组操作常见问题

      1、数组脚标越界异常(ArrayIndexOutOfBoundsException)

         访问到了数组中的不存在的脚标时发生。

             如：int[] arr = new int[2];
                 System.out.println(arr[3]);

       2、空指针异常(NullPointerException)

          arr引用没有指向实体，却在操作实体中的元素时。 

            如：int[] arr = null;
                System.out.println(arr[0]);

   （6）数组常见操作

         1、获取最值（最大值、最小值）

         2、排序（选择排序、冒泡排序）

         3、折半查找（二分查找）

    Java基础就先总结到这儿了，以后要养成边学习边总结的好习惯！  有哪些写的不对的地方，真诚的希望大家帮我指出来，谢谢！！！