黑马程序员--基本概念以及基础知识篇

基本概念部分

-----------------------------------------------------------------------------------------------------------------------------

基本常识：

    软件开发：

什么是软件：就是一系列按照特定顺训组织的计算机数据和指令的集合！

      常见的软件：

          系统软件：DOS,windows,Linux等。

          应用软件：扫雷，迅雷，QQ等。

      什么是开发：开发就是制作软件。

   人机交互：

      图形化界面交互

      命令行方式交互

   常用的DOS命令：

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

      md: 创建目录；

      rd: 删除目录；

      cd: 进入目录；

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

      cd/: 退回到根目录；

      del: 删除文件；

      exit： 退出DOS命令行；

      echo： 创建文件。

 

 --------------------------------------------------------------

 Java语言概述：

java语言是SUN(Stanford UniversityNetwork)斯坦福大学网络公司于1995年推出的一门高级编程语言；

是一门面向internet的编程语言；

随着java技术在Web方面的不断成熟，已成为Web应用程序的首选开发语言；

是一门简单易学，完全面向对象，安全可靠，与平台无关的编程语言。

Java语言的三种技术架构：

     J2EE(Java 2 Platform Enterprise Edition):企业版

     J2SE(Java 2 Platform Standard Edition):标准版

J2ME(Java 2 Platform MicroEdition):小型版

     java5.0版本以后他们依次被更名为：JAVAEE,JAVASE,JAVAME

java的跨平台性：

   定义：通过java语言编写的应用程序在不同的操作系统平台上都可以运行。

  原理：只要在运行java应用程序的操作系统上先安装一个java虚拟机

          (JVM:Java Virtual Machine)然后由JVM来负责java程序在该系统中的运行！-----在这里这个虚拟机就相当于一个翻译，

  当一个java应用程序想要在windows操作系统中运行是，必须找一个会windows语言JVM来做翻译.

--------------------------------------------------------------

Java语言环境的搭建：

JRE(JavaRuntime Environment):

java运行环境它包括java虚拟机和java程序所需的核心类库等！如果想要运行一个开发好的java程序，那么计算机中必须安装JRE.

JDK(JavaDevelopment Kit):

java开发工具包JDK是提供给java开发工作人员使用的，其中包含了java的开发工具，也包括了JRE，所以安装了JDK,就不需要再安装JRE了！

   简而言之：JDK开发好的java程序，交给JRE去运行！

   就他们的范围而言：JDK > JRE > JVM.

 

运行环境路径的配置：

 (一劳永逸的配置方式) 

      因为javac.exe和java.exe等开发工具几乎每次开发时都会用到，然后每次都在DOS命令行中输入cd....等一大串的命令进入到开发工具包中去找

javac.exe这些开发工具太麻烦，于是乎，一种一劳永逸的方式产生了----在系统中配置Path路径！

     其大致步骤如下：计算机--->属性--->系统设置--->高级--->环境变量--->系统变量--->找到Path这个系统变量--->将JDK的bin目录复制到Path的变量值中，

    并用分号将新的变量值和原有的变量值分割开！--->确定

   这样就已经将运行环境路径配置好了！以后就可以在任意目录下启动bin目录下的卡发工具了！

   注意：如果在配置运行环境路径之前已经开启有DOS命令行了，那么这个DOS命令行还无法从Path中去找到这个路径，只有在创建运行路径之后的Dos

       命令行才可以找到path中配置好的路径！

 (环境变量配置技巧)

         从上面我们知道了如何配置运行环境路径，其中最关键的一步就是将JDK的bin目录复制到Path的变量值中，但是如果我们将JDK从D盘移动到了E盘；

此时运行环境路径就无用了，因为通过path路径将无法找到开发工具包，这时侯我们需要将新的路径重新配置进去，但是path中的内容很多，稍微不注意就

有可能将其他程序配置的路径弄错，为了避免这个问题，我们可以这样做：

   在系统变量中新建JAVA_HOME = E:\Jdk.1.7;

   在path中这样配置：path = %JAVA_HOME%\bin;这样一来就只用在JAVA_HOME中改变路径即可！      

 (临时配置环境变量)

   如果我们用的是别人的电脑来开发java程序，而我们又不能随意更改人家机器里面的path路径，这是我们还可以用临时配置的方式来配置path！

   步骤如下：打开DOS命令行--->set path = d:\Jdk.1.6\bin 就OK啦！

   如果我们还想保留原有的path路径，可以通过动态获取已有环境变量值来完成：set path = d:\Jdk.1.6\bin;%path%

      注意：通过DOS命令行配置的临时环境变量只在当前窗口以及当前窗口通过start命令新开的DOS窗口有效！

--------------------------------------------------------------

ClassPath的配置：

   它的作用是可以方便我们在任意目录下快速找到.java文件和.class文件

   操作如下：

    (方式一)打开DOS命令行--->set classpath =  d:\java0818\day01; 

    (方式二)打开DOS命令行--->set classpath =  d:\java0818\day01

   这两种方式的区别在于：

方式一中DOS命令行会先在classpath路径中先找一次，然后再到当前路径中再找一次；

而方式二只会找classpath而不会再到当前目录下再找一次！

此外还有多路径的配置：set classpath = .;c:\;d:\;e:\     (.代表当前路径，多个路径之间用分号隔开，)

当然，对于classpath我们也可以到系统的环境变量中去配置，但是由于.java文件和.class文件存储路径通常不确定，所以通常我们并不这样做！         

             对于path，DOS命令行是先找当前目录，没有找到才去path路径中去找；

             而classpath，DOS命令行是先找classpath，如果没有找到才找当前路径！

 -----------------------------------------------------------

注释通常可以分为以下三种：

   单行注释：格式为：//一行注释内容  

它可以用来对某行代码进行解释，说明其作用，以防便于别人阅读

   多行注释：格式为： /*多行注释内容*/  

当注释内容在一行中写不下时可以使用多行注释；同时多行只是可以帮助我们检验代码中出现的错误！

   文档注释：格式为： /** 文档注释内容 */                       

它可以将注释的内容出现在java的doc帮助文档中！

            

      注意：在使用多行注释和文档注释时，不可以在其中嵌套多行注释。

基础知识部分

---------------------------------------------------------------------------------------------------------------------------------------

标识符的概念：

Java语言中，对于变量，常量，函数，语句等都有名字，这些名字统称之为标识符.它是用来给

类、对象、方法、变量、接口和自定义数据类型命名的。

标识符的组成：Java标识符由数字（0-9），字母(a-z)，下划线（_）和美元符号（$）组成。

Java中命名规则：(1) Java 中关键字不能当作Java标识符的；

                                (2)不能用数字开头。

Java中的名称规范：

（1）包名：有多个单词组成时，所有单词均小写：xxxyyyzzz

（2）类名或接口名：由多个单词组成时，所有单词的首字母均大写：XxxYyyZzz

（3）变量名和函数名：由多个单词组成时，从第二个单词开始首字母大写：xxxYyyZzz

（4）常量名：所有字母均大写，单词之间以下划线连接XXX_YYY_ZZZ

---------------------------------------------------------------------------------------------------------------------

常量和变量

常量：不能改变的数值；

Java中常量的分类：

1.      整数常量：所有整数

2.      小数常量：所有小数

3.      布尔型常量：只有两个值true和false

4.      字符型常量：存在许多字符的串并被双引号所扩起，如“abcdefg”

5.      字符常量：将一个字母，数字，符号用一对单引号所扩起的整体，如：‘a’

6.      null常量：只有一个数值，那就是null

对于java中的整数有三种表现形式：

       十进制：0-9，满十进一；

       八进制：0-7，满八进一；

       十六进制：0-9外加A-F，满十六进一；

       八个二进制位是一个字节！

--------------------------------------------------------------------------------------------------------------------

进制转换：见下图

从上图可以看出十进制，八进制以及十六进制之间的转换都需要通过二进制来中转！

-------------------------------------------------------------------------------------------------------------------

负数的二进制表现形式：

一个负数的二进制其实就是这个数的相反数的二进制取反再加1；

所以如果我们要想知道-6的二进制是多少，首先需要知道6的二进制

（通常6在计算机中被当作int 类型的，所以它占32个二进制位）

6的二进制：0000 -0000   0000 -0000  0000 -0000   0000-0110

取反：   1111-1111    1111-1111   1111-1111   1111-1001

再加1：  1111-1111   1111-1111    1111-1111  1111-1010   <--------- -6的二进制

--------------------------------------------------------------------------------------------------------------------

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

通过明确数据类型，变量名称和数据来完成将变量存储在内存空间中。

Java是一种强类型语言，对于每一种数据都明确了具体的数据类型，在内存中分配了不同大小的内存空间。

Java中数据类型分为两大类：基本数据类型和引用数据类型。

其中基本数据类型分为以下八类：

                            |------byte  (在内存中占1个字节)  -----| 

                            |------short (在内存中占2个字节)  -----|     

                            |------int   (在内存中占4个字节)   -----|------整数类型

                            |------long  (在内存中占8个字节)  ----|

基本数据类型---|------float (在内存中占4个字节)   -----|                 

                            |------double (在内存中占8个字节)  -----|-----浮点类型

                            |------char  (在内存中占2个字节)  ------|-----字符型                

                            |------boolean ：仅仅只有true和false两个值------|-----布尔型

申明：在java中整数默认类型是int，而小数默认的类型是double；

定义变量的格式：  数据类型   变量名称 =  初始化值；

初始化值需要和数据类型相匹配，比如float  f = 2.3;是错误的，

        因为系统对于小数默认数据类型是double，所以2.3是double类型的，他和float类型不匹配，所以编译器会报错；

应该改为：float f = 2.3f；

----------------------------------------------------------------------------------------------------------------------

类型转换和自动类型提升：

eg:  byte  b = 3;

        b= b+2;     //类型由byte提升成为int

        System.out.println(b); //编译器将会报错

这是因为2是整数，系统默认其数据类型是int，所以他在内存中占四个字节，而b是byte类型，他在内存中占一个字节，

他们之间进行运算后的结果也将变成int，在内存中占4个字节；此时用byte类型装不下这个结果，所以编译器会报错！

对于这种情况可以这样做：

byte  b = 3;

b = （byte）(b+2);   //将运算后的占四个字节的结果强转为占一个字节的byte类型！

System.out.println(b);

 

除了上面通过运算符让类型提升的情况，还有一种自动类型提升的情况：

System.out.println(‘a’);  输出结果是：97

原因如下：‘a’的数据类型是char类型，他在内存中占2个字节，系统默认其数据类型是int，于是‘a’由字符类型被自动提升

为了int类型，而‘a’在ASCII码中对应的就是97！

----------------------------------------------------------------------------------------------------------------------

运算符：

Java中的运算符可以分为以下几大类：

算术运算符：(+ :加法)   ( - ：减法)   ( * ：乘法)   ( / ：除法)   ( % ：取余数运算 ) 

                     除此之外还有自加自减运算符：

                     ++a：a先自加1后再赋值      a++：a先赋值后再自加1

                     - -a ：a先自减1后再赋值      - -a ：a先赋值后再自减1 

赋值运算符：= ： int x = 3   //把3付给x

+=： int x += 3  //把左右两边的和赋给左边，可以理解为int  x =x+3;

-= ： int x -= 3   //把左减去右边的差赋给左边，可以理解为int  x = x-3;

*= ：int x += 3   //把左右两边的乘积赋给左边，可以理解为int  x = x*3;

/=  ：intx += 3   //把左除以右边的商赋给左边，可以理解为int  x = x/3;

%= ：int x += 3   //把左除以右边的余数赋给左边，可以理解为int  x = x%3;

比较运算符：==(等于)  !=(不等于)  <（小于） >大于  <= 小于等于） >= （大于等于）

instanceof（用于检查对象是否是特定类的一个实例对象）

