java编程基础第三天

---------------------- android培训、 java培训、期待与您交流！ ----------------------

  3.循环结构：当有语句需要被执行很多次的时候可以考虑用循环结构。
代表语句：while，do while，for
    1.while语句的格式：
//满足条件就执行下面的语句，执行完之后再看是否满足while的条件表达式，如果满足那么再继续执行，直到不满足为止。如果把while换成if就只执行一次。
while(条件表达式)
{
    执行语句（也叫循环体）;
}
按ctrl＋c可以强制结束命令行。为了能控制一定循环次数，循环体下面最好加上限制语句，比如：
int x=4;
while(x<6)
    {
    System.out.println("x="+x);
    x++;
    }
或者打印10以内的奇数，
int x=1;
while(x<10)//注意后面没有分号，一般来说程序的结束不是分号就是大括号，这里如果加上了分号，程序就会一直判断1是否小于10，如果满足就循环判断1是否小于10。
{
    System.out.println("x="+x);
    x+=2;
}
加入没有那个自增x++，那么就会一直循环下去，有了自增之后就会逐渐的停止直到不满足while条件为止。

    2.do while语句格式：
do//先执行下面的执行语句，然后判断while的条件表达式，如果满足条件，再循环执行do的执行语句。
{
    执行语句;
}
while(条件表达式);
比如：
int x=1;
do
{
    System.out.println("x="+x);//先打印1，再加一，等于2，再判断while条件，满足小于3，再打印2，再加一等于3就不满足while条件了，程序停止。
    x++;
}
while(x<3);//注意不要漏掉后面的分号

while和do while的区别：
while是先判断条件，满足条件再执行循环体。
do while是先执行循环体，再判断条件，条件满足再执行循环体。无论条件是否满足，循环体至少执行一次。

    3.for语句的格式：
for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句;
}
例如：
for(int x=1;x<3;x++)//先判断x是否小于3，满足则执行下面的打印x，再执行x++，得2，判断2是否满足小于3，满足则执行打印x，直到x不小于3为止。
{
    System.out.println("x="+x);
}
注意：初始化表达式只执行一次，for和while是可以互换的，但是for定义的变量只在for的大括号里面起作用，当循环结束后就会从内存中释放，这就是变量的作用域，在for中变量的作用域只是在for的大括号中，而while中的变量是先定义好的，当while循环结束之后，内存中的这个变量还在，还可以继续使用。这样的好处是用for可以节约内存。如果需要定义循环增量，用for更合适。还需要注意哪些语句需要参与循环，哪些不需要。
特例：
int x=1;
for(System.out.println('a');x,3;System.out.println("c"),x++)
{
    System.out.println("b");
}
int y=1;
for(;y<3;)
{
    System.out.println("x="+x);
    y++;
}
这里for的初始化表达式那里不一定非得要定义个变量，只要是合法的表达式都行，如果有多个表达式，中间用逗号隔开。这里x++写在打印c后面或写在打印b后面都一样。另外for里面的初始化表达式和循环后的表达式都可以不写。

无限循环的最简单表达式：
for：for(;;){}//当省略for的条件表达式时，默认是true。
while：while(true){}

循环结构应用举例：
/*
例一：
计算1到10的和，并打印。
思路：1加到10也就是：1+2+3+4+...+10
1+2
  3+3
    6+4
...
左边的都是上一次的和，右边是从2开始自增。
需要定义两个变量。
*/
class Sum
{
    public static void main(String[] args)
    {
        //定义变量，存储和
        int sum=1;
        //定义变量，存储被加数
        int x=2;
        while(x<=10)
        {
            sum+=x;
            x++;
        }
    System.out.println("1到10的和等于"+sum);
    }
}
也可以用for写：
class Sum
{
    public static void main(String[] args)
    {
        int sum=1;
        for(int x=2;x<=10;x++)//注意：由于最后要用到sum的值，sum就不要写到for的括号里面去了，不然循环结束后sum就从内存释放了。
        {
            sum+=x;
        }
        System.out.println("1到10的和等于"+sum);
    }
}

/*
例二：
/*
1~100之间7的倍数的个数，并打印。
思路：
1.对1~100进行循环（遍历）。
2.对循环的过程定义条件，只对7的倍数操作。
3.7的倍数不确定，需要变量记录能整除7的次数。
步骤：
1.定义循环语句，使用for语句。
2.在循环中定义判断，只要是7的倍数即可，使用if语句，即if(x%7==0)。
3.定义变量，记录x%7==0为真时的次数。
*/
class Test
{
    public static void main(String[] args)
    {
        int count=0;
        for(int x=1;x<=100;x++)
        {
                if(x%7==0)
               {
                   count++;
               }
         }
         System.out.println("次数为"+count);
    }
}
总结：以上就是累加和计数器思想，累加是通过变量记录不断变化的结果，通过循环进行累加，计数器是用变量记录数据变化的次数，也是通过循环进行累计。

