前五天知识点总结

1、dos命令行，常用命令:

dir：列出当前目录下的文件及文件夹；

md:创建目录；

rd：删除目录；

cd：进入指定的目录；

cd.. :退回到上一级目录；

cd\:退回到根目录；

del：删除文件；

exit：退出dos命令行；

2、java语言概述

      (1)Java语言的发展史
          Java之父 -- 詹姆斯·高斯林（James Gosling）
     (2)Java语言的平台
          A:J2SE 基础版,桌面应用。
          B:J2ME 微型版,手机开发。(android,ios)
          C:J2EE 企业版,所有浏览器访问的应用程序。

          注意：JDK5以后改名
               JavaSE,JavaME,JavaEE

          J2SE是学习其他两门的基础。
     (3)Java语言的特点
          开源：源代码开放
          跨平台：在任意操作系统下都可以使用。
     (4)跨平台(理解)
         java语言跨平台是依托于在不同平台上运行jvm的不同。

          注意：java语言是跨平台的，jvm不是跨平台的。
     (5)JRE、JDK和JVM之间的关系
          JRE包括jvm和java核心类库，是java运行环境。
          JDK包括JRE 和 tools（java 开发工具包）

          JDK>JRE>JVM;

          一句话：有JDK开发的软件，必须在JRE上运行，并由JVM保证跨平台。

        (6)第一个代码：
               class Demo
               {
                    public static void main(String[] args)
                    {
                         System.out.println("Hello World");
                    }
               }

          解释：
               A:java语言的最基本单位是类。用class表示
                    定义类的格式：
                         class 类名
               B:程序如果要运行，就必须有main方法，是程序的入口，它是被jvm调用。
                    格式：
                         public static void main(String[] args)
               C:程序如果要输出一些内容，就必须使用输出语句。
                    格式：
                         System.out.println("Hello World");
     (7)java常用的两个命令：
          A:开发源程序(.java文件)
               Demo.java
          B:通过javac命令编译(.class)  javac命令
               javac Demo.java
          C:通过java命令执行   java命令
               java Demo
     (8)常见的错误及注意事项
          A:文件扩展名导致编译失败。把隐藏文件扩展名给显示出来。
          B:非法字符错误
               只要看到是非法字符，肯定是中英文问题。
               因为我们要求所有的符号全部是英文状态的。
          C:注意大小写问题
               class -- Class
               String -- string
               System -- system
          D:括号的对应问题
               在java程序中，括号都是成对出现的。
          E:main方法格式错误    
               public static void main(String [] args){ }
          F:当java源文件发生变化后，请重写编译在运行
          G:缩进问题
               写代码，遇到{}，请缩进一个tab位置。

     (9)：环境变量(理解)
     (1)path环境变量的作用
          让javac和java命令可以在任意的目录下使用。
     (2)path环境变量的配置(掌握)
          A:只修改path
               D:\develop\Java\jdk1.7.0_45\bin;以前的path
          B:先建立一个JAVA_HOME,后修改path
               新建：JAVA_HOME 值是 D:\develop\Java\jdk1.7.0_45
               修改：%JAVA_HOME%\bin;以前的path

          推荐使用B方案。
     (3)classpath环境变量的配置
          让指定的class文件在任意目录都可以被访问。

          技巧：在最左边配置一个.;
                这样做的好处就是能够先在当前目录下查找并执行。

3、java语言的基本组成

(1)关键字（小写的才是关键字）

class 用于表示这是一个类；

(2)标识符

1、26个英文字母大小写、数字0~9、符号_$组成；

2、数字不可以开头；

3、不可以使用关键字；

4、java中严格区分大小写；

5、命名规则

包名:一个或多个单词组成时，所有字母均小写；xxyyzz

类名：一个单词组成时，首字母大写，多个单词组成时，所有单词的首字母均大写；XxxYyyZzz

变量名和方法名：一个单词组成，字母均小写，多个单词组成，第一个单词首字母小写，其余单词首字母均大写；xxxYyyZzz

常量名：所有字母都要大写，多个单词组成，用下划线分割；XX_YY_ZZ

注意：java中goto和const作为保留字存在没有被使用。

(3)常量（不能变化的量）

1、整数常量：所有整数、小数及布尔常量；

2、字符常量：将字母、数字、符号用一个单引号括起来标识；

3、字符串常量：将一个或多个字符用双引号标识；

4、null常量

注意：计算机中的数值运算都是以补码的形式进行；

规则：1、反码、正数的反码和原码相同，负数的反码和原码不同，规则是负数除去符号位，其他的数取反；

          2、补码、正数的补码和原码相同，负数的补码和原码不同，规则是负数出去符号位，反码+1；

(4)常量：将不确定数据进行存储，也就是需要在内存中开辟一个空间。

格式：数据类型 变量名 = 初始化值;

变量定义规则：当数据不确定时，需要对数据进行存储，就定义一个变量来完成存储动作。java中不允许在一个类中重复定义同一个变量。

(5)数据类型

     (1)分类
          基本类型：4类8种。
          引用类型：类class，接口interface，数组arr[]。
     (2)基本类型
          整型：
               byte     1个字节
               short     2个字节 
               int     4个字节 
               long     8个字节 
          浮点型：
               float     4个字节 
               double     8个字节 
          字符型：
               char     2个字节 （一个汉字2个字节）
          布尔型：         
               boolean 不明确。可以认为是1个字节。
         
          注意：
               整数默认是int类型。long类型需要加L或者l后缀。
               浮点数默认是double类型。float类型需要加F或者f后缀。
     (3)类型转换
          1：boolean类型不参与转换。
          2：隐式转换(由低精度向高精度转换，系统自动执行。)

          byte,short,char -- int -- long -- float -- double
          3：强制转换(由高精度向低精度转换,易丢失精度。）
               格式：
                    (数据类型)数据;byte b=byte(3+8);

     (4)算术运算符
          +,-,*,/,%,++,--

          +：正号，加法，字符串连接符。
               System.out.println("5+5="+5+5);//5+5=55
               System.out.println(5+5+"=5+5");//10=5+5

          %：取得余数
               左边如果大于右边，结果是余数。
               左边如果小于右边，结果是左边。
               左边如果等于右边，结果是0。

               正负号跟左边一致。

          ++/--：
               ++ 其实相当于把数据+1

               单独使用：
                    在数据的前后，结果一致。
         
               参与操作使用：
                    如果在数据的后边，数据先操作，在++/--
                    如果在数据的前边，数据先++/--，在操作。
     (4)赋值运算符
          =,+=,-=,*=,/=,%=

          int a = 10;
               把10赋值给int类型的变量a。

          a += 20;
               把左边和右边的和赋值给左边。

          注意事项：
               a = a + 20;
               a += 20;
               结果是等价的，理解不是等价的。

               因为+=这种运算符，内含了强制类型转换功能。
               比如：
                    short s = 2;
                    s+=3;
                    等价于
                    s = (short)
     (5)关系运算符
          ==,!=,>,>=,<,<=

          特点：关系运算符的结果都是boolean类型。
                请千万注意：== 不要写成 =
     (6)逻辑运算符
          &,|,!,^,&&,||
         
          &:有false则false
          |:有true则true
          !:true变false,false变true
          ^:相同false,不同true

          &&:有false则false
          ||:有true则true

          &&和&的区别是：如果左边有false了，右边将不再执行。
          ||和|的区别是：如果左边有true了，右边将不再执行。

          开发中常用：
               &&,||,!(s+3);

     (7)位运算符

     &按位与、|按位或、~按位取反、^按位取异或、<<左移、>>右移、>>>无符号右移；

     &：将参与运算的两个二进制数进行与运算，如果两个二进制位都为1，则位的运算结果为1，否则为0；

     |：将参与运算的两个二进制数进行或运算，如果两个二进制位有一个为1，则位的运算结果为1，否则为0；

     ~：只针对一个操作数的运算，如果二进制位是1，则取反的结果为0；如果二进制位是0，则取反的结果为1；

     ^:将参与运算的两个二进制数进行异或运算，如果两个二进制位相同，则异或的运算结果为0，否则为1；

     <<:将操作数所有的二进制位向左移动一位，运算时，右边的空位补0，左边移走的部分舍去；

     >>:将操作数所有的二进制位向右移动一位，运算时，左边的空位根据原数的符号位补0或者补1（原来是负数就补1，正数补0）；

     >>>:将操作数所有的二进制位向右移动一位，运算时，左边的空位补0（不考虑原数的正负）；

     注：将一个数^同一个数两次，等于这个数本身。

          n=n^m;

          m=n^m;//n^m^m=n

          n=n^m;//n^m^n=m

     (8)三元运算符

     格式：条件表达式？值1：值2；

     解释：如果条件表达式为真，则执行值1，否则执行值2.

     (9)转义字符    

     \n:换行；\t：制表符；\r回车键；\b：退格；

     (10)运算符优先级

     

优先级

描述

运算符

1

括号

() 、[]

2

正负号

+ 、-

3

自增自减，非

++ 、-- 、 !

4

乘除，取余

* 、/ 、 %

5

加减

+ 、-

6

移位运算

<< 、>> 、 >>>

7

大小关系

> 、>= 、 <、 <=

8

相等关系

== 、!=

9

按位与

&

10

按位异或

^

11

按位或

|

12

逻辑与

&&

13

逻辑或

||

14

条件运算

?:

15

赋值运算

= 、+= 、 -=、 *= 、/= 、 %=

16

位赋值运算

&= 、|= 、 <<=、 >>= 、>>>=

注： 如果想要改变运算顺序，可以使用（）来完成；

4、程序流程控制

1、判断语句

 if语句
     (1)用于做判断使用的。
        常见于对某个范围进行判断，或者几个变量进行判断，还有就是boolean表达式的判断。
     (2)格式：
     A:第一种格式
          if(条件表达式)
          {
               语句体;
          }

          执行流程：
               如果条件表达式为true，就执行语句体；
               否则，什么都不执行。

    B:第二种格式

     if(条件表达式)

     {

          语句体1;

     }

     else

     {

          语句体2;

     }

     执行流程：
          如果条件表达式为true，就执行语句体1；
          否则，就执行语句体2；

     特殊：
          可以和条件表达式在某些情况下进行替换。
          一般是在赋值的情况下可以。

     举例：
          获取两个数中的最大值。

C:第三种格式

     if(条件表达式1)

     {

          语句体1;

     }

     else if(条件表达式2)

     {

          语句体2;

     }

     ...

     else

     {

          语句体n;

     }    

     执行流程：

          如果条件表达式1为true，就执行语句体1；

          否则如果条件表达式2为true，就执行语句体2；

          ...

          否则，就执行语句体n；

         

    D:注意事项
     a:什么时候时候用哪一种if语句。
          第一种格式在判断条件为一种情况下使用。
          第二种格式在判断条件为两种情况下使用。
          第三种格式在判断条件为多种情况下使用。
     b:每一种if语句其实都是一个整体，如果有地方执行了，
       其他的就不执行了。
     c:如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，
       但是，如果是控制多条语句，就必须写上大括号。
       建议：永远写上大括号。
     d:大括号和分号一般不同时出现。

  E:作用域
     所有变量的定义只在它所属的大括号内有效。
2、选择语句
switch语句
(1)用于做选择使用的。一般用于几个常量的判断。
     switch会把几个常量值直接加载到内存，在判断的时候，效率要比if高。
     所以，针对几个常量的判断，一般选择switch语句。
(2)switch语句的格式：
     switch(表达式)
     {
          case 值1:
               语句体1;
               break;
          case 值2:
               语句体2;
               break;
          case 值3:
               语句体3;
               break;
          ...
          default:
               语句体n;
               break;    
     }

          A:针对格式的解释
               switch:表示这里使用的是switch语句，后面跟的是选项。
                    表达式：byte,short,int,char
                            JDK5以后可以是枚举
                         JDK7以后可以是字符串
               case:表示这里就是选项的值，它后面的值将来和表达式的值进行匹配。
                    case后面的值是不能够重复的。
               break:
                    switch语句执行到这里，就结束了。
               default:
                    当所有的case和表达式都不匹配的时候，就走default的内容。
                    它相当于if语句的else。一般不建议省略。
          B:执行流程
               进入switch语句后，就会根据表达式的值去找对应的case值。
               如果最终没有找到，那么，就执行default的内容。
         
          C:注意事项：
               a:default整体可以省略吗?
                    可以，但是不建议。
               b:default的位置可以放到前面吗?
                    可以，但是不建议。
               c:break可以省略吗?
                    可以，但是不建议。
                    default在最后，break是可以省略的。
                    case后面的break可以省略，但是结果可能有问题。
               d:switch语句什么时候结束呢?
                    就是遇到break或者执行到程序的末尾。

增加：Scanner的使用
     (1)Scanner是JDK5以后设计的用来接收键盘录入数据使用的。
     (2)目前我们要通过键盘录入int类型数据,必须按照如下步骤：
          A:导包
               import java.util.Scanner;
          B:创建对象,封装键盘录入
               Scanner sc = new Scanner(System.in);
          C:调用方法,获取数据
               int number = sc.nextInt();

3、循环结构

A:while 格式：
               初始化条件;
               while(判断条件)
               {
                    循环体;
                    控制条件;
               }
              
               执行流程：
                    a:先执行初始化条件;
                    b:执行判断条件
                    c:根据判断条件的返回值：
                         true:执行循环体。
                         false:就结束循环。
                    d:最后执行控制条件。返回到b继续。

B:do...while格式：
               初始化条件;
               do{
                    循环体;
                    控制条件;
               }while(判断条件);

               执行流程：
                    a:先执行初始化条件;
                    b:执行循环体和控制条件;
                    c:执行判断条件
                    d:根据返回值
                         true:返回b。
                         false:就结束循环。

C：for格式：
               for(初始化条件;判断条件;控制条件)
               {
                    循环体;
               }

               执行流程：
                    a:先执行初始化条件;
                    b:执行判断条件
                    c:根据判断条件的返回值：
                         true:执行循环体。
                         false:就结束循环。
                    d:最后执行控制条件。返回到b继续。

          注意：
               a:一般使用for循环或者while循环。而且这两种循环是可以等价转换的。
               b:do...while循环至少执行一次循环体。

 D循环嵌套：
          A:也就是循环语句的循环体是一个循环语句。
          B:外循环控制行数，内循环控制列数。
          C:正三角形
               内循环的判断条件：y<=x

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

          E:倒三角形
               内循环的初始化条件：y=x

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

          F：9*9乘法表

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();

   }

G:水仙花数

请输出满足这样条件的五位数。
          个位=万位
          十位=千位
          个位+十位+千位+万位=百位

          思路：
               1.定义一个要操作的五位数变量num
               2.求出每一位个系数
                    个：num%10
                    十：num/10%10
                    百：num/100%10
                    千：num/1000%10
                    万：num/10000%10
               3.根据题意确定范围10000-99999，变化规律是+1
               4.判断是否符合题意中的要求，符合的话输出num
          代码：
              
               for(int num = 10000; num <100000;num++)
               {
                    int ge = num%10;
                    int shi = num/10%10;
                    int bai = num/100%10;
                    int qian = num/1000%10;
                    int wan = num/10000%10;

                    if(ge == wan && shi == qian && (shi+ge+qian+wan) == bai)
                    {
                         System.out.println(num);
                    }
               }

         

G：break和continue关键字
     (1)有些时候，我们需要对循环进行一些控制终止,这个时候，就出现了两个关键字：
          break和continue
     (2)特点：
          A:它们都必须在循环中(break还可以在switch中。)。
            一般在循环的判断中。
          B:如果单独使用break和continue，后面是不能有语句的。
     (3)区别：
          A:break 结束当前循环。
          B:continue 结束本次循环，进入下一次循环。
     (4)如何退出嵌套循环：(了解)
          用带标签的循环。
          格式:
               标签名：for(){
                         for(){
                              if()
                              {
                                   break 标签名;
                              }
                         }
                    }

H:应用场景
     (1)当要对某些语句执行很多次时，就使用循环语句；特别要明确那些语句要参与循环，那些不要参与；

5、函数

1、函数的定义：定义在类中具有特殊功能的一段独立小程序。函数也成为方法。

2、函数的格式：

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

{

     执行语句；

     return 返回值；

}

解释：

          A:修饰符     public static
          B:返回值类型     程序最终结果的数据类型
          C:函数名     其实就是函数的名称
          D:参数          参数类型     数据类型
                             形式参数     就是接收实际参数的变量 
          E:执行语句     就是按照正常的逻辑完成功能的代码。
          F:返回值     就是程序的最终结果
          G:reutrn 返回值     哪里调用程序，return就把结果返回到哪里。
     (3)函数的特点：
          A:函数与函数之间是平级关系。不能在函数中定义函数，只能在函数内调用函数。
          B:运行特点     函数只有被调用才执行。

          C:当函数运算后没有具体返回值时，这时返回值用特殊的关键字void来表示。

          D:当函数的返回值为void时，函数中的return语句可以不写，系统会自动加载。

     
     (4)函数的定义和调用
          1、定义函数:有明确返回值类型和是否需要定义未知的参数

           2、函数调用

               a:单独调用     一般没有意义。
               b:输出调用     但是如果想拿结果继续操作，就有问题了。所以，不好。
               c:赋值调用     推荐方式。
     (5)函数重载

           定义：在同一个类中，允许存在一个以上的同名函数，只要他们的参数列表不同（参数类型或参数个数有区别）。

           什么时候使用函数重载？

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

   注：函数名相同,参数列表不同(个数不同,对应的类型不同)， 与返回值类型无关。  
  举例：
               public static int sum(int a,int b){...}
               public static int sum(int a,int b,int c){...}
               public static int sum(float a,float b){...}

