今天看完基础第四天的内容，明天就开始学习面向对象了，所以自己做个阶段小结。
第一天的开发前奏主要是说明
一.Java的说明：
     1.编程就是人机交互的过程；
     2.Java的特点：简单易学，完全面向对象（还没看到对象，所以这点只是知道，不了解），与平台无关（能够实现跨平台运行，是因为java不直接运行在任何底层平台上，而是运行在对应平台的jvm上）。
    3.jre:java运行环境，包括Java虚拟机和Java程序所需的核心类库。
      jdk：Java开发工具包，包含jre和开发工具（如编译工具javac.exe,打包工具jar,exe等）。
      jvm:Java虚拟机，Java语言的运行环境，Java虚拟机不跨平台。
      java程序运行机制： .java源文件—javac.exe编译—.class文件—java.exe（jvm先加载）—结果。
二.Java环境的搭建：环境变量path和classpath的配置。classpath优先走环境变量；path优先走当前，当前找不到才去走环境变量。
三.第一个程序hello world的写法，初次具体接触java语言。java语言严格区分大小写！
    class定义一个类，若源文件中包含了public类，则源文件必须和该public类同名。
    main代表主函数，是程序的入口，保证程序的独立运行，被jvm调用。    System.out.print()和System.out.println()都是打印到屏幕，前者不换行，后者自动换行。
四.代码注释：注释有3种，单行注释//  ；  多行注释/*  */  ;和java特有的文档注释/**  */用于生成文档。多行注释和文档注释都不能嵌套使用！

   

多长时间看到第四天的?我好长时间了，才看到第二天   总结的很不错

个人视频学习小结02
第二天就进入java编程基础了。一.标识符：为了增强阅读性而自定义的名称，如：类名，变量名，函数名等。命名规则：

       1. 由字母、数字、下划线、$组成，不能以数字开头。注意:字母还可以是中文,日文等。

       2. 大小写敏感。

       3. 不得使用java中的关键字和保留字。（红色和蓝色）

       4. 不能用Java API里面的类名作为自己的类名。（API类还未了解，只能先记住该规则）

二.常量和变量：

     1.变量   概念:占据着内存中的某一个存储区域,该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。

      定义变量是为了用来不断存放同一类型的常量，并重复利用。

      定义格式： 数据类型   变量名 = 初始值；作用范围：定义开始到定义它的代码块结束；同一范围内不允许存在同名的局部变量。

     个人理解：局部变量是定义在函数中的变量，没有默认初始化值，使用前必须赋初值，只在函数中有效；成员变量是定义在类中、函数外的变量，在整个类中生效，有默认初始化值。

     2.基本数据类型：8种，可分为4类。

       整数型： byte(字节型，1个字节)，short（短整型，2个字节），int（整型，4个字节），long（长整型，8个字节）；4者默认值均为0；一般默认选择int型。

       浮点型：float（单精度浮点，4个字节，默认值：0.0f），double（双精度浮点，8个字节,默认值：0.0）；一般选择默认double型。

      字符型： char(字符型，2个字节)；默认值:'\u0000'(表示空格)。

      布尔型： boolean（布尔型，1个字节）；默认值：false。

      类型转换：

      运算时小的类型会自动转大的类型（隐式转换）：byte,short,char → int → long → float → double

       byte，short，char之间不会相互转换，计算时首先会转换为int类型。boolean 不可以转换为其他基本数据类型。

       大的类型转小的类型需要进行强制转换（显式转换）。

三.运算符：算数运算符，赋值运算符，逻辑运算符，条件运算符，位运算符。

    逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

  “&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；双与时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

     |”和“||”的区别同理，双或时，左边为真，右边不参与运算。“ ^ ”与“|”不同之处是：当左右都为true时，"^"结果为false。

四.三目运算符：语法格式：x ? y : z;      其中x为boolean类型表达式，先计算x的值，若为true,则整个三目运算符的结果是表达式y的值，否则就是z的值。

海纳百川1123 发表于 2015-7-17 17:27
多长时间看到第四天的?我好长时间了，才看到第二天   总结的很不错

看了4天半，明天要开始看面向对象，所以今天下午把之前看的内容总结一下。

个人学习小结03
第三天学三大循环结构和嵌套
一.流程控制：顺序结构，条件结构（分支结构），循环结构，控制循环结构。
二.顺序结构：如果代码里没有流程控制，程序是至上而下一行一行执行的，一条语句执行完之后继续执行下一条语句，直到程序的最后。
三.条件结构：if语句和switch语句。
     1.if语句:基本语法:if(表达式){方法体}else if(表达式){方法体}else(方法体)

     三种格式：

     if(条件表达式){执行语句；}

     if(条件表达式){执行语句；}else{执行语句；}

     if(条件表达式){执行语句；}else if(条件表达式){执行语句；}……else{执行语句；}

     2.switvh语句：

       格式：

       switch(表达式){

                 case表达式可能的结果值1:

                             执行语句；

                              break;

                 case表达式可能的结果值2:

                             执行语句；

                              break；

                   ...

                  default:

                             执行语句；

                             break；//最后这个一般不写

             }

         注意：

                 (1)case之间与default没有顺序。先执行第一个case，都没有匹配的case值执行default。

                 (2)结束switch语句的两种情况：遇到break，switch语句执行结束。

                 (3)如果匹配的case或者default没有对应的break，那么程序会从第一次匹配的case语句开始继续向下执行，运行可以执行的语句，直到遇到break或者switch结束为止。

四.循环结构：用于处理需要重复执行的操作；根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落我们称为循环体；

        (1)3大循环结构：while,do-while,for。        

        while:事先不需要知道循环执行多少次；

        do while:同上，只是至少要执行一次(先做，后判断)；

        for:需要知道循环次数；

        (2)循环结构(while& do while)

        while语句

        格式：

        while(条件表达式值为true)

       {

                执行语句；

        }

        do while语句

        格式：

        do

        {

               执行语句；

         }

         while(条件表达式值为true);

         要点：do while特点是无论条件是否满足，循环体至少被执行一次。

                   循环里的条件表达式不能直接写false或直接写结果是false的表达式,不过可以使用变量来传递false值;

         (3)循环结构(for)

             格式：

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

             {

                    执行语句；（4）

              }

               执行顺序：(1) → (2) → (4) → (3) → (2) → (4) → (3)

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

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

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

五.嵌套循环：循环里套循环。外循环的循环次数是x次,内循环的循环次数是y次，那么内层循环的循环次数需要x * y次。

六.流程控制:break语句, continue语句；

                   break：终止该层循环；  continue：跳过该层循环

           要点：

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

           (2)这个两个语句后面都不能有语句，因为执行不到。

           (3)continue语句是跳过本次循环，继续下次循环。

           (4)标签的出现，可以让这两个语句作用于指定的循环。

学习小结04
一.方法(函数)：方法是一组为了实现特定功能的代码块的集合。
    1. 方法在语法上的功能主要有以下两个：

   (1)结构化代码:将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。
   (2)减少代码重复:一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。

    总结：方法就是一段可重复利用的代码段，是程序中可以完成独立功能的一段代码的集合。

    2.格式：

      [修饰符] 返回值类型 方法名([参数类型 形式参数1，参数类型 形式参数2，……])

       {      

                  执行语句;     [return 返回值;]//需要的话

       }

       要点： 参数列表（参数的类型 ，参数的个数，参数的顺序）中任何一个不一样即使同名也代表不同的方法。

      3.特点：它可以实现独立的功能;必须定义在类里面;它只有被调用才会执行;它可以被重复使用;方法结束后方法里的对象失去引用。

      4.写一个功能的方法的要点：明确该功能运算后结果，确定返回值类型；明确实现该功能时是否有未知内容参与运算，确定参数列表。

二.函数的重载：在同一个类中，允许存在一个以上的同名函数(方法)，只要它们的参数个数或者参数类型或参数顺序不同即可。

    存在的原因：屏蔽了一个对象的同一类方法由于参数不同所造成的差异。

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

