黑马程序员-Java基础知识-day03

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

1、循环结构

代表语句：while,do while ,for

 

2、循环语句结构

(1)while语句：

while(条件表达式){

循环体（执行语句）；

}

特点：先判断条件，只有条件满足才会执行作用域中的循环体；

(2)do while语句

do{

执行语句；

}

while(条件表达式);

特点：无论条件表达式是否成立，作用域中的执行语句至少执行一次，然后再来判断条件表达式是否成立，条件满足，再继续执行循环体；

注意：do while语句的while后面需要加分号，而while后加分号后则不会执行循环体；

(3)for语句

for(初始化初始化1；循环条件表达式2；循环后的操作表达式4){

执行语句3；

}

注：

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

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

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

总结：

1，变量有自己的作用域，对于for来讲，如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效，for语句执行完毕，该变量在内存中释放。

2，for和while可以进行互换，如果需要定义循环增量，用for更为合适；

其实，用for语句更省内存，间接提高程序运行效率，因为for语句执行完毕后，变量会随程序的执行完毕而被垃圾回收机制回收。

什么时候使用循环结构？

当要对某些语句执行很多次时，就使用循环结构。需要特别指出一点的是，如果循环过后还需要当初定义的初始值，那么这里使用while循环更为合适。

/*
需求：统计1~100之间7的倍数的个数并打印
*/
class  Test3
{
       public static void main(String[] args)
       {
              int count=0;//定义一个计数器，用于存储不断变化的值
              for(int x=1;x<=100; x++)//考虑到时1到100之间，因此条件表达式初始值为1，而判断语句则会小于等于100；
              {
                     if(x%7==0)//x%7取余，即凡是能整除7的数，就是符合条件的数
{
System.out.println(“x=”+x);
count++;//凡是符合条件，则计数器就会自增一次
 
}
              }
              System.out.println("count="+count);
       }
}
 
小结：计数器思想，通过一个变量记录住数据的状态变化

//语句嵌套形式，其实就是语句中还有语句，循环嵌套。
class ForForDemo
{
       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();//换行
              }
              System.out.println("----------------------------");
 
              for(int x=0; x<5; x++)//x<5:因为外循环控制行数，一共5行。
              {
                     for(int y=x; y<5; y++)//内循环控制列数，而为了让*越来越少，最好的方法就是让x的值赋给y
                     {
                            System.out.print("*");
                     }
                     System.out.println();
              }
 
              System.out.println("----------------------------");
 
             
 
              /*
              1
              12
              123
              1234
              12345
              */
              for (int x=1;x<=5 ;x++ )
              {
                     for (int y=1;y<=x ;y++ )
                     {
                            System.out.print(y);
                     }
                     System.out.println();
              }
              System.out.println("--------------------------------");
 
              /*
              九九乘法表
              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");//直接输出，为了让输出的图像更好看，这里加入制表符：\t
                     }
                     System.out.println();//在外循环里换行
              }
       }
 
}

/*

****

****

****

对于打印长方形：外循环控制行数，内循环控制列数，也就是每一行中元素的个数。

*****

****

***

**

*

发现图形有很多行，每一行有很多列，要使用嵌套循环，

原理：形象说法即为大圈套小圈。

*

**

***

****

*****

*/

规律：

前提：外循环控制行数，内循环控制列数

尖朝上，可以改变内循环条件，让条件随着外循环变化；

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

3、其他流程控制语句

break（跳出）：应用范围：选择结构和循环结构。

continue（继续）：应用于循环结构。

注：

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

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

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

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

class OtherDemo
{
       public static void main(String[] args)
       {
              //break:
              w:for (int x=0;x<3 ;x++ )
              {
                     for (int y=0;y<4 ;y++ )
                     {
                            System.out.println("x="+x);
                            break w;
                     }
              }
 
              //continue:只能作用于循环结构，继续循环。
              //特点：结束本次循环，继续下一次循环。
              for (int x=1;x<=10 ;x++ )
              {
                     if(x%2==1)
                            continue;
                     System.out.println("x="+x);
              }
 
              /*
              记住：
              1.break和continue语句作用的范围。
              2.break和continue单独存在时，下面可以有任何语句，因为都执行不到。
              */
       }
}

/*
----*
---* *
--* * *
-* * * *
* * * * *
 
*/
 
