黑马程序员 Java基础知识（二）语法结构、函数和数组
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
一.语法结构
1.判断结构：有三种格式。
（1）if(条件表达式)
{ 执行语语句;}
（2）if(条件表达式)
{执行语语句;}
else
{执行语语句;}
（3）if(条件表达式)
{执行语语句;}
else if(条件表达式)
{执行语语句;}
else
{执行语语句; }
//需求：根据指定月份，打印该月份所属的季节。
//3，4，5春季；6，7，8夏季；9，10，11秋季；12，1，2冬季。
class IfText
{
public static void main(String[] args)
{
int x=6;
if(x>12 && x<1)
System.out.println("该月份不存在");
else if(x>=3 && x<=5)
System.out.println(x+"春季");
else if(x>=6 && x<=8)
System.out.println(x+"夏季");
else if(x>=9 && x<=11)
System.out.println(x+"秋季");
else
System.out.println(x+"冬季");
}
}
2.选择结构
（1）格式
switch(表达式)
{
case 取值1:
执行语句;
break;
case 取值2:
执行语句;
break;
default:
执行语句;
break;
}
注意：写的顺序可以乱，但运行是先运行完case，再运行default，运行case的顺序按照写的顺序。
（2）switch的语句特点：
(a)switch语句选择的类型只有四种：byte,short,int,char。
(b)case之间与default没有顺序，先执行第一个case，没有匹配的case执行default。
(c)结束switch语句的两种情况：遇到break，执行到switch语句结束。
(d)如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch的结尾结束。
//需求：根据指定月份，打印该月份所属的季节。
//3，4，5春季；6，7，8夏季；9，10，11秋季；12，1，2冬季。
class SwitchText
{
public static void main(String[] args)
{
int x=13;
switch(x)
{
case 3:
case 4:
case 5:
System.out.println(x+"春季");
break;
case 6:
case 7:
case 8:
System.out.println(x+"夏季");
break;
case 9:
case 10:
case 11:
System.out.println(x+"秋季");
break;
case 12:
case 1:
case 2:
System.out.println(x+"冬季");
break;
default:
System.out.println("该月份不存在");
break;
}
}
}
（3）if和switch的使用
如果判断的具体数值不多，而是符合byte,short,int,char这四种类型，建议使用switch语句，因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围广。
3.循环结构
（1）while(条件表达式)
｛执行语句;｝
（2）do
{执行语句;}while(条件表达式);
do while的特点是无论条件是否满足，循环体至少被执行一次。
（3）for(初始化表达式;循环表达式;循环后的操作表达式)
{ 执行语句;}
注意：
(a)for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。
(b)while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
(c)最简单无限循环格式：while(true)，for(;;);
(4)for循环练习
//1.获取1-10的和，并打印。
class ForTest1
{
public static void main(String[] args)
{
int sum=0;
for(int x=1;x<=10;x++)
{
sum=sum+x;
}
System.out.println("sum="+sum);
}
}//2.找出1-100之间7的倍数的个数，并打印
/*思路：
1.遍历1-100；
2. 在循环体中使用判断语句判断x%7是否为0。
3.定义变量count随着7的倍数的出现而自增。*/
class ForTest2
{
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);
}
}//3.制作一个九九乘法表。
/*思路：
1.通过for循环嵌套，大圈套小圈。
2.大圈是行，小圈是列*/
class ForTest3
{
public static void main(String[] args)
{
for(int x=1;x<10;x++)
{
for(int y=1;y<=x;y++)
{
System.out.print(x+"*"+y+"="+x*y+" ");//使用tab分格美观
}
System.out.println();//换行
}
}
}
/*制作图形：
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
*/
class ForTest4
{
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();//换行
}
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.其他流程控制语句
break（跳出）：应用范围是选择和循环结构。
continue（继续）：应用于循环结构。
注意：
(a)这两个语句离开应用范围，存在是没有意义的。
(b)这两个语句单独存在时，下面都不可以有语句，因为执行不到。
(c)continue语句是结束本次循环继续下次循环。
(d)标号的出现，可以让这两个语句作用于指定范围。
二.函数
1.函数的定义
（1）什么是函数？
函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。
（2）函数的格式
修饰符 返回值 函数名(参数类型 形式参数1，参数类型 形式参数2....)
{
执行语句；
return返回值
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
2.如何定义一个函数？
（1）明确是否有返回值，有的话要明确返回值类型。
（2）明确是否有未知参数参与运算，有的话要明确函数的参数列表（参数类型和参数个数）
3.函数的重载
（1）重载的概念
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
（2）重载的特点：与返回值类型无关，只看参数列表。
（3）重载的好处：方便阅读，优化了程序设计。
（4）重载示例：
返回两个整数的和：int add(int x,int y) (return x+y;)
返回三个整数的和：int add(int x,int y,int z) (return x+y+z;)
返回两个小数的和：double add(double x,double y) (return x+y;)
三.数组
1.数组的定义
（1）概念：同一种类型数据的集合，其实数组就是一个容器。
（2）数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
（3）格式1：元素类型[ ] 数组名=new 元素类型[元素个数或数组长度]; 示例int[] arr=new int[5];
（4）格式2：元素类型[ ] 数组多=new 元素类型[ ]{元素，元素.....}; 示例int[] arr=new int[]{2,4,6};或int[] arr={2,4,6};
2.内存结构
Java程序在运行时，需要在内存中分配空间，为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
（1）栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
（2）堆内存：
(a)数组和对象，通过new建立的实例都存放在堆内存中。
(b)每一个实体都有内存地址值。
(c)实体中的变量都有默认初始值。
(d)实体不在被使用，会在不确定的时间内被垃圾回收器回收。
（3）方法区，本地方法区，寄存器
3.数组的常见问题
（1）ArrayIndexOutOfBoundsException：操作数组时，访问到了数组中不存在的角标。
（2）NullPointerException：空指针异常，当引用没有任何指向，值为null的情况，该引用还在用于操作实体。
4.数组的常用操作
（1）求最值
//获取数组的最值
/*
思路:
1.通过前后两个数比较，较大的存起来跟下一个数比较
2.返回最大值
3.同理可得最小值
*/
class ArrayTest1
{
public static int getMax(int[] arr)
{
//获取最大值
int max=arr[0];
for(int x=1;x<arr.length;x++)//length是数组长度
{
//对每个数进行比较，较大的数就存起来
if(arr[x]>max)
max=arr[x];
}
return max;//返回值
}
public static int getMin(int[] arr)
{
//获取最小值
int min=arr[0];
for(int x=1;x<arr.length;x++)
{
//对每个数进行比较，较小的数就存起来
if(arr[x]<min)
min=arr[x];
}
return min;//返回值
}
public static void main(String[] args)
{
int[] arr=new int[]{3,1,6,9,4,8};//创建一个数组对象
int max=getMax(arr);//调用函数
System.out.println("max="+max);
int min=getMin(arr);
System.out.println("min="+min);
}
}（2）排序
//对数组进行排序（选择排序）
/*
思路:
1.对每个数都进行比较
2.通用嵌套循环进行比较。
3.将较小的数排在前面。
*/
class ArrayTest2
{
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 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.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr=new int[]{3,1,6,9,4,8};//创建一个数组对象
printArray(arr);
selectSort(arr);
printArray(arr);
}
}//对数组进行排序（冒泡排序）
/*
思路:
1.前后的数进行比较，一直比到最后，得出最大值
2.每次得出最大值都少一个数进行比较，所以内圈循环次数减x。
3.将最大的数排在最后面，并不再参与其他比较。。
*/
class ArrayTest3
{
public static void bubbletSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
//不断的进行前后比较
for(int y=0;y<arr.length-1-x;y++)
{
//将大的数排在后面
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
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.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr=new int[]{3,1,6,9,4,8};//创建一个数组对象
printArray(arr);
bubbletSort(arr);
printArray(arr);
}
}//对数组进行查找（折半查找）
/*
思路:
1.拿一个数跟数组的中间值比较。
2.比中间值大的就选择大的一边进行折半。
3.直到数组无法折半
4.折半查找的前提是数组必须是有序的。
*/
class ArrayTest4
{
public static void bubbletSort(int[] arr)
{
//对数组进行排序
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-1-x;y++)
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
public static int getIndex(int[] arr,int key)
{
//对数组进行折半查找
int min=0,max=arr.length-1,mid;
while(min<max)
{
mid=(min+max)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return min;
}
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.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr=new int[]{3,1,6,9,4,8};//创建一个数组对象
bubbletSort(arr);//排序
printArray(arr);//打印
int index=getIndex(arr,9);//查找
System.out.println("index="+index);
}
}
格式一：int[] [] arr=new int[3] [2];
（1）定义了名称为arr的二维数组。
（2）二维数组中有3个一维数组。
（3）每一个一维数组中有2个元素。
（4）一维数组名称分别为arr[0];arr[1];arr[2];
（5）给某一个一维数组1脚标位赋值为78写法是：arr[0] [1]=78;
格式二：int[] [] arr=new int[3] [];
（1）二维数组中有3个一维数组
（2）每个一维数组都是默认初始化值null
（3）可以对这个三个一维数组分别进行初始化
arr[0]=new int[3]
arr[1]=new int[1]
arr[2]=new int[2]
436
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
