黑马程序员 Java基础语法——下

时间:2020-12-27 00:46:22

六.语句

1) 判断结构

if:语句用于做判断使用的。

常见于对某个范围进行判断,或者几个变量进行判断,还有就是boolean表达式的判断。

判断语句三种格式:

1. if (条件表达式){

执行语句;

   }

执行流程:如果条件表达式为true,就执行语句,否则,什么都不执行。

2. if(条件表达式){

if语句执行体;

    }else{

else语句执行体;

    }

执行流程:如果条件表达式为true,就if语句执行体;否则,就执行else语句执行体;

3. if(条件表达式){
if语句执行体;
   }
   else if(条件表达式){
else if语句执行体;
   }
   ...
   else{
else语句执行体;

   }

执行流程:

如果条件表达式1 为true,就执行if语句执行体;;

如果条件表达式2 为true,就执行else if语句执行体;;

如果条件表达式...为true,就执行else if语句执行体;;

否则,就执行else语句执行体;

注意事项
1:什么时候用哪一种if语句?
第一种格式在判断条件为一种情况下使用。
第二种格式在判断条件为两种情况下使用。

第三种格式在判断条件为多种情况下使用。

2:if语句执行完会执行另外一个语句吗?

每一种if语句其实都是一个整体,如果有地方执行了。其他的就不执行了。

3:大括号需要每次都写上吗?

如果if或者else里面控制的语句体是一条语句,是可以省略大括号的,

但是,如果是控制多条语句,就必须写上大括号。

建议:永远写上大括号。

4:大括号和分号一般不同时出现。

if(true)

System.out.println("true");

else

System.out.println("false");;

举例:
需求:获取两个数中的最大值。
//因为获取俩个数中的最大值必须有一个结果.所以可以先考虑三元运算符。
int  x=1,y=2,z;

z=(x>y)?x:y;

作用域

所有变量的定义只在它所属的大括号内有效。 

特殊

可以和条件表达式在某些情况下进行替换。

一般是在赋值的情况下可以。

2)选择结构

switch 语句

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

switch 语句 会把几个常量值直接加载到内存,在判断的时候,效率要比 if 语句 高。

所以,针对几个常量的判断,一般选择 switch 语句。

选择语句格式:

switch(变量){

case 取值1:

执行语句;

break ;

case 取值 2:

执行语句;

break ;
...

default:

执行语句;

break;

}

针对格式的解释

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

表达式:byte,short,int,char

JDK 1.5以后可以是枚举

JDK 1.7以后可以是字符串

case:表示这里就是选项的值,它后面的值将来和表达式的值进行匹配。

case:后面的值是不能够重复的。

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

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

它相当于if语句的else。一般不建议省略。

执行流程

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

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

注意事项:

a: default 整体可以省略吗?

可以,但是不建议。

b:default的位置可以放到前面吗?

可以,但是不建议。

c:break可以省略吗?

可以,但是不建议。default在最后,defaultbreak是可以省略的,但是结果可能有问题。

d:switch语句什么时候结束呢?

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

if switch 的应用:

if语句特点:

1,对具体的值进行判断。

2,对区间判断。

3,对运算结果是boolean类型的表达式进行判断。

switch语句特点:

1,对具体的值进行判断。

2,值的个数通常是固定的。

对于几个固定的值判断,建议使用switch语句,因为switch语句会将具体的答案都加载进内存。效率相对高一点。

3.switch只能对基本数据类型进行操作 byte,short,int,char

3)循环结构

循环语句:while,   do while ,   for

如果我们发现有很多重复的内容的时候,就该考虑使用循环改进代码。
让我们代码看起来简洁了。

while循环语句格式:

while(条件表达式){

循环执行体;

}

do  while  循环语句格式:
do {

循环执行体;

}while(条件表达式);

while     特点:条件如果不满足,不会走循环体

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

for循环语句格式:

for (初始化表达式;循环条件表达式;循环后的操作表达式){

执行语句;(循环体)

}

循环注意  : while  先判断后执行。  do while  先执行一次后判断。
循环总结:一定要注意哪些语句需要参加循环,哪些不需要。

总结:什么时候用循环语句?

当对某些语句执行很多次时,就使用循环结构。

总结:什么情况用for,什么情况用while呢?

for和while可以互换。如果用于定义循环增量。用for更合适。因为节约内存。

当然,当我们在写测试程序时,为了书写的简洁,也是可以用while,因为容易看。

不过建议使用for,习惯成自然。你懂的黑马程序员 Java基础语法——下

嵌套循环:

简单的说就是循环里面还有循环。

外循环执行一次,内循环执行一遍。

for(初始化表达式;条件表达式;循环后的操作表达式){

for(初始化表达式;条件表达式;循环后的操作表达式){

}

}

while(条件表达式){

while ( 条件表达式 ){

}

}

总结:嵌套循环是外循环条件成立执行一次,内循环必须执行到条件不满足才结束。

1)累加思想

原理:通过变量记录住每次变化的结果,通过循环的形式,进行累加动作。

2).计数器思想:

原理:通过一个变量记录住数据的状态变化,也许通过循环完成。

3)大圈套小圈思想:

原理:尖朝上改变条件。尖朝下改变初始值。

注意

1, for 里面的连个表达式运行的顺序,初始化表达式只读一次,判断循环条件,为真就执行循环体,然后再执行循环后的操作表达式,接着继续判断循环条件,重复找个过程,直到条件不满足为止。

2,  while for 可以互换,区别在于 for 为了循环而定义的变量在 for 循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。

3, 最简单无限循环格式: while ( true ), for (;;)无限循环存在的原因是并不知道循环多少次,而是根据某些条件,来控制循环。比如在循环体定义判断语句。

其它流程控制语句

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

breakcontinue

break(跳出),continue(继续)

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

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

注意

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

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

3, continue语句是结束本次循环继续下次循环,结束之后会去判断表达式。

3, continue语句是结束本

4, 标号的出现,可以让这两个语句作用于指定的范围。方便了可以跳出多重循环或者继续哪层循环。

练习题

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下

黑马程序员 Java基础语法——下



七.函数

1.函数的定义

(1).函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。

(2).函数的格式:

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

执行语句;

return 返回值;

}

2.函数的特点

(1).定义函数可以将功能代码进行封装,便于对该功能进行复写。

(2).函数只有被调用才会被执行。

(3).函数的出现提高了代码的复用性。

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

(5).函数中只能调用函数,不可以在函数内部定义函数。

(6).定义函数时,函数的结果应该返回给调用者,交由调用者处理。

(7).可以自定义一个访问权限。

定义函数时需要注意

1.功能中只定义所需内容,不是该功能所需的内容不要定义。

2.如果非要定义,也是单独定义一个功能来体现。以后开发时,尽量都将功能以不同的函数来体现。

3.不要将代码都定义在主函数中。

4.主函数的作用是:对已有的功能的进行调用,可以理解为用于功能的测试。

5.函数名就是一个自己定义的标示符。函数名的定义,要尽量体现出这个函数的功能。是为了增强该函数的阅读性,方便于调用者使用,所以函数名一定要有起的有意义。

6.静态方法只能调用静态方法。主函数是静态的。

7.返回值类型和参数类型没有直接关系。

定义函数时候需要有两个明确

1)这个函数会得到什么结果,也就是返回值是什么。

2)有没有未知内数据参与运算。

3.函数的重载(Overload)

(1).重载的概念:在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数和参数类型不同即可。

(2).重载的特点:与返回值类型无关,只看参数列表。

(3).重载的好处:方便于阅读,优化了程序设计。

注:Java是严谨性语言,如果函数出现的调用不确定性,会编译失败。

4.函数重载什么时候使用

重载:当定义的功能相同,但参与运算的未知内容不同,那么,这时就定义一个函数名称以表示其功能,方便阅读,而通过参数列表的
同来区分多个同名函数。  

黑马程序员 Java基础语法——下

八.数组

1.数组的概述:

(1).概念:同一种类型数据的集合。其实数组就是一个容器。

(2).好处:可以自动给数组中的元素从0开始编号,方便操作这些元素。

(3).对数组的基本操作就是存和取。核心思想:基于角标。

(4)既可以存储基本数据类型又可以存储引用类型,只是长度固定。集合长度可变,但只能存储引用类型。

2.数组的定义:

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

2)元素类型[] 数组名 ={1,2,3,4,5,6,7};可以直接指定具体的数据

3)元素类型[] 数组名;

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

3.数组的特点

1)数组定义时,必须明确数组的长度(就是数组中可以存储的元素的个数。)因为数组长度是固定的。

2)数组定义时,必须明确数组中的元素的数据类型。

例子:

char[] arr = new char[5];

arr[0] = '黑';arr[1] ='马';



4.数组的内存结构

Java内存区域的划分:1)寄存器。2)本地方法区。3)方法区。 4)栈内存。5)堆内存。

为什么划分这么区域?因为每一个内存区域对数据的处理方式不同。目前要讲的就是栈和堆。

1栈内存的特点:存储都是局部变量

(函数参数,函数内定义的变量,语句中定义的变量)变量一旦使用完(作用域结束),就会在栈内存中自动释放。

2)堆内存特点:存储的是实体

1.堆内存中的实体都有首内存地址值.

2.堆内存中的变量都有默认初始化值.

3.对于没有任何引用变量指向的实体,会视为垃圾,会被垃圾回收机制所回收

(数组和对象,只要是new的,都在堆内存中)

黑马程序员 Java基础语法——下

5.操作数组时常见问题

A.数组角标越界异常(ArrayIndexOutOfBoundsException):操作数组时,访问到了数组中不存在的角标。

B.空指针异常(NullPointerException):当引用没有任何指向值为null的情况,该引用还在用于操作实体。

6.对数组的常见操作

                   1.获取数组中的元素 2.获取最值 3.排序(冒泡排序 最大的在最后、选择排序) 

                    4.查找(折半查找 只针对有序)插入(针对有序)


1).获取数组中的元素,通常会用到遍历

黑马程序员 Java基础语法——下


2).获取最值

最大值:

  1. /* 思路: 
  2.        1,需要进行比较。并定义变量记录住每次比较后较大的值。 
  3.        2,对数组中的元素进行遍历取出,和变量中记录的元素进行比较。 
  4.               如果遍历到的元素大于变量中记录的元素,就用变量记录住较大的值。 
  5.        3,遍历结果,该变量记录就是最大值。 
  6.   
  7.        定义一个功能来是实现。 
  8.        明确一,结果。 
  9.                      是数组中的元素。int . 
  10.        明确二,未知内容。 
  11.                      数组. 
  12. */  

黑马程序员 Java基础语法——下


最小值:

  1. /* 思路: 
  2.        1,需要进行比较。并定义变量记录住每次比较后较小的值。 
  3.        2,对数组中的元素进行遍历取出,和变量中记录的元素进行比较。 
  4.               如果遍历到的元素小于变量中记录的元素,就用变量记录住较小的值。 
  5.        3,遍历结果,该变量记录就是最小值。 
  6.   
  7.        定义一个功能来是实现。 
  8.        明确一,结果。 
  9.                      是数组中的元素。int . 
  10.        明确二,未知内容。 
  11.                      数组. 
  12. */  

黑马程序员 Java基础语法——下

