黑马程序员--java基础语法



---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

知识点
一、关键字
二、标识符
三、注释
四、常量
五、变量
六、数据类型
七、运算符
-----------------------------------------------------------------------
一、关键字
       1、被Java语言赋予特殊意义的单词。
       2、特点：Java语言中的所有关键字全部是小写。
       3、注意事项：goto和const作为保留字存在，没有被使用。（在新版本中可能提升为关键字）   
二、标识符
       1、就是给类，变量，方法起名字的名词。
      2、组成规则：由数字0-9，英文大小写字母，$以及_组成。
       3、注意事项：
              （1）只能由组成规则规定的内容组成。
              （2）不能以数字开头。
              （3）不能是Java中的关键字。
              （4）区分大小写。
       4、常用的命名规则：见名知意，驼峰命名
              （1）包（文件夹，用于区分同名的类）：全部小写。如果多级包，用点.分开。
                            举例：com一级包；cn.it二级包     
                            注意：多级包常用域名的反写
              （2）类和接口：
                     A：如果是一个单词，首字母大写。
                            举例：Demo，Test，Student
                     B：如果是多个单词，每个单词的首字母大写。
                            举例：HelloWorld，StudyJava
              （3）变量和方法
                     A：如果是一个单词，首字母小写。
                            举例：main，name，age
                     B：如果是多个单词，从第二个单词开始每个单词的首字母大写。
                            举例：showName（），studentName
              （4）常量：全部大写，如果多个单词组成，用_连接。
                            举例：PI，STUDENT_MAX_AGE
三、注释
       1、就是对程序的解释性文字。
      2、注释的分类：
              （1）单行注释：以//开头，以回车结束；单行注释是可以嵌套的。
              （2）多行注释：以/*开头，以*/结束；多行注释是不可以嵌套的。
              （3）文档注释：以/**开头，以*/结束。将来被javadoc工具解析，生成一个说明书。
       3、注释的作用：
              （1）解释程序，提高程序的阅读性。
              （2）可以调试错误：有可能发生问题的代码，可以先注释起来，看运行结果再做判断
四、常量
       1、在程序的运行过程中，其值是不会发生改变的数据。
      2、常量的分类：
              （1）字面值常量
                     a：整数常量，如：12，-23
                     b：实数常量，如：12.5，-65.43
                     c：字符常量（'a'--97，'A'--65，'0'—48），如：'a'，'A'，'0'
                     d：字符串常量，如："hello"
                     e：布尔常量，只有2个：true，false
                     d：空常量，只有：null
（2）       自定义常量：被final修饰的成员变量是一个常量
3、常量可以直接被输出。
4、进制：对于整数，有二进制，八进制，十进制和十六进制4种表示形式。
       （1）进制是一种进位的方式。X进制，表示逢x进1。
              （2）Java中整数常量的表示
                     A：二进制 由0，1组成。以0b开头。JDK7以后的新特性。
                     B：八进制 由0-7组成。以0开头。
                     C：十进制 由0-9组成。默认就是十进制。
                     D：十六进制 由0-9，A-F（不区分大小写）组成，以0x开头。
              （3）进制转换：
                     A：其他进制到十进制
                            系数：就是每一位上的数据。
                            基数：X进制，基数就是X。
                            权：在右边，从0开始编号，对应位上的编号即为该位的权。
                            结果：把系数*基数的权次幂相加即可。
                     B：十进制到其他进制
                            除基取余，直到商为0，余数反转。
                     C：快速转换
                            a：8421码。
                            b：二进制--八进制（3位组合）
                            c：二进制--十六进制（4位组合）
五、变量
       1、程序的运行过程中，在指定范围内发生改变的量。
其实就是内存中的一个存储空间，用于存储常量数据。变量空间可以重复使用。
       2、格式：数据类型 变量名 = 初始化值;
              变形格式：
                     数据类型 变量名;
                     变量名 = 初始化值;
       3、注意问题：
              什么时候定义变量：当你知道这是一个变化的内容的时候。
              一般定义的范围：首先是在小范围内，如果不合理，在考虑大范围。
