JAVA_TOJAVASE_Day04（函数，数组，语句）

for语句嵌套练习：

实现如下图形

*****
****
***
**
*

//      int z=5;
//      for (int i = 1; i <=5; i++) {//1-5 1-4 1-3   //1-5 2-5 3-5
//
//          for (int y = 1; y <=z; y++) {
//              System.out.print("*");
//          }
//          System.out.println();
//          z--;
//      }


        int z=1;
        for (int i = 1; i <=5; i++) {  //1-5 2-5 3-5

            for (int y = z; y <=5; y++) {
                System.out.print("*");
            }
            System.out.println();
            z++;
        }
    }

实现以下图标：

*
**
***
****
*****

public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

实现以下图形

54321
5432
543
54
5

for(int i=1;i<=5;i++) {

            for(int j=5;j>=i;j--) {
                System.out.print(""+j);
            }
            System.out.println();
        }

输出以下图形

1*1=1
1*2=22*2=4
1*3=32*3=63*3=9
1*4=42*4=83*4=124*4=16
1*5=52*5=103*5=154*5=205*5=25
1*6=62*6=123*6=184*6=245*6=306*6=36
1*7=72*7=143*7=214*7=285*7=356*7=427*7=49
1*8=82*8=163*8=244*8=325*8=406*8=487*8=568*8=64
1*9=92*9=183*9=274*9=365*9=456*9=547*9=638*9=729*9=81

public static void main(String[] args) {
        for(int i=1;i<=9;i++) {

            for(int y=1;y<=i;y++) {
                System.out.print(y+"*"+i+"="+y*i+"");
            }
            System.out.println();
        }
    }

特殊符号：
\n :回车
\t:制表符
\b:退格
\r:按下回车键

windows 系统中回车符其实是俩个符号组成的。 \r\n
linux中回车符是： \n

当需要输出带双引号的字符串时，就需要转义了
如下：
System.out.println(“\”helloworld\”“);
\反斜线转义的是后面的”

当需要输出带有(反斜线)的字符串时用如下：
System.out.println(“\helloworld\”);

写出如下图形：

* * * * * 
 * * * * 
  * * * 
   * * 
    * 

    for(int x=1;x<=5;x++) {

            for(int y=1;y<x;y++) {
                System.out.print(" ");
            }
            for(int i=x;i<=5;i++) {
                System.out.print("* ");
            }
            System.out.println();

        }

其他流程控制语句

break :跳出
break 作用的范围，要么是switch语句，要么是循环语句
记住：当break语句单独存在时，下面不要定义其他语句，因为执行不到。

break跳出当前所在的循环，如果出现循环嵌套，break如果想要跳出指定的循环，可以通过标号来完成。默认是跳出所在循环。

for (int x = 0; x < 3; x++) {
            for (int i = 0; i < 4; i++) {
                System.out.println("x=" + x);
                break;
            }
        }
        结果是：x=0
x=1
x=2

break 跳出指定标识

xiaoqiang: for (int x = 0; x < 3; x++) {
            wangcai: for (int i = 0; i < 4; i++) {
                System.out.println("x=" + x);
                break xiaoqiang;
            }
        }
        输出结果：x=0

continue :继续
作用范围：循环结构
continue：结束本次循环，继续下次循环。
如果continue单独存在时，下面不要有任何语句，因为执行不到。

for (int i = 0; i < 8; i++) {
            System.out.println("i=" + i);
            continue;
        }
        //这样写continue和不写没有区别

for (int i = 0; i < 8; i++) {
            continue;
            System.out.println("i=" + i);

        }
        //这样写下面的语句执行不到。

for (int i = 0; i < 8; i++) {
            if (i % 2 == 0) {
                continue;
            }
            System.out.println("i=" + i);
        }
        输出的结果是：奇数
        i=1
i=3
i=5
i=7

    xiaoqiang: for (int x = 0; x < 3; x++) {
            wangcai: for (int i = 0; i < 4; i++) {
                System.out.println("x=" + x);
                continue xiaoqiang;
            }
        }
        结果：x=0
x=1
x=2

函数

特殊情况：
功能没有具体的返回值。
这时return的后面直接用分好结束。
返回值类型怎么体现呢？因为没有具体值，所以不可以写具体的数据类型。
在java中只能用一个关键字来表示这种情况，关键字是：void
总结：没有具体返回值时，返回值类型用void来表示。
注意：如果反水质类型是void ，那么函数中的return语句可以省略不写。

函数的重载（overload）

    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 int add() {
        return 0;
    }

static 关键字

• 首先，两者本质上的区别是：静态方法是在类中使用staitc修饰的方法，在类定义的时候已经被装载和分配。而非静态方法是不加static关键字的方法，在类定义时没有占用内存，只有在类被实例化成对象时，对象调用该方法才被分配内存。
• 其次，静态方法中只能调用静态成员或者方法，不能调用非静态方法或者非静态成员，而非静态方法既可以调用静态成员或者方法又可以调用其他的非静态成员或者方法。

这里的静态，指以static关键字修饰的，包括类，方法，块，字段。

非静态，指没有用static 修饰的。

静态有一些特点：

1.全局唯一，任何一次的修改都是全局性的影响

2.只加载一次，优先于非静态

3.使用方式上不依赖于实例对象。

4.生命周期属于类级别，从JVM 加载开始到JVM卸载结束。

为什么静态方法不能调用非静态方法?

这个要从java的内存机制去分析，首先当你New 一个对象的时候，并不是先在堆中为对象开辟内存空间，而是先将类中的静态方法（带有static修饰的静态函数）的代码加载到一个叫做方法区的地方，然后 再在堆内存中创建对象。所以说静态方法会随着类的加载而被加载。当你new一个对象时，该对象存在于对内存中，this关键字一般指该对象，但是如果没有 new对象，而是通过类名调用该类的静态方法也可以。

程序最终都是在内存中执行，变量只有在内存中占有一席之地时才会被访问，类的静态成员（变态和方法）属于类本身，在类加载的时候就会分配内存，可以 通过类名直接去访问，非静态成员（变量和方法）属于类的对象，所以只有在类的对象禅师（创建实例）的时候才会分配内存，然后通过类的对象去访问。

在一个类的静态成员中去访问非静态成员之所以会出错是因为在类的非静态成员不存在的时候静态成员就已经存在了，访问一个内存中不存在的东西当然会出错。

那类是什么时候被加载呢？在需要调用的时候被加载。

java 数组

格式1：
int[] arr =new int [5];

格式2
int[] arr=new int{3,5}

/**
* 内存的划分。
* 1.寄存器
* 2.本地方法区
* 3.方法区
* 4.栈内存
* 存储的都是局部变量
* 而且变量所属的作用域一旦结束，该变量就自动释放。
* 5.堆内存
* 存储的是数组和对象（其实数组就是对象），凡是new建立的都在堆中。
* 特点：
* 1.每一个实体都有首地址值
* 2.堆内存中的每一个变量都有默认的初始化值，根据类型的不同而不同，整数是0，小数是0.0，或者0.0f，boolean false ，char ‘\u0000’
*
*/

引用数据类型：