3).排序

  1.         /*排序(选择排序,冒泡排序)*/  
  2.         public static void swap(int[] arr,int x,int y)  
  3.         {  
  4.               int temp = arr[x];  
  5.               arr[x]= arr[y];  
  6.               arr[y]= temp;  
  7.         }  
  8.        /* 
  9.        冒泡排序。 
  10.        */  
  11.        public static void bubbleSort(int[] arr)  
  12.        {  
  13.               for(int x=0; x<arr.length-1; x++)  
  14.               {  
  15.                      for(int y=0; y<arr.length-1-x; y++)  
  16.                      {  
  17.                             if(arr[y]>arr[y+1])  
  18.                             {  
  19.                                    swap(arr,y,y+1);  
  20.                             }  
  21.                      }      
  22.               }  
  23.        }  
  24.    
  25.    
  26.        /* 
  27.        选择排序。 
  28.        */  
  29.        public static void selectSort(int[] arr)  
  30.        {  
  31.               for(int x=0; x<arr.length-1; x++)  
  32.               {  
  33.                      for(int y=x+1; y<arr.length; y++)  
  34.                      {  
  35.                             for(arr[x]>arr[y])  
  36.                             {  
  37.                                    swap(arr,x,y);  
  38.                             }  
  39.                      }  
  40.               }  
  41.        }  

数组的工具类Arrays:开发中主要用于操作数组用其工具类。

此类包含用来操作数组(比如排序和搜索)的各种方法。 

其主要方法为:
1.排序:Arrays.sort( arr );

2.二分查找:Arrays.binarySearch(arr, key);

如果它包含在数组中,则返回搜索键的索引;否则返回(-(插入点) - 1)

3,复制指定的数组:Arrays.copyOf(arr, newLength);

返回新数组,长度不足则填充响应值。

4.复制指定范围的数组:Arrays.copyOfRange(arr,from,end);含头不含尾

5.toString:  Arrays.toString(arr);  返回数组的字符串形式

利用数组进行进制转换

public static void toBin(int num){

//定义二进制的表。

char[] chs = {'0','1'};  


//定义一个临时存储容器。

char[] arr = new char[32]; 


//定义一个操作数组的指针

int pos = arr.length; 

while(num!=0){

int temp = num & 1;

arr[--pos] = chs[temp];

num = num >>> 1;

}

for(int x=pos; x<arr.length; x++){

System.out.print(arr[x]);

}

}

public static void trans(int num,int base,int offset){

if(num==0){

System.out.println(0);

return;

}

char[] chs = {

'0','1','2','3',

'4','5','6','7',

'8','9','A','B',

'C','D','E','F'};  

//定义一个临时容器。

char[] arr = new char[32];  

int pos = arr.length;  


while(num!=0){

int temp = num & base;

arr[--pos] = chs[temp];

num = num >>> offset;  

}

System.out.println("pos="+pos);  


//存储数据的arr数组遍历。  

for(int x=pos;x<arr.length; x++)  {

System.out.print(arr[x]);

}

}

//二进制

public static int toBin(int num){

trans(num,1,1);

}

//八进制

public static int toBa(int num){

trans(num,7,3);

}

//十六进制

public static int toHex(int num){

trans(num,15,4);

}

注意: String toBina=Integer.toBinaryString (int i)

String toHex=Integer.toHexString(int i)

String toOctalString=Integer.toOctalString(int i)

九:二维数组

1.什么是二维数组:

其实元素就是一个一维数组。

2.二维数组格式:

(1).方式1:元素类型[][] 数组名 = new 元素类型[3][2];

例子:

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

解释:

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

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

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

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

给第一个一维数组1索引位赋值为78写法是:arr[0][1] = 98;

(2).方式2:元素类型[][] 数组名 =new 元素类型[3][];

例子:

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

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

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

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

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

(3).方式3:元素类型[][] 数组名 = {{一维数组元素}{一维数组元素}{一维数组元素}};

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


3.二维数组的遍历

思路:

(1).二维数组的每一个元素是一维数组。

获取到每一个一维数组。

(2).一维数组的遍历。

class Test {

public static void main(String[] args) {

//二维数组的遍历

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

//arr.length 获取二维数组的长度,其实也就是一维数组的个数

for(int x=0; x<arr.length; x++) {

//arr[x].length 获取的是每一个一维数组的长度

for(int y=0; y<arr[x].length; y++){

//arr[x][y] 获取的是二维数组的元素

System.out.print(arr[x][y]+"\t");

                    }

System.out.println();

}

}

}