六、数据类型
       1、分类
              基本类型：4类8种。
              引用类型：类，接口，数组。
       2、基本类型
              整型：byte， short，int，long
              浮点型：float ，double
              字符型：char
              布尔型：boolean
              注意：整数默认是int类型。long类型需要加L或者l后缀。
                       浮点数默认是double类型。float类型需要加F或者f后缀。
       3、类型转换
              （1）boolean类型不参与转换。
              （2）隐式转换（从小到大）：byte，short，char à int à long à float à double
              （3）强制转换（从大到小），格式：（数据类型）数据;
注意：在运算的过程中，一般要求类型一致；不一致时，就会有类型转换问题
一般不推荐使用强制类型转换；尽量使用该数据类型能够表示的范围。
       4、试题
              byte b1 = 3;
              byte b2 = 4;
              byte b3 = b1 + b2;（编译失败，因为b1和b2参与运算时，数据类型自动提升为int）
              byte b4 = 3 + 4; （常量参与运算，编译器先算值，若值属于左边类型的范围就不报错。）
七、运算符
       1、就是把常量和变量连接的符号，一般参与运算使用。
      2、分类：算术运算符，赋值运算符，关系运算符，逻辑运算符，位运算符，三元运算符
              （1）算术运算符：+，-，*，/，%，++，--
                     +：正号，加法，字符串连接符。
                            System.out.println（"5+5="+5+5）;//5+5=55
                            System.out.println（5+5+"=5+5"）;//10=5+5
                     %：取得余数
                            左边如果大于右边，结果是余数。
                            左边如果小于右边，结果是左边。
                            左边如果等于右边，结果是0。
                        注意：
正负号跟左边一致。
任何整数模2不是0就是1，改变被模数就可以实现开关运算。
                     ++/--：++ 其实相当于把数据+1
                            单独使用：在数据的前后，结果一致，都是加1。      
                            参与操作使用：如果在数据的后边，数据先操作，在++/--
                                                  如果在数据的前边，数据先++/--，在操作。
              （2）赋值运算符： =，+=，-=，*=，/=，%=
                            int a = 10；：把10赋值给int类型的变量a。
                            a += 20；：把左边和右边的和，赋值给左边。
                     注意：a = a + 20;和a += 20;       结果是等价的，理解不是等价的。
                           因为+=这种运算符，内含了强制类型转换功能。
                           比如：short s = 2;  s+=3; 等价于s = （short）（s+3）;
              （3）比较运算符（关系运算符）：==，!=，>，>=，<，<=
                    特点：比较运算符的结果都是boolean类型，结果要么是true，要么是false。
                          请千万注意：== 不要写成 =
（4）逻辑运算符：&， |， !， ^， &&， ||         
                            &与：有false则false
                            |或：有true则true
                            !非：true变false，false变true
                            ^异或：相同false，不同true
                            &&短路与：有false则false
                            ||短路或：有true则true
                       注意：&&和&的区别是：如果左边有false了，右边将不再执行。
                               ||和|的区别是：如果左边有true了，右边将不再执行。
                                 开发中常用：&&，||，!
              （5）位运算符：
&按位与，|按位或，^按位异或，~按位取反，<<左移，>>右移，>>>无符号右移
注意：位运算符用于操作二进制位的运算符。
一个数据对同一个数据^两次，结果还是数据本身。
                              如：a ^ b ^ b = a（ 不分前后，a ^ b ^ a = b ; a ^ a ^ b = b ）
              （6）三元运算符（条件运算符），格式：条件表达式？表达式1：表达式2
                       执行流程：
                                   根据条件表达式返回的是true还是false，决定结果是什么。
                                   如果是true，就把表达式1作为结果。
                                   如果是false，就把表达式2作为结果。
                       举例：int a = 100;     int b = a > 50 ? 200：100;    请问b的值? 200
3：试题
              （1）请用最有效率的代码写出2乘以8：2*8 = 2<<3
              （2）请交换两个变量：a，b
                     A：临时变量
                            temp = a; a = b; b = temp;
                     B：不用临时变量
                            a = a + b;
                b = a - b; // b = (a+b)-b = a
                a = a - b; // a = a-(a-b) = b
                     C：位^运算符
                            a = a ^ b;
                            b = a ^ b;  //b = （a^b）^b = a;
                            a = a ^ b; // a = a^（a^b）=b;
 
 Java基础语法
知识点
八．语句
九、函数
十、数组
--------------------------------------------------------------------------------------------------
八．语句
流程控制语句：
                            A:顺序结构 代码按照顺序从上往下执行。
                            B:选择结构 根据以下选择或者判断做出不同的执行。
                                   a: 判断结构
                                   b: 选择结构
                            C:循环结构 把某些事情做很多次。
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；
       （3）注意事项
              A：什么时候时候哪一种if语句。
                      第一种格式在判断条件为一种情况下使用。
                      第二种格式在判断条件为两种情况下使用。
                      第三种格式在判断条件为多种情况下使用。
              B：每一种if语句其实都是一个整体，如果有地方执行了，其他地方的就不执行了。
              C：如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，
                      如果是控制多条语句，就必须写上大括号。建议永远写上大括号。
                      如：int x = 10语句，jvm会理解为2句代码：int x；x = 10；所以需加上大括号。              
              D：大括号和分号一般不同时出现。      
              E：作用域，所有变量的定义只在它所属的大括号内有效。
2、选择结构：switch语句
       （1）用于做选择使用的。一般用于几个常量的判断。
               switch会把几个常量值直接加载到内存，在判断的时候，效率要比if高。
               所以，针对几个常量的判断，一般选择switch语句。
       （2）switch语句的格式：
                     switch （表达式）{
                     case 值1：语句体1;  break;
                     case 值2：语句体2;  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或者执行到程序的末尾。
3、循环结构
       （1）如果我们发现有很多重复的内容的时候，就该考虑使用循环改进代码。
       （2）循环的组成
               A：循环体，就是要做的事情。
               B：初始化条件。一般定义的是一个初始变量
               C：判断条件。用于控制循环的结束。
               D：控制条件。用于控制变量的变化。一般都是一个++/--操作。
       （3）循环的分类：
              A： for
                     for（初始化条件; 判断条件; 控制条件）{ 循环体; }
                     执行流程：
                            a：先执行初始化条件;
                            b：执行判断条件
                            c：根据判断条件的返回值，true：执行循环体；false：就结束循环。
                            d：最后执行控制条件。返回到b继续。
              B： while
                     初始化条件;  while（判断条件）{ 循环体; 控制条件; }             
                     执行流程：
                            a：先执行初始化条件;
                            b：执行判断条件
                            c：根据判断条件的返回值，true：执行循环体，false：就结束循环。
                            d：最后执行控制条件。返回到b继续。
              C： do...while
                     初始化条件; do{ 循环体; 控制条件; }while（判断条件）;
                     执行流程：
                            a：先执行初始化条件;
                            b：执行循环体和控制条件;
                            c：执行判断条件
                            d：根据返回值，true：返回b；false：就结束循环。
              注意：
                     a： 一般使用for循环或者while循环。而且这两种循环是可以等价转换的。
                     b： do...while循环至少执行一次循环体。
                     c： 什么时候用for，什么时候用while?
                            如果是控制范围，最好用for。
                            如果范围不明确，用while。
 
       （4）循环嵌套：循环语句的循环体是一个循环语句。
                                   外循环控制行数，内循环控制列数。
       （5）案例：
              A：正三角形
                     内循环的判断条件：y<=x
                     for（int x=0; x<5; x++）
                     { for（int y=0; y<=x; y++）
                            { System.out.print（"*"）; }
                            System.out.println（）; }
              B：倒三角形
                     内循环的初始化条件：y=x
                     for（int x=0; x<5; x++）
                     { for（int y=x; y<5; y++）
                            { System.out.print（"*"）; }
                            System.out.println（）; }
              C： 九九乘法表
                       class ForForTest
{ public static void main（String[] args）
                            { 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（）; }
                                   }
}
4、break和continue
        （1）break和continue可以对循环进行一些控制终止，
        （2）特点：
               A：它们都必须在循环中（break还可以在switch中。）。一般在循环的判断中。
               B：如果单独使用break和continue，后面是不能有语句的。
        （3）区别：break 结束当前循环；continue 结束本次循环，进入下一次循环。
        （4）如何退出嵌套循环：
                用带标签的循环。
                格式：
                     标签名：for（）{
                                   for（）{
                                          if（）
                                          {
                                                 break 标签名;
                                          }
                                   }
                            }