循环嵌套举例：
1.打印长方形：
class Test
{
    public static void main(String[] args)
    {
        for(int x=0;x<3;x++)//这是外循环。
        {
            for(int y=0;y<4;y++)//这是内循环，等内循环结束才会回去执行外循环。
            {
                System.out.print("*");//注意print不加ln就是不换行。
            }
            System.out.println();//这段命令只是换行的作用。
        }
    }
}
注意：当外循环满足，条件后会执行内循环，要等内循环完成后才会回到外循环，上面的结果会显示：
****
****
****
外循环控制长方形的行数，内循环控制每行的个数。

2.打印倒三角形：
class Test
{
    public static void main(String[] args)
    {
        int z=5;
        for(int x=0;x<5;x++)
        {
            for(int y=0;y<z;y++)
            {
                System.out.print("*");
            }
            System.out.println();
            z--;
        }
    }
}
结果是：
*****
****
***
**
*
小结：遇到这样的三角形，由于每行的个数在递减或者递增，可以把控制内循环的条件变化范围定义变量，也就是y<z，而不是y<5，然后在内循环完成之后让z递增或者递减。当然还有多种写法：
int z=0;
        for(int x=0;x<5;x++)
        {
            for(int y=z;y<5;y++)
            {
                System.out.print("*");
            }
            System.out.println();
            z++;
或者：
        for(int x=0;x<5;x++)
        {
            for(int y=x;y<5;y++)
            {
                System.out.print("*");
            }
            System.out.println();
或者：   
  for(int x=5;x>0;x--)
        {
            for(int y=0;y<x;y++)
            {
                System.out.print("*");
            }
            System.out.println();
所以范围的变化，只要区间不变，头尾变化或者增减变化都一样。相同的目的有多种写法，目的就是简化代码，方便识别，怎么好看怎么简单就怎么写。

3.打印三角形：
class Test
{
    public static void main(String[] args)
    {
        for(int x=0;x<5;x++)
        {
            for(int y=0;y<=x;y++)
            {
                System.out.print("*");
            }
            System.out.println();
        }
        
    }
}
结果是：
*
**
***
****
*****
小结：打印三角形：
尖朝上，一般改变内循环条件，让其跟着外循环变化。
尖朝下，一般改变内循环初始化值，让其跟着外循环变化。

4.打印如下：
1
12
123
1234
12345
代码如下：
class Test
{
    public static void main(String[] args)
    {
        for(int x=2;x<7;x++)
        {
            for(int y=1;y<x;y++)
            {
                System.out.print(y);    
            }
            System.out.println();
        }
    }
}

5.打印九九乘法表：
1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12  4*4=16
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81
代码是：
class Test
{
    public static void main(String[] args)
    {
        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();
        }
    }
}
小结：如果要对齐，需要在打印的最后加上制表符。

6.打印：

----*
---* *
--* * *
-* * * *
* * * * *
代码：
class Test
{
    public static void main(String[] args)
    {
        for(int x=0;x<5;x++)
        {
            for(int y=x;y<4;y++)
            {
                System.out.print("-");
                
            }
            for(int z=0;z<=x;z++)
            {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}
注意这段代码里面的fou里面嵌套了两个for，打印的时候如果有多种字符可以分别拆开来循环。

  在流程控制中的其他语句：

  break语句：用于选择和循环结构，执行跳出动作。
应用举例：
class Test
{
    public static void main(String[] args)
    {
        for(int x=0;x<=3;x++)
        {
            for(int y=0;y<=3;y++)
            {
                System.out.println("x="+x);
                break;
            }
        }
    }
}
其结果是：
x=0
x=1
x=2
x=3
注意：break只是跳出当前循环，比如上面的break跳出的是内循环。但是可以给循环进行标识，标识后就可以跳出指定的循环，比如：
class Test
{
    public static void main(String[] args)
    {
        a:for(int x=0;x<=3;x++)
        {
            b:for(int y=0;y<=3;y++)
            {
                System.out.println("x="+x);
                break a;
            }
        }
    }
}
结果是x=0，因为内循环执行完一次之后外循环就跳出了，整个循环就结束了，所以只打印了一次x。

  continue：用于循环结构
举例1：
class Test
{
    public static void main(String[] args)
    {
        for(int x=0;x<=10;x++)
        {
            if(x%2==1)
            {
                continue;
            }
            System.out.println("x="+x);
        }
    }
}
结果是：
x=0
x=2
x=4
x=6
x=8
x=10
当x%2==1之后，就会执行x++，让后在判断x%2==1，如果不等于1，则会打印x。所以continue的作用就是结束本次循环，继续下次循环。

举例2：
//continue同样可以用于指定标识
class Test
{
    public static void main(String[] args)
    {
        a:for(int x=0;x<=3;x++)
        {
            b:for(int y=0;y<=3;y++)
            {
                System.out.println("x="+x);
                continue a;
            }
        }
    }
}
结果是：
x=0
x=1
x=2
x=3

小结：注意两个语句的作用范围，就是标识。两个语句单独存在的时候的下面不能有任何语句，否则会报错，比如
b:for(int y=0;y<=3;y++)
            {
                System.out.println("x="+x);
                continue a;
                System.out.println("x="+x);
            }
这样就会报错了。

  函数的定义
函数也叫做方法。java的函数就有点像ae的预设，把某些重复的难做的代码提取出来，为了方便日后使用。

  函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型形式 参数2,...)
{
    执行语句;
    return  返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：就是变量的类型。
形式参数：就是一个变量
实际参数：传递给变量的实际参与运算的值。
return ：用于结束函数。
返回值：该值会返回给调用者。

举例：
class Test
{
    public static int a(int x)
    {
        System.out.println(x*3+5);
        return x;
    }
    public static void main(String[] args)
    {
            a(5);
    }
}
小结：结果是20，修饰符是public static，可以省略public只写static，这里加入没有具体的返回值类型，返回值的类型就要用void代替，当用void代替的时候，return后面的返回值就不要写了，而且return也可以不写。定义函数的时候不能写在其他函数里面。
比如上面的可以这样写：
class Test
{
    static void a(int x)
    {
        System.out.println(x*3+5);    
    }
    public static void main(String[] args)
    {
            a(5);
    }
}
或者
class Test
{
    static void a(int x)
    {
        System.out.println(x*3+5);
        return；   
    }
    public static void main(String[] args)
    {
            a(5);
    }
}
而不能写成：
class Test
{   
    public static void main(String[] args)
    {
        static void a(int x)
        {
            System.out.println(x*3+5);    
        }
            a(5);
    }
}
因为主函数也是函数，不能在函数里面定义函数。要像上面那样写在其他函数的括号外面，放在主函数上面下面都行，但是程序的执行都是从主函数开始，而且函数可以调用函数，向上面那样主函数调用了新定义的函数。编程就是在不断实现功能，而函数就是java最小的功能单位，编程的时候把一个功能分解为不同类的小功能，用函数编写，然后用主函数调用，就像先用max，ps，boujou做好不同部分，然后拿到ae合成。
定义函数需要明确：函数运算结果是什么，定义过程中是否需要未知内容参与运算。其实就是需要明确返回值类型和参数列表。

函数定义举例：
1.比较两个整数是否相等：
class Test
{
    public static boolean compare(int x,int y)
    {
        return x==y;
    }
    public static void main(String[] args)
    {
        System.out.println(compare(3,4));
    }
}
2.比较两个整数的大小，取较大的数：
class Test
{
    public static int getMax(int x,int y)
    {
        return (x>y)?x:y;
    }
    public static void main(String[] args)
    {
        System.out.println(getMax(3,4));
    }
}
注意：当返回值类型是void的时候，是不能调用的，当返回值是void的时候，如果要输出则直接写，例如下面：
class Test
{
    static void a(int x)
    {
        System.out.println(x*3+5);
        return；   
    }
    public static void main(String[] args)
    {
            a(5);
    }
}
但不能写成：
class Test
{
    static void a(int x)
    {
        return x*3+5;
    }
    public static void main(String[] args)
    {
         System.out.println(a(5));
    }
}
3..打印矩形：
/*
思路：
1.因为是直接打印，没有确定结果，返回值类型是void。
2.因为矩形的行列不确定，有未知内容。
*/
class Test
{
    public static void draw(int row,int col)//col是column的缩写。
    {
        for(int x=0;x<row;x++)
    {
        for(int y=0;y<col;y++)
        {
            System.out.print("*");
        }
        System.out.println();
    }
    return;
    }
    public static void main(String[] args)
    {
         draw(5,5);
    }
}
4.打印乘法表：
/*
思路：
1.因为是直接打印，没有确定结果，返回值类型是void。
2.想算到哪个数不确定，有未知内容。
*/
class Test
{
    public static void chengfa(int a)
    {
        for(int x=1;x<=a;x++)
    {
        for(int y=1;y<=x;y++)
        {
            System.out.print(y+"*"+x+"="+y*x+"\t");
        }
        System.out.println();
    }
    return;
    }
    public static void main(String[] args)
    {
         chengfa(9);
    }
}

  函数的重载：在同一个类中允许出现一个以上的同名函数，但参数列表不同。当定义的多个函数功能相同，只是未知内容不同时，不同的函数可以用同一函数名，方便使用和阅读。jvm会自动调用匹配的函数。比如：
class Test
{
    public static void main(String[] args)
    {
        System.out.println(getSum(1,2,3));
        System.out.println(getSum(1,2));    
    }
    public static int getSum(int x,int y)
    {
        return x+y;
    }
    public static int getSum(int x,int y,int z)
    {
        return x+y+z;//这里还可以简化。写成return getSum(x,y)+z;别人写好的代码就像是预设，都可以拿来套用。
    }
}
虽然同是getSum的函数名，但是参数列表不同，jvm在调用的时候会自动选择匹配的函数。

  思考：下面那个和原函数重载了：
void show(int a,char b,double c){}

A. void show(int x,char y,double z){}//没有，和原函数一样，因为变量是可以用任意字符代替的，xyz也可以用abc表示。

B. int show(int a,double c,char b){}//重载，因为参数列表有顺序，第一个参数都是int，但是B选项第二个参数是double，原函数第二个是char。注意重载与返回值类型无关。

C. void show(int a.double c,char b){}//重载，道理同上。

D. boolean show(int c,char b){}//重载，因为参数个数不同。

E. void show(double c){}//重载，道理同上。

F. double show(int x,char y,double z){}//没有，因为与返回值类型无关，参数列表里面按顺序类型都相同，xyz也可以用abc表示。
//由于这个函数的返回值类型和原函数不同，虚拟机在调用show的时候不知道返回值是void还是double，所以F选项不能和原函数存在于同一个类中。
---------------------------------------------------------------------------------------------------------------------------
  数组：
数组是用来存数据的，存同一类型的数据。数组会自动给里面的元素从0开始编号，方便操作。

  数组的格式：
格式1 ：
元素类型[]  数组名 = new 元素类型[ 元素个数或数组长度];//new这个关键字用来在内存中新建一个存数据的容器实体。
//这里的数组名的类型不是元素的类型，而是数组类型。比如：
int[] x=new int[3];//这里的x是数组名，类型是数组，不是int。

小结：数据类型回顾：
                                                                                                              数据类型

                                                               基本数据类型                                                              引用数据类型
                                                                                                              

       数值型                    字符型char                    布尔型boolean                         类class       接口interface      数组[]
                                                                                                              
   整数类型
byte，shot，int，long
   浮点类型
float，double

  内存结构：
栈内存：用与存储局部变量，定义在方法中的和定义在方法的参数中的以及定义在for中的都是局部变量，栈内存中的数据用完之后会自动释放。
堆内存：用于存储实体，实体包括对象和用new创建的东西。每一个实体都有内存地址值，用十六进制表示，实体中的每个数据都有角标，并且都有初始化值，因数据的不同类型而有不同的初始化值，比如：int是0，double是0.0，float是0.0f，boolean是false。

比如：
int[] x=new int[3];//其中x在栈内存中，new int[3]在堆内存中。栈内存中的x就指向堆内存中的那个十六进制地址值。
x[0]=5;//表示给角标为0的数据赋值为5。
x=null;//表示不再让x指向数组，null只能用于数组类型的数据。
//当堆内存中的实体不再被使用，也就是栈内存中没有数据指向堆内存中的实体的时候，这个实体就是垃圾，会在不定时间内被垃圾回收器回收。

注意：
int[] x=new int[3];//定义了一个叫x的数组指向堆内存中的一个实体。
int[] y=x;//把x赋值给y，进而y和x指向了同一个实体。
y[1]=5;//把实体中角标为1的值改为5。
x=null;//切断x与实体的指向。
问题是以上在堆内存中有垃圾吗，没有，因为x和y指向同一实体，切断了x的，但是y的指向还存在。

但是如果改成了这样：
int[] x=new int[3];
int[] y=new int[3];
x=null;
问题还是堆内存中有垃圾吗，有了，因为尽管x和y后面都是new int[3]，但只要是输入new，就会在堆内存中重新开辟一个新的空间，所以x和y各自指向不同的实体，当切断x的指向之后，x指向的那个实体成了垃圾，而y的指向还存在。

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima