黑马程序员----Java语言基础2（语句、函数、数组）

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

程序流程控制

判断结构 、选择结构、循环结构

判断结构

if语句

三种格式：

1、if(条件表达式)

{

执行语句；

}

2、if(条件表达式)

{

执行语句；

}

else

{

执行语句；

}

3、 if(条件表达式)

{ 执行语句；}

else if (条件表达式)

{ 执行语句； }

……

else

{ 执行语句； }

if语句特点：

a,每一种格式都是单条语句。

b,第二种格式与三元运算符的区别：三元运算符运算 完要有值出现。好处是：可以写在其他表达式中。

c,条件表达式无论写成什么样子，只看最终的结构是 否是 true 或者false;

选择结构

switch语句

格式：

switch(表达式)

{ case 取值1:

执行语句；

break；

case 取值2:

执行语句；

break；

……

default:

执行语句；

break； }

switch语句特点：

a,switch语句选择的类型只有四种：byte，short，int ，char。

b,case之间与default没有顺序。先执行第一个case，没有匹配的case执 行 default。

c,结束switch语句的两种情况：遇到break，执行到switch语句结束。

d,如果匹配的case或者default没有对应的break，那么程序会继续向下 执行，运行可以执行的语句，直到遇到 break或者switch结尾结束。

循环结构

代表语句：while ， do while ， for

while语句格式：

while(条件表达式)

{

执行语句；

}

do while语句格式：

do

{执行语句； }

while(条件表达式);

do while特点是条件无论是否满足， 循环体至少被执行一次。

格式： for(初始化表达式；循环条件表达式；循环后的操作表达式)

{ 执行语句； }

最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循 环多少次，而是根据某些条件，来控制循环。

其他流程控制语句

break(跳出)， continue(继续)

break语句：应用范围：选择结构和循环结构。

continue语句：应用于循环结构。

注：

a,这两个语句离开应用范围，存在是没有意义的。

b,这个两个语句单独存在下面都不可以有语句，因为执行不到 。

c,continue语句是结束本次循环继续下次循环。

d,标号的出现，可以让这两个语句作用于指定的范围。

/*
需求：1~100之间 7的倍数的个数。并打印。
思路：
1，先对1~100进行循环(遍历)通过循环的形式。
2，在遍历的过程中，定义条件。只对7的倍数进行操作。
3，因为7的倍数不确定，只要符合条件，就通过一个变量来记录住这个变化的次数。

步骤：
1，定义循环语句，选择for语句。
2，在循环中定义判断。只要是7的倍数即可。使用if语句。条件：7的倍数 x%7==0；
3，定义变量，该变量随着7的倍数的出现而自增。
*/
class  ForTest3
{
public static void main(String[] args)
{
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*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();
}

不是规律的规律：
尖朝上，可以改变条件。让条件随着外循环变化。

尖朝下，可以初始化值，让初始化随着外循环变化。

函数

什么是函数？

函数就是定义在类中的具有特定功能的一段独立小程序。

函数也称为方法。

函数的格式：

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

{ 执行语句;

return 返回值; }

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

参数类型：是形式参数的数据类型。

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

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

函数的特点

定义函数可以将功能代码进行封装

便于对该功能进行复用

函数只有被调用才会被执行

函数的出现提高了代码的复用性

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

注意：

函数中只能调用函数，不可以在函数内部定义函数。

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

函数的应用

两个明确 ：

明确要定义的功能最后的结果是什么？

明确在定义该功能的过程中，是否需要未知内容参与运算。

/*
需求：判断两个数是否相同。
思路：
1，明确功能的结果：结果是：boolean 。
2，功能是否有未知内容参与运算。有，两个整数。
*/
public static boolean compare(int a,int b)
{
/*
if(a==b)
return true;
//else
return false;
*/

//return (a==b)?true:false;

return a==b;
}

函数的重载(overload)

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

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

什么时候用重载？

当定义的功能相同，但参与运算的未知内容不同。

那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

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 add(x,y)+z;
}
}

数组

数组：同一种类型数据的集合。其实数组就是一个容器。

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

格式1：

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

示例：int[] arr = new int[5];

格式2：

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

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};



内存结构

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

栈内存

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

堆内存

数组和对象，通过new建立的实例都存放在堆内存中。

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不在被使用，会在不确定的时间内被垃圾回收器回收

数组操作常见问题

//**遍历**
//定义功能，用于打印数组中的元素。元素间用逗号隔开。
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");

}
}

/*
获取数组中的最大值。
思路：
1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
通过一个变量进行临储。
2，让数组中的每一个元素都和这个变量中的值进行比较。
如果大于了变量中的值，就用该该变量记录较大值。
3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

步骤：
1，定义变量。初始化为数组中任意一个元素即可。
2，通过循环语句对数组进行遍历。
3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；

需要定义一个功能来完成。以便提高复用性。
1，明确结果，数组中的最大元素 int。、
2，未知内容：一个数组。int[]
*/
public static int getMax(int[] arr)
{
int max = arr[0];

for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}

选择排序

public static void selectSort(int[] arr)
{
for (int x=0;x<arr.length-1;x++)
{
for (int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;}

}

}
}

冒泡排序

public static void selectSort(int[] arr)
{
for (int x=0;x<arr.length-1;x++)
{
for (int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])
{int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;}

}

}
}

选择排序：

内循环结束一次，最值出现在头角标位置。

冒泡排序：

内循环结束一次，最值出现在最后角标位置。

图例：





折半查找

public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/2;

while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;

if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}

十进制——>十六进制

使用数组



查表法



数组中的数组

二维数组[][]

格式1：int[][] arr = new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组中有2个元素

一维数组的名称分别为arr[0], arr[1], arr[2]

给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2：int[][] arr = new int[3][];

二维数组中有3个一维数组

每个一维数组都是默认初始化值null

可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

格式3：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;

注意特殊写法情况：

int[] x,y[];

//x是一维数组，y是二维数组。

二维数组写法：

int [][]x;

int []x[];

int x[][];