逻辑运算符：&：与-----参与逻辑运算的表达式全部为真，结果才是真；

                     |： 或-----参与逻辑运算的表达式有一个为真，结果便是真；

                     ^：异或----两边相同结果为false，两边不同结果为true；

                     !：非-------颠倒黑白的专家，将真变成假，将假变成真；

                     &&：与（短路）---当&&左边为false时右边就不运算了，效率比&高；

                     ||：非（短路）------当||左边为true时，右边就不运算了，效率比|高。

位运算符：

首先我们要明确：位运算是以二进制位为单位进行的运算，其操作数和运算结果是整型值。那么对应的位运算符就是

对内存中的二进制数据进行运算的符号。Char、byte、short类型，在进行移位之前，都将被转换成int类型，移位后的

结果也是int类型；在java中位运算符共有7个，分别是：

与（&）：                    或（|）：                      异或（^）：

反码（~）：就是对应的二进制数取反，即二进制数中0变成1，1变成0；

右移（>>）：其实就是除以2的移动位数次幂，然后再取整；右移后高位由原来高位的数字补齐！

左移（<<）：其实就是乘以2的移动位数次幂；左移后低位用0补齐！

无符号右移（>>>）：二进制数字向右移动，同时高位统一用0来补齐！

三元运算符：

格式为：（条件表达式）？表达式1：表达式2；

如果条件表达式结果为true，那么运算后的结果为表达式1；否则为表达式2；

我们知道三元运算符运算以后必须有一个结果，而这个结果通常是用一个变量来记录的，那么这个变量就有一个类型，

而这个类型到底是什么类型呢?这是通过表达式1和表达式2综合来决定的；

a、如果表达式一的类型和表达式二的类型相同，那么毫无疑问，整个结果也是这个类型；

b、如果高级类型(比如int)可以转成低级类型(char)，那么当结果的类型为是低级类型那个表达式的类型时，

      整体的类型可以是低级类型；

c、如果高级类型不可以转变成低级类型，那么即使结果是低级类型那个表达式，结果数据的类型也要提升为高级类型；

----------------------------------------------------------------------------------------------------------------------

程序流程控制---语句：

语句结构可以分为：

a.       顺序结构；java语言默认的代码执行顺序。

b.       判断结构：有三种形式：

形式一：if（控制条件）｛

执行语句；

｝

 

形式二：if(控制条件1){

执行语句1；

}else{

执行语句2；

}

形式三：if(控制条件2){

                     执行语句1

}else if(控制条件){

执行语句1；

}……（若干个elseif()语句）

else if(控制条件n)｛

执行语句n；

｝else{

执行语句n+1；

}

c.       选择结构：switch语句   格式如下：

switch(表达式){

       case 取值1：       //case的顺序可以改变；

       执行语句；         //结束的方式有两种：一是break处结束；

      break；             //二是：switch语句包含的大括号处结束；

       case 取值2：

       执行语句；        

       break；

               .

                 .

       default:           //如果匹配的case或者default处没有break语句

       执行语句；        //那么，程序会继续向下执行，直至其他break

       break;             //或者switch语句的结尾才结束！

}

  在switch语句的表达式中最初只接受byte，short ,int和 char这四个基本数据类型；而在java5.0中又添加了枚举，

在java7.0中又添加了字符串；所以只有六种类型！

d.       循环结构：循环结构有三种常见的形式：

形式一：while（条件表达式）｛执行语句；｝

形式二：do{执行语句；}while(条件表达式)；  

// do while 语句中无论条件表达式是否为true，

//do后面的大括号中的执行语句都会执行！

       形式三：for(初始化表达式；循环条件表达式；虚幻后的操作表达式){

                           执行语句；

}

         可以通过双重for循环在控制台上打印出九九乘法表，矩阵等效果！外层for循环控制行数，内层for循环控制列数，

以及每列的具体效果。对于九九乘法表这样的输出效果有这样一个不是规律的规律：

尖朝上，可以通过改变内层循环的控制条件，让条件随着外层循环变化！

