周报（0.0）

枯木逢春不在茂，年少且惜镜边人

这周呢，很是浮躁，所以来回顾下java，当我打开idea 的时候 发现出了问题我当时就 蒙蔽了，找了很久不知道什么原因，所以我又重新配置了一下，额真的淦

好的，看看我真正开始写的第一个java吧！淦

Error:(8, 1) java: 需要class, interface或enum

哦，对不起这的确是第一个

package com.company;

public class Main {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

看起来很简短，但是也算是入门吧，好的继续学习

再来简单的看看1-100 的累加吧！

package com.company;

public class jiuhe {
    public static void main(String[] args) {
        System.out.println("结果是："+sumpun());
    }
    public static int sumpun(){
        int sum=0;
        for (int i = 1; i <=100; i++) {
            sum += i;
        }
         return sum;
    }
}

这个是用函数写的，没带参数，基本和c语言差不多

再写一个指定次数的hello

package com.company;

public class Main {
    public static void main(String[] args) {
        printf(5);
    }

    public static void printf(int sum) {
        for (int i = 1; i <=sum; i++) {
            System.out.println("hello"+i);
        }
        return;
    }
}

结果

hello1
hello2
hello3
hello4
hello5

再来看看重载的东西，淦就完了

package com.company;

public class bool {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        System.out.println(haha(a,b));

        System.out.println(haha((short)a,(short)b));

        System.out.println(haha((byte) a,(byte)b));

        System.out.println(haha(10L,10L));

    }

    public  static boolean haha(int a, int b)
    {
        System.out.println("这是int比较方法");
        boolean sum;
        if(a==b)
            sum=true;
        else
            sum=false;
        return sum;
    }


    public static boolean haha(byte a,byte b)
    {
        System.out.println("这是byte比较方法");
        boolean sum=a==b?true:false;
        return sum ;
    }

    public static boolean haha(short a,short b)
    {
        System.out.println("这是short比较方法");
        if(a==b)
            return true;
        else
            return false;
    }

    public static boolean haha(long a,long b)
    {
        System.out.println("这是long比较方法");
        return a==b;
    }
}

看看结果

这是int比较方法
false
这是short比较方法
false
这是byte比较方法
false
这是long比较方法
true

重载即使是函数变量名称相同，他也会根据变量类型的不同而去选择不同的函数

接下来看看数据类型吧，c语言里面还有什么 sign int 什么的就是占据字节很大之类的

package com.company;

import com.sun.org.apache.xpath.internal.objects.XString;

public class shuchu {
    public static void main(String[] args) {
        print(100.1);
        print("hello");
    }

    public static void print(int num)
    {
        System.out.println(num);
    }

    public static void print(short num)
    {
        System.out.println(num);
    }

    public static void print(long num)
    {
        System.out.println(num);
    }

    public static void print(double num)
    {
        System.out.println(num);
    }

    public static void print(float num)
    {
        System.out.println(num);
    }

    public static void print(byte num)
    {
        System.out.println(num);
    }

    public static void print(char is)
    {
        System.out.println(is);
    }

    public static void print(String str)
    {
        System.out.println(str);
    }

    public static void print(boolean hl)
    {
        System.out.println(hl);
    }
}

结果

100
hello

基本上常见的类型都在这里
与c语言不同的是这里面多了个boolean值
这个东西，
只有 true 和false 两个 也就相当于 0 1

下面看看动静态数组

package com.company;

import com.sun.org.apache.xpath.internal.objects.XString;

public class dongtai {
    public static void main(String[] args) {
        int[] a= new int[5];
        int[] b= new int[]{0,1,2,3};
        String[] c=new String[]{"hello","java","devc-pp"}
        //是动静态的数组写法
        //下面看看省略写法
        int[] d;
        d=new int[5];
        //动态
        int[] e;
        e=new int[]{0,1,2,3};
        //静态
        int[] f={5,6,7};
        int[] g;
        g={0,1,2,3};
    }
}

注意

   int[] g;
   g={0,1,2,3};

这种格式是错误 的 ，静态不支持分开写
再来看看数组的取值

package com.company;

public class shuzu {
    public static void main(String[] args) {
        int[] a=new int[]{1,2,3};
        System.out.println(a);
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
    }
}

数组名称代表数组的地址

package com.company;

