黑马程序员----Java语法基础（2）{语句，函数，数组}

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、循环语句

循环语句：Java程序中，有的地方会需要我们重复一段相同的代码，而只改变其中的几个变量的值，这时就需要使用循环语句，循环语句也是程序中使用最多的一种语句结构。
三种循环语句：
1.for
格式for(循环变量初始化;循环判断语句;循环条件改变)例如for(int i=0;i<9;i++){循环体}
2.while
格式while(循环条件判断){循环体}
3.do-while
格式do{循环体}while(循环条件判断)

while与do-while的唯一区别在于：do-while是先执行一次再判断，也就是说无论条件是否满足都要执行一次，而while如果条件一开始就不满足，那么一次都不执行。

循环语句代码

class Demo
{
public static void main(String[] args)
{
for(int i=0;i<10;i++)
{
System.out.print(i);
}
System.out.println();
int i=0;
while(i<10)
{
System.out.print(i++);
}
System.out.println();
i=0;
do
{
System.out.print(i++);
}
while (i<10);
}

}

运行图



while与do-while区别代码

class Demo
{
public static void main(String[] args)
{
int i=0;
while(i!=0)
{
System.out.println("while->i="+i);
}
do
{
System.out.println("do-while->i="+i);
}
while (i!=0);
}
}

运行图



可以看出，while中循环体一次都没执行，但是do-while中执行了一次，即使循环条件一开始就不满足。

循环打印等腰三角形

class Dengyao
{
public static void main(String[] args)
{
for(int i=1;i<=5;i++)
{
for(int j=0;j<5;j++)
{
if(j<5-i)
System.out.print(' ');
else
System.out.print("* ");
}
System.out.println();
}
}
}

运行图



循环打印乘法表

class Chengfabiao
{
public static void main(String[] args)
{
f(7);
}
public static void f(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();
}
}
}

运行图

二、判断语句

判断语句的格式
1.if(判断条件){....}
2.if(判断条件){....}else{....}
3.if(判断条件){....}else if(判断条件){....}else{....}
一般不推荐使用超过两个的else，会使得代码看起来非常混乱，逻辑判断过多不易于读懂代码。超过三个的判断一般有switch语句代替。
判断语句代码

class Demo
{
public static void main(String[] args)
{
int i=0;
//第一种语句格式
if(i==0)
{
System.out.println("i等于0");
}
//第二种语句格式
if(i!=0)
{
System.out.println("i不等于0");
}
else
{
System.out.println("i等于0");
}
//第三种语句格式
if(i!=0)
{
System.out.println("i不等于0");
}
else if(i==1)
{
System.out.println("i等于1");
}
else
{
System.out.println("i不等于1");
}
}
}

运行图

三、选择语句

一般当条件的可能性多于三个时我们就不使用if判断语句，而是使用switch的选择语句。
switch语句：
格式switch(条件表达式){case 常量1:....break;case 常量2:....break;case 常量3:....break;default break;}
注意：switch括号中的表达式的结果只能是byte,short,int,char中的一种。
每一个case都应当对应一个break，因为switch的执行流程是：查找与条件表达式结果一致的case，如果找到，那么就执行该case下的语句，知道遇到break为止，也就是说如果该case没有break，那么它就会一直执行下去，也会执行到其他case的语句，知道遇到break或者switch结束为止，因此除非特别需求，否则一般都要加break。
default是当case中没有与条件表达式结果匹配时，会执行default语句，通常其中就是一个break语句。
选择语句代码

class Demo
{
public static void main(String[] args)
{
int i=1;
switch(i)
{
case 1:System.out.println("i等于1");break;
case 2:System.out.println("i等于2");break;
case 3:System.out.println("i等于3");break;
default:System.out.println("i不等于1,2,3");break;
}

System.out.println("不写break语句后：");
switch(i)
{
case 1:System.out.println("i等于1");
case 2:System.out.println("i等于2");
case 3:System.out.println("i等于3");
default:System.out.println("i不等于1,2,3");
}
}
}

