java学习第04天（语句、函数、数组）

（3）循环结构

格式：

for(初始化表达式，循环条件表达式，循环后的操作变大时){
   执行语句，循环体；
}

注：

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

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

c. 最简单无限循环格式，while（true），for（），无线循环存在的原因是并不知道循环多少次，二十根据某些条件，来控制循环。

注意：

/*
      
:回车
      	:制表符
      :退格
      
:按下回车键
      window系统中回车符其实是由两个符号组成的

      linux中回车符是

      */
//练习题1:
class  forDemo
{
   public static void main(String[] args)
   {
      //大全套小圈思想
      for(int x=0; x<3;x++){//外循环控制的是行数
        for(int y=0; y<4;y++){//内循环控制的是每一行的个数
           System.out.print("*");
        } 
        System.out.println();
      }    
   }
}

/*输出结果：
****
****
****
*/
 

练习题2

class  forDemo
{
   public static void main(String[] args)
   {
      for(int x=0; x<5;x++){
        for(int y=5-x; y>0;y--){
           System.out.print("*");
        } 
        System.out.println();
      }    
   }
}

运行结果：

*****

****

***

**

*

练习题3：

class  forDemo
{
   public static void main(String[] args)
   {
      for(int x=0; x<6;x++){
        for(int y=0; y<x;y++){
           System.out.print("*");
        } 
        System.out.println();
      }    
   }
}

运行结果：

*

**

***

****

*****

例题4：

class  forDemo
{
   public static void main(String[] args)
   {
      for(int x=1; x<=9;x++){
        for(int y=1; y<=x;y++){
           System.out.print(x+"*"+y+"="+x*y+"	");
        } 
        System.out.print("
");
      }    
   }
}

运行结果：

乘法口诀

联系5：

class  forDemo
{
   public static void main(String[] args)
   {
      for(int x=1; x<=6;x++){
        for(int z=0; z<x-1;z++){
           System.out.print(" ");
        }
        for(int y=6-x; y>0;y--){
           System.out.print("* ");
        } 
        System.out.print("
");
      }    
   }
}

运行结果：

/*

      * * * * *

       * * * *

        * * *

         * *

          *

      */

（4）其他流程控制语句

break（跳出），continue（继续）

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

例题：

class  forDemo
{
   public static void main(String[] args)
   {
      /*
      break：跳出。
      break作用的范围，要么是switch语句，要么是循环语句。
      记住：当break语句单独存在是，下面不要定义其他语句，因为执行不到。
        break跳出当前所在的循环
        如果出现了循环嵌套，break想要跳出指定的循环可以通过标号来完成。
      */ 
      xiaoqiang:for(int x=0;x<3;x++)
      {
        wangcai:for(int y=0;y<4;y++)
        {               
           System.out.print("x="+x);
           break xiaoqiang;          
        }       
      }    
   }
}

continue语句：应用于循环结构

例题：

class  forDemo
{
   public static void main(String[] args)
   { 
      /*
      continue:继续
      作用的范围：循环结构。
      continue:解除本次循环，继续下次循环。
      如果continue单独存在时，下面不要有任何语句，因为执行不到。

      for(int x=0;x<11;x++){
        if(x%2 == 0)
           continue;
        System.out.println("x="+x);      
      }*/
      xiaoqiang:for(int x=0;x<3;x++)
      {
        wangcai:for(int y=0;y<4;y++)
        {               
           System.out.println("x="+x);
           continue xiaoqiang;          
        }       
      }     
   }
} 

注：

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

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

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

d. 标号的出现，可以让这两个语句作用于指定的位置。

7.函数

（1）函数的定义

什么是函数：

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

   函数也称为方法。

函数的格式：