public class shuzu {
    public static void main(String[] args) {
        int[] a=new int[]{1,2,3};
        int num;
        System.out.println(a);
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
        num=a[1];
        System.out.println(num);
    }
}

基本上和c差不多

但是如果你定义一个动态的数组，int 类型 他初始值是0
而字符型是 \u0000
Boolean型是 false
引用类型是 NULL

内存结构
一、栈：储存局部变量

局部变量：在方法的定义中或者在方法声明上的变量称为局部变量。
特点：栈内存的数据用完就释放。

二、堆：储存 new 出来的东西

特点：
    每一个 new 出来的东西都有地址值；
    每个变量都有默认值 （byte, short, int, long 的默认值为 0；float, double 的默认值为 0.0；char 的默认值为 “\u0000”；boolean 的默认值为 false；引用类型为 null）；
    使用完毕就变成垃圾，但是并没有立即回收。会有垃圾回收器空闲的时候回收。

三、方法区：

一个对象的运行过程：

程序从 main 方法中进入；运行到 Phone p 时，在栈中开辟了一个空间；
new Phone() 时，在队中开了一个内存空间，此时会有一个内存值为 0x0001；此时会找到对应的 Phone 的 class 文件，发现有三个变量和三个方法，于是将三个成员变量放在了堆中，但是此时的值为默认值（具体默认值见上）。注意，在方法区里也有一个地址值，假设为 0x001，可以认为在堆中也有一个位置，在堆中的位置，可以找到方法区中相对应的方法；
继续运行，p.brand = "三星"；将三星赋值给 p.brand，通过栈中的 p 找到了堆中的 brand，此时的 null 值变为“三星”。剩下的类似；
当运行到 p.call("乔布斯") 时，通过栈中的 p 找到堆中存在的方法区的内存地址，从而指引到方法区中的 Phone.class 中的方法。从而将 call 方法加载到栈内存中，注意：当执行完毕后，call 方法就从栈内存中消失！剩余的如上。
最后，main 方法消失！

两个对象的运行过程：

程序从 main() 方法进入，运行到 Phone p 时，栈内存中开内存空间；
new Phone() 时，在队中开了一个内存空间，内存值为 0x0001；此时会找到对应的 Phone 类，发现有三个变量，于是将三个成员变量放在了堆中，但是此时的值为默认值。又发现该类还存在方法，于是将该方法的内存值留在了堆中，在方法区里也有一个地址值，假设为 0x001，这个值与堆中的值相对应；
程序继续运行，到 p.brand 时，进行了负值，同上；
当程序运行到 Phone p2 时；到 new Phone() 时，在堆内存中开辟了内存空间 0x0002，赋值给 Phone p2；
剩下跟一个对象的内存相同。

当然我现在用到的是堆和栈，后面的都不太熟悉，先了解一下，学到了在学

搞了半天再来点干货

JRE：Java Runtime Environment
JRE顾名思道义是java运行时环境，包含了java虚拟机，java基础类库。是使用java语言编写的程序运行所需要的软件环境，内是提供给想运行java程序的用户使用的。

JDK：Java Development Kit
JDK顾名思义是java开发工具包，是程序员使用java语言编写java程序所需的开发工具包，是提供给程序员使用的。JDK包含了JRE，同时还包含了编译java源码的编译javac，还包含了很多java程序调试和分析的工具：容jconsole，jvisualvm等工具软件，还包含了java程序编写所需的文档和demo例子程序。
如果你需要运行java程序，只需安装JRE就可以了。如果你需要编写java程序，需要安装JDK。

再说说面向对象的概念

1、面向对象的概念
面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

提到面向对象，自然会想到面向过程，面向过程就是分析解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一个一个依次调用就可以了。面向对象则是把解决的问题按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。当然，一个应用程序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护。

最后写个杨辉三角结束吧

package com.company;

public class yanghui {
    public static void main(String[] args) {
        int[] a=new int[6];
        a[0]=1;
        for (int i = 0; i < 6; i++) {
            for (int j = i;j > 0; j--) {
                a[j]=a[j]+a[j-1];
            }
            for (int j = 0; j <= i; j++) {
                System.out.print(a[j]);
                System.out.print('\t');
            }
                System.out.println();
        }
    }
}

结果

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	

System.out.println 这个后边有个ln 是换行的意思
ok,下周继续