运行图



我们可以看到虽然i为1，但是程序依然打印了i等于2，i等于3等语句，这就是没有写break语句，程序一致向下执行的结果，因此一定不要忘了写break语句，除非特殊要求，。
特别需求，部分位置不写break语句代码

class Demo
{
public static void main(String[] args)
{
char result='B';
switch(result)
{
case 'A':
System.out.println("成绩为优秀");break;
case 'B':
case 'C':
System.out.println("成绩为良好");break;
case 'D':
default:
System.out.println("成绩为差");break;
}
}
}

运行图



可以看到，在case 'B'和case 'D'后没有写break，这是因为对于这个程序，case 'B'和case 'C'的执行代码是一样的因此我们可以这样写，就可以不用写两份一样的代码了。

四、函数

函数：具有特定功能（单一功能）的一段小程序，可以嵌套调用，不能嵌套定义；
定义函数的步骤：
1.确定返回值（这个函数处理完之后该返回点什么？）
2.确定参数列表（有没有哪些数据要参与函数内部运算呢？）
3.书写函数体（函数的具体处理过程）
在java中，函数是最小封装体，表示的是一个功能。对于函数的命名，我们要做到它的名字就是它的功能，例如max(int x,int y)，一眼就能让人看出该函数的功能就是求两个数中大的那个。如果名字用一个单词不能解释，可以用多个，这样采用的命名方式叫做驼峰命名法，例如getElementFlag，除了第一个单词，其他单词的首字母大写，其他小写，像驼峰一样起伏，这种命名让人更快的看出每个单词的位置等。
函数中能调用函数，如果一个函数调用自己，那么我们称之为递归调用。
函数中不能定义函数。
模块化编程思想就是利用函数。
我们都知道编程思想分为面向过程和面向对象，面向对象的基础是类，而面向过程的基础就是函数，面向过程的思想是将程序分为一个一个的功能，而实现功能的手段就是函数。
使用函数代码

class Demo
{
public static void main(String[] args)
{
int x=2,y=3;
System.out.println("x=2,y=3中大的是："+max(x,y));
}
private static int max(int x,int y)
{
return x>=y?x:y;
}
}

运行图



可以看到我们调用函数max来完成了从x，y中取最大值的功能，通常main函数中并没有什么逻辑代码，而应该是创建对象，调用方法。

不知道大家思考过一个问题没有，像这种比较大小的函数，这个函数本身很局限，因为它只能比较两个int型数据的大小，如果我想比较三个呢，或者比较float型的呢？函数本身的功能并没有实质性的变化，还是求最大值，只是问题规模变了而已，那么狠明显的我们还要写函数，问题来了，这个函数怎么命名呢，max已经被用了，难道我们使用maxFloat这样的名字吗？很明显这是不可能的，因为这种名字的可读性极差，其实在这里我们依然可以用max这个名字，这就涉及到函数的一个非常重要的特性：重载。
函数重载：当多个函数间函数名相同，但是参数列表不一致时，就形成了函数重载，函数重载的原则是这多个函数处理的都是同一类问题，只是规模或者参数类型等不同而已，这才是使用重载的地方，而两个函数是否称为重载，是看参数列表是否不一致，跟返回值无关。
重载代码如下

class Demo
{
public static void main(String[] args)
{
int i=2,j=3,k=4;
double x=1.2,y=2.3;

System.out.println("i=2,j=3其中最大的是："+max(i,j));
System.out.println("i=2,j=3,k=4其中最大的是："+max(i,j,k));
System.out.println("x=1.2,y=2.3其中最大的是："+max(x,y));
}
private static int max(int i,int j)
{
return i>=j?i:j;
}
private static int max(int i,int j,int k)
{
return max(max(i,j),k);
}
private static double max(double i,double j)
{
return i>=j?i:j;
}
}

运行图



可以看到，重载的好处是可以让相同功能的函数的名字一样，而不用去特地取那些拗口的名字。

五、数组

用于存储多个相同类型数据的集合，可以使用下标对集合中的元素进行索引，存取都非常方便。
数组一般与循环语句配合使用，例如遍历数组中的元素啊等等。
数组是引用数据类型，例如int[] arr={1,2,3};其中arr存储于栈中，而数组实体存储于堆中。
栈和堆：
栈内存（数据使用完自动释放）：函数，局部变量；

堆内存（当引用为null，对应在堆的数据会不定时被java虚拟机的垃圾回收机制释放）：

new出来的实体，对象，堆中的数据根据类型是有默认值的（int:0,double:0.0,float:0.0f,boolean:false,char:空格->'\u0000',引用类型:null）。
创建数组的三种语法格式
1.int[] arr=new int[3];创建了但是未赋值。
2.int[] arr=new int[]{1,2,3};创建了一个包含1,2,3三个元素的数组。
3.第二种方式的简写int[] arr={1,2,3};
创建数组，遍历其中元素代码

class Demo
{
public static void main(String[] args)
{
int[] arr1=new int[3];
arr1[0]=12;
arr1[1]=23;
arr1[2]=34;

int[] arr2=new int[]{1,2,3};
int[] arr3={5,6,7};
for(int i=0;i<arr1.length;i++)
{
System.out.println("arr1:["+i+"]="+arr1[i]+",arr2:["+i+"]="+arr2[i]+",arr3:["+i+"]="+arr3[i]);
}
}
}

运行图



我们看到，有一句代码：i<arr1.length：数组本身是引用数据类型，它内部封装了数据和方法的，我们可以使用它的名字加.来调用这些方法，例如此处的arr1.length就是使用了数组的长度成员来控制循环次数。

很多同学可能不理解数组名的意义，那么我们就打印输出来分析一下。
打印数组名代码

class Demo
{
public static void main(String[] args)
{
int[] arr1=new int[3];
System.out.println(arr1);
}
}

运行图



我们看到打印结果是;[I@7852e922，我们来挨个分析;其中[表示这是一个数组，I表示数组内元素类型是int，而@后面的一串数字是该数组堆中地址的16进制表示法。

二维数组：

实际上Java是没有二维数组的，二维数组在Java中使用数组的数组来表示的。

例如：

int[][] arr=new int[3][];这就是一个数组，不同的是该数组的内部成员也是数组，也就是所谓的数组的数组。

而且Java中数组的数组的特点是：可以不规则，也就是说内部的三个成员数组的长度可以不相等。

比如：arr[0]={1};arr[1]={1,2};arr[2]={1,2,3};

同样的打印数组的数组名也会得到不一样的结果。

数组的数组代码

class Demo
{
public static void main(String[] args)
{
int[][] arr=new int[3][];
arr[0]=new int[1];
arr[0][0]=1;//这是访问数组中的数组中的元素的方式
arr[1]=new int[]{1,2};
arr[2]=new int[]{1,2,3};//不能使用arr[2]={1,2,3};的方式赋值了。
for(int i=0;i<arr.length;i++)//循环数组的数组
{
for(int j=0;j<arr[i].length;j++)//循环遍历数组中的数组元素的元素
{
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
System.out.println(arr);
}
}

运行图



我们可以看到，该数组的数组是不规则的，其中每个数组元素的长度都不一样，这是Java数组的数组的优势。当我们打印数组的数组名时可以看到其他部分都一样，除了开始的[[，这个表示的就是数组的数组。

六、总结

这部分主要是学习了循环语句，判断语句，选择语句，函数和数组。这些都是Java程序的基础，没有它们就没有Java，而且再复杂的程序也是由无数个基础语法组成的。因此一定要熟练掌握。函数作为Java的最小封装体，也是非常重要的，面向对象中类的方法就是函数在面向对象中最好的利用。数组作为一种处理多个相同类型的容器，使用非常频繁，我们将同类，且有关系的数据放在数组中处理也是符合逻辑的。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------