   修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…………）{

   执行语句；

return 返回值；

特殊情况：

功能没有具体的返回值

这时return的后面直接用分号结束。

返回值类型怎么处理呢？因为没有具体值，所以不可以写具体的数据类型。在java中只能用一个关键字来表示这种情况。关键字：void。

总结：没有具体返回值时，返回值类型用void来表示。

注意：如果返回值类型是void的话，那么函数中的return语句可以忽略不谢。

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

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

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

return：用于结束函数。

返回值：该函数运算结束后的结果，该结果会返回给调用者。

例题：

class FunctionDemo
{
   public static void main(String[] args)
   {
      /*int a = 3;
      int b = 4;
      int c;
      c = a+b;
      */
      int c = add(3,4);//调用的函数也需要是static的，所以add方法前面加static
      System.out.println("c="+c);
   }
   public static int add(int a,int b)
   {
      return a+b;
   }
}

（2）函数的特点

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

b.便于对该功能进行复用

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

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

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

f.注意：

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

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

（3）函数的应用

class FunctionDemo
{
   public static void main(String[] args)
   {
      //int sum = jiaFa(5,10);
      //System.out.println(sum);
      //draw(4,6);
      //print99();
      getLevel(95);
   }
   /*
   需求1：定义一个功能，完成两个整数的和的获取。
   思路：既然定义功能，就是可以用函数来体现
      如何定义一个函数呢？
      通过两个明确来完成
   明确一：这个功能的结果是什么？是和。所以该功能的返回值类型是int。
   明确二：这个功能实现过程中是否需要未知内容参与计算？有，加数与被加数。这就是函数的参数列表（参数的个数   参数类型）。
   其实就是在明确参数列表 
   注意点：返回值类型和参数类型没有直接关系。
   */
   public static int jiaFa(int a,int b)
   {
      int sum = a+b;
      return sum;
   }
 
   /*
   需求2：定义一个功能，画一个矩形在控制台。
   明确一：这个功能的结果是什么？
        没有结果，因为直接打印到控制台，并未返回给调用者，用void表示。
   明确二：这个功能实现过程中是否需要未知内容参与计算？
        有，行和列不确定。两个，整数 int。
   */
   public static void draw(int row,int col)
   {
      for(int x=1;x<=row;x++)
      {
        for(int y=1;y<=col;y++)
        {
           System.out.print("*");
        }
        System.out.println();
      }
      //return;//可以省略不写
   }
 
   /*
   需求3：定义一个功能，比较两个数是否相等。
   明确一：这个功能的结果是什么？
        有，boolean。
   明确二：这个功能实现过程中是否需要未知内容参与计算？
        有，两个整数。
   */
 
   public static boolean equals(int a,int b)
   {
      /*if(a == b)
        return true;
      else
        return false; 
      return a==b? true:false;//三元运算符
      */
      return a==b;
   } 

   /*
   需求4：定义一个功能，获取两个整数中较大的那个数。
   明确一：这个功能的结果是什么？
        有，其中一个数 int
   明确二：这个功能实现过程中是否需要未知内容参与计算？
        有，参与比较的两个整数 int。
   */  

   public static int getMax(int a,int b)
   {
      /*if(a>b)
        return a;
      else
        return b;*/
      return a>b? a:b;
   }

   /*
   需求5：定义一个功能，打印99乘法表。
   明确一：这个功能的结果是什么？
        没有结果，因为直接打印到控制台，并未返回给调用者，用void表示。
   明确二：这个功能实现过程中是否需要未知内容参与计算？
        有，行和列不确定。两个，整数 int。
   */

   public static void print99()
   {
   for(int x=1;x<=9;x++)
      {
        for(int y=1;y<=x;y++)
        {
           System.out.print(y+"*"+x+"="+x*y+" " );
        }
        System.out.println();
      }
   } 

   /*
   需求6：根据考试成绩获取学生分数对应的登记
   99~100  A
   80~89 B
   70~79 C
   60~69 D
   60以下  E

   明确一：这个功能的结果是什么？
        有，返回等级，字符，char
   明确二：这个功能实现过程中是否需要未知内容参与计算？
        有，分数 int。
   */

   public static char getLevel(int nums)
   {
      char level;
      if(nums >=90 && nums <=100)
        level = 'A';
      else if(nums >=80 && nums <=89)
        level = 'B';
      else if(nums >=70 && nums <=79)
        level = 'C';
      else if(nums >=60 && nums <=69)
        level = 'D';
      else
        level = 'E';
      return level;   
   }
}

（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;}
/*
需求：函数的重载
*/

class  FunctionDemo4
{
   public static void main(String[] args)
   {
      //add(4,5);//找第一个add方法
      //add(4.2,5.9);//找第二个add方法
      //add(4,5，10);//找第三个add方法
      printCFB(15);
      //System.out.println("Hello World!");
   }
   /*

   函数的要求：

   1.同一个类

   2.同名

   3.参数个数不同，or参数类型不同

   4.函数的重载和返回值类型无关

   5.java是严谨性计，如果函数出现的调用不确定性，会编译失败。

  

 */

   //加法运算，两个整数的和。
   public static int add(int a,int b)
   {
      return a+b;
   }  

   //加法运算，两个小数的和。
   public static double add(double a,double b)
   {
      return a+b;
   }

   //加法运算，三个整数的和。
   public static int add(int a,int b, int c)
   {
      return a+b+c;
   }

   /*
   打印乘法表
   */
   public static void printCFB(int num)
   {
      for(int x=1;x<=num;x++)
      {
        for(int y=1;y<=x;y++)
        {
           System.out.print(y+"*"+x+"="+x*y+" " );
        }
        System.out.println();
      }
   } 

   /*
   打印标准乘法表
   */
   public static void printCFB()
   {
      printCFB(9)；
   }
}

8.数组

（1）数组的定义

概念：

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

数组的好处：

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

格式1：

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

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

格式2：

   元素类型[] 数组名 = new 元素类型(元素,元素,元素……);

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

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

（2）数组的内存分配及特点

class ArrayDemo
{
   public static void main(String[] args)
   {
      //元素类型[] 数组名 = new 元素类型{元素个数或者数组长度}
      {//局部代码块,限定局部变量的生命周期。
        int age = 3;
      } 
      int[] arr = new int[3];//基本定义格式
      arr[0] = 89;
      System.out.println(arr[0]);
   }
}
/*
内存的划分：
1.寄存器
2.本地方法区（所在系统相关的）
3.方法区
4.栈内存
   存储的都是局部变量。
   而且变量所属的作用域一旦结束，该变量就自动释放。
5.堆内存
   堆存储的是数组和对象（其实数组就是对象），凡是new建立的都在堆中。
   特点：
   1.每一个实体都有首地址值。
   2.堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同，数值是0，小数0.0或者0.0f，boolean false，char 'u0000'。
   3.垃圾回收机制。（自动回收）

*/

（3）数组操作常见问题

class ArrayDemo2
{
   public static void main(String[] args)
   {
      int[] arr = new int[3];
      //System.out.println(arr[3]);
      //ArrayIndexOutOfBoundsException
      //当访问到数组中不存在的角标时；就会发生该异常。     
      //arr = null;
      //System.out.println(arr[0]);
      //NullPointerException
      //当引用型变量没有任何实体指向时，还在用其操作实体，就会发生该异常。 
      System.out.println(arr);//直接输出数组,[I@15db9742
   }
}

（4）数组常见操作

（5）数组中的数组

视频教程地址：https://chuanke.baidu.com/v1867921-123914-300154.html