5、应用场景
        （1）if语句：如果是一个范围的判断，boolean类型的表达式的判断，几个数据的判断。
        （2）switch语句：几个数据的判断。一般这种情况，优先选择switch。
        （3）for语句：如果次数或者范围特别明确。
        （4）while语句：如果次数或者范围不明确。
九、函数（方法）
       1、函数：定义在类中，有特定功能的一段小程序。
       2、函数的格式：
              修饰符 返回值类型 函数名（形参类型 形式参数1，形参类型 形式参数2...）
              {      函数体;  reutrn 返回值; }
 
              A：修饰符     public static
              B：返回值类型     程序最终结果的数据类型
              C：函数名     其实就是函数的名称，方便我们调用。
              D：参数
                     形参类型       数据类型
                     形式参数       就是接收实际参数的变量
                     实际参数       就是实际参与操作的变量（常量）
              E：函数体     就是按照正常的逻辑完成功能的代码。
              F：返回值     就是程序的最终结果
              G：reutrn 返回值 哪里调用程序，return就把结果返回到哪里。
                     如果返回值类型是void时，return语句可以省略不写的，系统会自动补上。
       3、函数的特点：
              A：函数与函数之间是平级关系。不能在函数中定义函数。
              B：运行特点 函数只有被调用才执行。
       4、函数的作用：
A：用于定义功能。
B：用于封装代码，提高代码的复用性和维护性。
       5、函数重载（overload）
              A：函数名相同，参数列表不同（个数不同或者对应的类型不同）。
                 与返回值类型无关。
              B：举例：public static int sum（int a，int b）{...}
                             public static int sum（int a，int b，int c）{...}
       6、参数传递问题。
              基本类型：形式参数的改变对实际参数没有影响。
              引用类型：形式参数的改变直接影响实际参数。
十、数组
1、数组是用于存储同一种类型的多个元素的容器。
       2、好处：数组中的元素会被自动从0开始编号，方便我们获取（索引）。
       3、格式（推荐A和D）：
              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、二维数组：
              格式：
                     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}};
5、数组操作的常见问题：
              ArrayIndexOutOfBoundsException：
数组越界异常，访问了不存在的索引。         
              NullPointerException：
空指针异常，一个实例(对象)已经不存在了，你还去访问它的内容。
6、JVM内存分区（5区）
（1）java栈(Stack)：用于存储局部变量，或者方法的执行。使用完毕，立马消失。
当JVM创建一个新线程时，都会产生程序计数寄存器和栈。每一次方法调用都会产生栈帧，栈帧中包含局部变量区和操作数栈。
       （2）java堆(Heap)：所有new出来的都在堆里面，用来存放java对象的。
程序中创建的类的实例和数组，包括class对象和exception对象，存放在堆里面。
堆中除了存储对象的实例数据外，还要存储该对象指向方法区中类型信息的指针。
              A：每一个实体都有地址值，本身是一个十进制，显示的是十六进制的值。
              B：每一个实体内的内容都有默认值
                     整数：0；浮点数：0.0；字符：'\u0000'；布尔：false
              C：在垃圾回收器空闲的时候（不确定时间）被回收。
       （3）java方法区(Method area)：方法，String常量池，静态区。
存放JVM加载的类型信息。包括: 类型基本信息，常量池，字段信息，方法信息，类变量，指向ClassLoader的引用，Class类的引用，方法表等。
（4）本地方法区(Native method Stack)：跟系统相关的方法。
也叫本地方法栈，当JVM线程调用了本地方法， 则会跳入本地方法栈。本地方法返回后可能再次跳回java方法栈。（JVM支持本地方法调用，故JVM占用的OS内存可能会超出JVM堆内存大小设置，甚至会产生本地内存泄漏）
       （5）寄存器(Program counter register)：程序计数寄存器，由CPU执行,因为寄存器位于处理器内部。
这个寄存器，我们只能够看看，而不能够对其产生任何的影响。也没办法在程序里头感觉到寄存器的任何存在迹象。 每个线程拥有自己的程序计数器，它指向下一条指令。当线程调用本地方法的时候，它为undefined。 
 

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！