黑马程序员 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);
}
}
(3)查找。
//对数组进行查找(折半查找)
/*
思路:
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]