不错，赞一下~

比较善于总结哦

个人学习小结05
一.数组：数组(Array)是Java语言中内置的一种基本数据存储结构。个人理解，数组就是一组数的集合，目的是用来一次存储多个数据。
    要点：(1)数组的好处：数组里的每个元素都有角标，角标从0开始，并且依次递增，方便操作这些元素；(2)使用Java数组：必须先声明数组，再给该数组分配内存；(3)数组对应在内存中一段连续空间;(4)数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。
二.一维数组:可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素.
    1.声明格式： 数组类型 []   数组名；或者   数组类型   数组名[];     
             注意：数组的长度一旦确定，就无法改变。声明数组时不能指定其长度；初始化时可以确定其长度。
    2.初始化：Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；

       数组初始化的两种方式：

              静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；

                       格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};

                 简化语法：数组名 = {元素1,元素2,元素3...元素n};

             动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；

                      格式：数组名 = new 数组类型[数组长度];

        注意：不能静态初始化和动态初始化同时使用。就是说不能同时指定数组的长度和元素。

    3.常见操作：这里只记录关键代码

       给数组元素赋值：   int[] arr =new int[3]; arr[0] = 1;

       访问数组元素：      int x = arr[0];

       获取数组长度 :        int l = arr[].length;

       遍历数组：       利用for循环遍历       for(int x=0;x<arr.length;x++)  arr[x]

       数组内查重：   for(int x=0;x<arr.length-1;x++)   for(int y=x+1;y<arr.length;y++)   if(arr[x] == arr[y])   

       数组内求最大值：int max = arr[0];   for(int x=0;x<arr.length;x++)   if(max < arr[x])   max = arr[x];  

       数组元素求和：  int sum = 0;  for(int x=0;x<arr.length;x++)   sum+=arr[x];  

       数组内排序：

          选择 for(int x=0;x<arr.length-1;x++)  for(int y=x+1;y<arr.length;y++)  if(arr[x]>arr[y])  int temp = arr[x];arr[x] = arr[y]; arr[y] = temp;

二x+          冒泡 for(int x=0;x<arr.length-1;x++)  for(int y = 0;y<arr.length-x-1;y++)  if(arr[y]>arr[y+1]) int temp = arr[y]; arr[y] = arr[y+1]; arr[y+1] = temp;                  数组内查找：
                 折半：int max,min,mid;min=0;  int key(key为需要查找的数);  max = arr.length;mid =(min+max)/2  while(max>min)  if(arr[mid]>key) max=mid-1;else if min =mid+1;  else return mid;  mid =(max+min)/2;   return -1;
              数组做容器，进制转换：  trans(int num,int base, int offse)   if(num ==0)  s.o.p(0); return;   char[] chs ={'0',...,'F'};  char[] arr = new char[32];  int pos =arr.length;  while(num !=0)  int temp = num &base; arr[--pos]=chs[temp]; num =num >>>offset;    for(int x=pos;x<arr.length;x++)  arr[x]
             二进制：trans(num,1,1) ；   八进制 ： trans(num,7,3);  十六进制 : trans(num,15,4);
  

          三.二维数组：看作是一个一维数组，一位数组中的每一个元素又是一个一维数组。可以看作一张表格。
          动态初始化：int[][] arr=new int[3][2]; 定义一个二维数组，二维数组中有3个一维数组，每个一维数组有2个元素。int[][] arr =new int[3][];必须有二维数组长度。此时一维数组初始化为null。
          静态初始化： int[][] arr={{1,2,3},{2,4,2},{3,5,3}};   int[][] arr =new int[][] {{1,2},{3,4}};
           注意：int[]  x;int x[]均是一维数组。int[][] y;int y[][]; int[] y[]均是二维数组。
           如： int[]  x,y[];    这里x是一维数组，y是二维数组。

明天开始学习面向对象，学完在来接着小结面向对象部分的。

应该是新开班的

厉害  这种帖可以加精了