6、数组

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

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

3、格式：

          A:int[] arr = new int[3];
          B:int arr[] = new int[3];
          C:int[] arr = new int[]{1,2,3};
          D:int[] arr = {1,2,3};

 4、Java内存图：
          A:栈     存储局部变量使用。  使用完毕，立马消失。 
          B:堆     所有new出来的都在堆里面。
               a:每一个实体都有地址值
               b:每一个实体内的内容都有默认值
                整数：0； 浮点数：0.0；字符：'\u0000'；布尔：false
               c:在垃圾回收器空闲的时候被回收。
          C:方法区
          D:本地方法区
          E:寄存器
     (5)操作：

//1，获取数组中的最大值，以及最小值。
public static int  GetMax(int[] arr)
{
     int max=arr[0];
     for (int x=1;x<arr.length ;x++ )
     {
          if (max<arr[x])
          {
               max=arr[x];
          }
     }
     return max;
}
public static int GetMin(int[] arr)
{
     int min=arr[0];
     for (int x=1;x<arr.length ;x++ )
     {
          if (min>arr[x])
          {
               min=arr[x];
          }
     }
     return min;
}
//2,对给定数组进行排序(选择排序)。
public static void selectSort(int[] arr)
{
     for (int x=0;x<arr.length-1 ;x++ )//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;
               }
          }
     }
}
//3(冒泡排序)
public static void bubbleSort(int[] arr)
{
     for (int x=0;x<arr.length-1; x++)//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;
               }
          }
     }
}
//4打印数组
public static void printArray(int[] arr)
{
     System.out.print("[");
     for (int x=0; x<arr.length;x++ )
     {
          if (x!=arr.length-1)
          {
               System.out.print(arr[x]);
          }
          else
          {
               System.out.print(arr[x]+"]");
          }
     }
}
//5反转数组
public static void reverseArray(int [] arr)
{
     for(int start=0,end=arr.length-1; start<end ; start++,end--)//定义变量控制首尾位置
          {
               int temp = arr[start];//交换位置
               arr[start] = arr[end];
               arr[end] = temp;
          }
}
//6数组查找，折半查找，必须要保证该数组是有序的数组。
public static int halfSerach(int[] arr,int key)
{
     int min=0;
     int max=arr.length-1;
     int mid=(min+max)/2;
     while (arr[mid]!=arr[key])
     {
          if (arr[key]>arr[mid])//判断key与数组中间元素值的大小，然后改变相应的min和max；
          {
               min=mid+1;
          }
          else if (arr[key]<arr[mid])
          {
               max=mid-1;
          }
          if (min>max)//判断出现min大于max则数组中key不存在；
          {
               return -1;
          }
          mid=(min+max)/2;//每循环一次，改变mid的值
     }
     return mid;
}
//7进制转换
class HexConversion
{

     //十进制-->二进制
    
     public static void toBin(int num)
     {
          trans(num,1,1);
     }

    
     //十进制-->八进制
    
     public static void toBa(int num)
     {
          trans(num,7,3);
     }
    
     //十进制-->十六进制
     public static void toHex(int num)
     {
          trans(num,15,4);
     }

     public static void trans(int num,int base,int offset)
     {
     if (num==0)//0不需要转换
     {
          System.out.println(0);
     }
     char[] chs = {'0','1','2','3',
                      '4','5','6','7',
                      '8','9','A','B',
                      'C','D','E','F'};//设置数组
     char[] arr = new char[32];//定义一个容器，用于接收&运算后的值，所对应的chs数组中的元素。

          int pos = arr.length;

          while(num!=0)
          {
               int temp = num & base;//获取二进制最后的base位数值
               arr[--pos] = chs[temp];
               num = num >>> offset;//获取所有二进制位的所有值。
          }

          for(int x=pos; x<arr.length; x++)
          {
               System.out.print(arr[x]);//将arr[]数组打印
          }

          return ;
     }
}



         
     (6)二维数组：
          格式：
               A:int[][] arr = new int[3][2];
               B:int[][] arr = new int[3][];
               C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

     注：int[]x,y[]<=>int[]x,int[]y[];

    二维数组的遍历：

int [][]arr = {{2,3,6},{4,5,8},{2,4,8,9}};

for(int x=0;x<arr.length;x++)

{

     for(int y=0;y<arr[x].length;y++)

     {

          System.out.print(arr[x][y]+"\t");

     }

     System.out.println();

}