尖朝下，可以通过改变内层循环的初始化值，让初始化值随着外层循环变化！

e.       其他流程控制语句：

        break(跳出当前循环)：用于选择和循环结构；

         continue(结束本次循环，继续下次循环)：用于循环结构；

注意：1.这两个语句离开了作用范围，它的饿存在是没有意义的；

         2.这两个语句单独存在时下面是不可以有语句的，因为执行不到；

         3.continue可以结束本次循环，继续下一次循环的；

         4.当没有标号时，这两个语句作用的范围是当前循环或者选择结构的范围；

        而当有标号时这两个语句作用于标号的管辖范围！

       eg：       w:  for(int x=0; x<3; x++)

              {

                     q：for(inty=0; y<4; y++)

                     {

                            System.out.println("x="+x);

                            break w;     //在这里的w和q就是标号！

                     }                         

              }

  标号只能取在循环上，给循环起名字，只要这个名字符合标识符的定义规则就可以！

----------------------------------------------------------------------------------------------------------------------------------------

函数：

定义：就是定义在类中的具有特定功能的一段独立小程序！

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

                     执行语句；

               return 返回值；

｝

              返回值类型：函数运行后的结果的类型；

参数类型：形式参数的数据类型；

形式参数:是一个变量，用于存储调用函数时传递给函数的诗句参数；

实际参数： 传递给形式参数的具体数值；

return： 将返回值返还给调用者；

 函数的特点：

a.       定义函数可以将功能代码进行封装；

b.       便于对该功能进行复用；

c.       只用被调用时才会执行；

d.       它的出现提高了代码的复用性；

e.       对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么如果return语句在代码的最后一行，

 return可以省略不写！

注意：函数内部可以调用函数，但是不可以定义函数！

定义一个函数的步骤：

1，明确函数的返回值类型。

2，明确函数的参数列表（参数的类型和参数的个数）。

函数的重载（overloaded）：

              定义：在同一各类中，允许此乃在一个以上的同名函数，只要其参数列表不同便可！

       特点：函数的重载与函数的返回值类型无关！

----------------------------------------------------------------------------------------------------------------------------------------------------

数组---一个容器

       定义：同一类型数据的集合。

       优点：可以给数组中的元素从0开始编号，方便通过角标（index）来操作这些元素。

       格式：元素类型[]数组名称 = new  元素类型[ 元素个数或者数组长度 ]；

          eg:  int[ ] x = new int[3];  //定义了一个可以存放三个整数的容器。

对于创建的这个int类型的数组，他在内存中有以下三个特点：

a.   这个数组在堆内存占据了一定空间，这个空间有一个地址名称，即内存地址值，

然后在栈内存中的x变量记住了这个内存地址值；

b.   所有的数组已经建立，即使没有存入数据，数组的每一个角标位上已经被分配了一个默认初始化值;

int类型的初始化值是0；

double类型的数组其初始化值为0.0；

float类型的数值其初始化值为0.0f;

boolean型数组其初始化值为false。

c.   如果存在于堆内存中的数组对象其内存地址值没有被栈内存中变量所记住，那么在一定的时候

      他会被java中的垃圾回收机制清除掉。

除了上面创建数组的方式之外，java还允许下面两种创建方式：

       数组名称[ ]  =  new 元素类型[ 元素个数或者数组长度 ]；

       元素类型[ ]  数组名称  =  new 元素类型[]{元素1，元素2，元素3，元素4}；

数组中第一个元素称为0角标位元素，记为：数组名称[0]；后面元素一次递增；

元素4实际上只是3角标位元素，记为数组名称[3];如果写成数组名称[4]，那么就会发生：“数组角标越界异常”。

二维数组：将数组作为元素存到数组当中，构成的数组称为二维数组。

格式：int[ ] [ ]  arr  =  new int[3] [2] ;

          上述代码完成了这样的操作：

1. 定义了一个名叫arr的二维数组，

2. 这个二维数组中有3个一维数组；

3. 每个一维数组中都有2个元素；