class  ForForTest
{
       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();
              }
       }
}

语句的最后总结：

1.     什么时候使用变量？

当数据不确定的时候，就定义变量来存储数据。

2.     什么情况下，使用哪个语句？

A：当对某几个值进行判断的时候，可以使用if语句，或者switch语句。建议使用switch。但是，使用switch要注意，它只能操作五中类型的值：byte,short,int,char,String。如果是五中以外的值，需要使用if。

B:如果对数据区间in行判断，或者对运算结果是boolean类型的数据进行判断，用if语句。

C:当需要某些语句执行很多次的时候，使用循环结构。如果定义变量只为循环增量存在时，可以使用for语句。

D:如果要结束循环，可以控制循环条件，或者通过break语句来完成。

E:break结束当前所在循环，continue结束本次循环，并进入下一次循环。

F：switch语句中的default可以放在作用域的任意位置，但是当遇到语句中没有break等语句时，其执行完default语句且后面还有case语句时，程序将不再判断case语句而是直接执行case语句中的程序。

 

函数

1、函数的定义

什么是函数？

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

2、函数的格式：

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

       {

              执行语句；

              return 返回值；

       }

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

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

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

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

return：用于结束函数。

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

 

3、函数的特点：

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

2.便于对该功能进行复用。

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

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

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

注意：

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

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

 

4、如何定义一个函数呢？

       1.既然函数是一个独立的功能，那么该功能的运算结果是什么得先明确；

              因为这是在明确函数的返回值类型。

       2.再明确在定义该功能的过程中是否需要为之的内容参与运算。

              因为是在明确函数的参数列表（参数的类型和参数的个数）

class FuncitonDemo
{
       public static void main(String[] args)
       {
              /*
              int sum = getSum(2,9);
              System.out.println("sum="+sum);
              */
              print99();//调用99乘法表的方法
       }
      
       /*
       需求：定义一个功能，完成3+4的运算，并将结果返回给调用者。
       1.明确功能的结果：是一个整数的和。
       2.在实现该功能的过程中是否有为之内容参与运算，没有。
       其实这两个功能就是在明确函数的定义。
       1.是在明确函数的返回值类型。
       2.明确函数的参数列表（参数的类型和参数的个数）。
 
      
       public static int getSum()
       {
              return 3+4;
       }
       */
       public static int getSum(int x,int y)
       {
              return x+y;
       }
       //99乘法表
       public static void print99()
       {
              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();
              }
       }
}
注：在定义好的函数中，必须有静态static，因为主函数是静态的，只有静态的函数才能调用静态的方法

5、函数的重载（overload）：重载只和参数列表有关。

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

例如：参数类型不同：int add(int i)                 void add(double d)

参数个数不同：add(int a,int b);             add(int a,int b,int c)

参数顺序不同

重载的特点：

与返回值类型无关，只看参数列表。

重载的好处：

方便于阅读，优化程序设计

什么时候用重载？

       当定义的功能相同，但参与运算的位置内容不同，那么，这是就定义一个函数名称一表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

classFunctionOverLoad
{
       public static void main(String[] args)
       {
              print99();
       }
       public static void print99()
       {
              print99(9);//重载的形式
       }
       public static void print99(int num)
       {
              for(int x=1; x<=num; x++)
              {
                     for(int y=1;y<=x; y++)
                     {
                            System.out.print(y+"*"+x+"="+y*x+"\t");
                     }
                     System.out.println();
              }
       }
}

 

6、数组

1.数组的定义

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

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

格式：

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

示例：int[] x = new int[3];其中x为引用数据类型,

凡是局部变量都定义在栈内存中,而new出来的对象都存在于堆内存中。

 

2.内存结构

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

其中内存中一共分配了5个区域：

栈内存、堆内存、方法区、本地方法区、寄存器

(1)栈内存：用于存储局部变量(在函数中定义的变量)，当数据使用完，所占空间会自动释放。

(2)堆内存：

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

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

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

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

小结：栈内存里面的数据会在使用完毕后自动释放，而堆内存里的数据会被垃圾回收机制回收。其实在栈内存里面定义的数据类型都是引用数据类型，而在堆内存里存放的数据，会使引用数据类型指向堆内存里的数据，而引用数据其实指向的就是堆内存中的地址值。

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net