javase学习笔记-----JAVA语言基础组成

JAVA语言基础组成：

    1，关键字。都用小写。类名每个单词的首字母要大写。

    2，标识符：在程序中自定义的一些名称。由26个英文字母大小写，数字0－9，符号_（下划线）

       和美元符$组成。

       定义合法标识符规则：1，数字不可以开头。2，不可以使用关键字。

       JAVA中严格区分大小写。在起名时，为了提高阅读性，尽量起有意义的名字。

    3，注释。用于注解说明解释程序的文字就是注释。

       // 单行注释。/*多行注释*/。/**文档注释*/。

       注释的应用：

       /*需求：练习一个helloworld程序。

           思路：1，定义一个类，因为java程序都定义在类中，java程序都是以类的形式存在的，

                  类的形式其实就是一个字节码文件的最终体现。

                2，定义一个主函数，为了让该类可以独立运行。

                3，因为要演示hello world，在控制台上看到该字样，所以需要使用输出语句完成。

           步骤：1，用class关键字来完成类的定义，并起一个阅读性强的类名。

                2，主函数：public static void main (String[ ] args)这是固定格式的。

                3，使用输出语句：System.out.println("helloworld");*/

       class Demo{

           //定义一个主函数，为了保证程序的独立运行。

           public static voidmain(String[ ] args){

              System.out.println("helloworld");//这是输出语句，用于将括号中的数据打印到

                                          //控制台上，ln表示可以在数据的结尾处换行。

           }

       }

       总结：代码仅仅是思想的一种体现形式。

    4，常量和变量。常量表示不能改变的数值。

       java中常量的分类：

           1，整数常量：所有整数。

           2，小数常量：所有小数。

           3，布尔型（boolean）常量：较为特有，只有两个数值：true和false。

           4，字符常量：将一个数字、字母或者符号用单引号标识。

           5，字符串常量：将一个或者多个字符用双引号标识。

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

       对于整数，有四种表现形式：

           1，二进制：0－1。满2进1。

           2，八进制：0－7。满8进1。用0开头表示。

           3，十进制：0－9。满10进1。

           4，十六进制：0－9，A－F。满16进1。用0X开头表示。

       进制的由来：任何数据在计算机中都是以二进制的形式存在的，二进制早期由电信号开关演变而来。

           一个整数在内存中一样也是二进制的，但是使用一大串的1或0组成的数值进行使用很麻烦。所

           以就想把一大串缩短点，将二进制的三位用一位表示，这三位可以取到的最大值就是7，超过7

           就进位了，这就是八进制。

       结论：八进制数，其实就是二进制位中的3个二进制位为一个八进制位。

             十六进制数，其实就是二进制位中的4个二进制位为一个十六进制位。

       负数的进制：其实就是这个数的正数的二进制取反，再加1。如求－6的二进制。

              0000－0110

           取反1111－1001

              +0000－0001

            －－－－－－－－

               1111－1010

       变量的概念：内存中的一个存储区域。该区域有自己的名称（变量名）和类型（数据类型）。

                  该区域的数据可以在同一类型范围内不断变化。

       为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用。

       使用变量注意：变量的作用范围（一对{ }之间有效）。初始化值。

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

       注意：格式是固定的，记住格式，以不变应万变。

       理解：变量就如同数学中的未知数。

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

       的内存空间。数据类型分基本数据类型和引用数据类型。基本数据类型又分为数值型、字符型（char）

       和布尔型（boolean）。引用数据类型包括类（class）、接口（interface）和数组（[ ]）。数值型

       又分整数型（byte,short,int,long）和浮点型（float,double）。

       整数默认为：int。小数默认为：double。

       在内存中占的空间：

           byte    占1个字节     char   占1个字节

           short   占2个字节    

           int     占4个字节     float  占4个字节

           long    占8个字节     double 占8个字节

    5，运算符。

       算术运算符：+ 、—、 *、 /、 %（取余，模运算）、+（连接符）、++、--。

       赋值运算符：＝、+＝、-＝、*＝、/＝、%＝。

       比较运算符：>、<、＝＝、>=、<=、!=、instanceof。运算完的结果必须是true或者是false。

       逻辑运算符：&、｜、^、！、||、&&。用于连接两个boolean类型的表达式。

           & （与）符号的运算特点：

              true  & true = true

              true  & false = false

              false & true  = false

              false & false = false

           & 符号的运算规律：

              运算的两边只要有一个是false，结果肯定是false；

              只有两边都为true，结果才是true。

           | （或）符号的运算特点：

              true  | true = true

              true   | false = true

              false | true  = true

              false  | false = false

           | 符号的运算规律：

              运算的两边只要有一个是true，结果肯定是true；

              只有两边都为false，结果才是false。

           ^ （异或）：和或有点不一样。

           ^ （异或）符号的运算特点：

              true  ^ true = false

              true  ^ false = true

              false ^ true  = true

              false ^ false = false

           ^ （异或）符号的运算规律：

              符号的两边结果如果相同，结果是false；

              两边的结果不同，结果是true。

           ！非运算符：判断事物的另一面。

           ！（运算符）符号的运算特点：

              !true = false

              !false = true

              !!true = true

           面试题：

           && （双与）：与&（单与）运算的结果是一样的，但是运算过程有点小区别。

              & ：无论左边的运算结果是什么，右边都参与运算。

              &&：当左边为false时，右边不参与运算。

           || （双或）：与|（单或）运算的结果是一样的，但是运算过程有点小区别。

              | ：无论左边的运算结果是什么，右边都参与运算。

               ||：当左边为true时，右边不参与运算。

       位运算符：<<（左移）、>>（右移）、>>>（无符号右移）、&（与运算）、|（或运算）、

                  ^（异或运算）、~（反码）。主要用于二进制位运算。

                  一个数异或同一个数两次，结果还是这个数。

                  一个数左移几位其实就是该数据乘以2的几次方。<<可以完成2的次幂运算。

                  一个数右移几位其实就是该数据除以2的几次方。>>对于高位出现的空位，原来

                  高位是什么就用什么来补这个空位。

                  >>>无符号右移：数据进行右移时，高位出现的空位，无论原高位是什么，空位

                  都用0补。

                  练习：用最有效率的方式计算2* 8的结果。可用左移。

       三元运算符：（条件表达式）？表达式1：表达式2。

              如果条件为true，运算后的结果是表达式1。

              如果条件为false，运算后的结果是表达式2。

    6，语句。

           判断结构：if语句的三种格式：

              1，if（条件表达式）{

                     执行语句；

                 }

              2，if（条件表达式）{

                     执行语句；

                 }

                 else{

                     执行语句；

                  }

                三元运算符是if else 的简写格式。

                简写格式什么时候用？

                    当if else 运算后，有一个具体的结果时，可以简化写成三元运算符。

               3，if（条件表达式）{

                     执行语句；

                 }

                 else if（条件表达式）{

                     执行语句；

                 }

                 else{

                     执行语句；

                 }

                 

              需求：根据用户指定的具体数据，判断该数据对应的星期。如：1－星期一Monday

              思路：用户输入无法获取但是那只是具体数据的一种获取手段而已。而我们要做的功能

                  仅仅是对用户指定的数据进行对应星期的打印而已。所以具体的数据不确定，完全

                  可以使用变量来表示。我们只对变量进行操作即可，至于变量的值，可以由用户决定。

                  因为数据的不确定性，所以要对数据进行判断。使用if语句。

           选择结构：switch（表达式）{

                         case取值1；

                             执行语句；

                             break；

                         case 取值2；

                             执行语句；

                             break；

                         ……

                         dafault；

                             执行语句；

                             break；

                    }

           if和switch的区别：

              if：   1，对具体的值进行判断。

                     2，对区间进行判断。

                     3，对运算结果是boolean类型的表达式进行判断。

              switch：1，对具体的值进行判断。

                     2，值的个数通常是固定的。对于几个固定的值进行判断，建议使用switch语句。

                         因为switch语句会将具体的答案都加载进内存。效率相对高一点。

           循环结构：代表语句有while、do while、for。

                  while语句：while（条件表达式）{

                                执行语句；

                            }

               do while语句：do{

                                执行语句；

                            }

                            while（条件表达式）

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

              练习：获取1到10 。10个数字的和。

                  0 + 1

                    1 + 2

                      3 + 3

                        6 + 4

                          10 + 5

                   思路：1，每次参与加法的数值不确定。

                         2，每次的出现的和数据也不确定。

                         3，发现参与加法运算的数值有递增规律。

                         4，每一次都是加法运算在重复，并且都是和再加上下一个数值。

                   步骤：1，定义一个变量，记录住参与加法运算的数据。

                         2，定义一个变量，记录住每一次出现的和。

                         3，对于记录参与加法运算的数据进行自增。

                         4，因为加法运算需要重复，就要想到循环结构。

                        int x = 1;//记录参与加法的数据。

                        int sum = 0;//记录住每一次的和。

                        while(x<= 10){

                            sum = sum + x;

                            x++;

                        } 

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

              练习：1－100之间，6的倍数出现的次数。

                  int x = 1;

                  int count = 0;

                  while(x<= 100){

                     if(x%6==0)

                         count++;

                     x++;  

                  }

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

              for（初始化表达式；循环条件表达式；循环后的操作表达式）

              {

                  执行语句；（循环体）

              }

           for和while的特点：

              1，for和while可以互换。

              2，格式上的不同，在使用上有点小区别。

                  如果需要通过变量来对循环进行控制，该变量只作为循环增量存在时，

                  区别就体现出来了。

           打印1－10十个数字。

              int x = 1;

              while(x<5){

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

                  x++;

              }

              System.out.println("x===="+x);//循环结束后，x的值还能用。

              for(y=1;y<5;y++){

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

              }

              System.out.println("y===="+y);//循环结束后，y的值不能用。

           无限循环最简单的表现形式：

              while(true){ }

              for(;;){ }

           什么时候使用循环结构呢？

              当对某些代码执行很多次时，使用循环结构完成。

              当对一个条件进行一次判断时，可以使用if语句。

              当对一个条件进行多次判断时，可以使用while语句。

              注意：在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。

                    循环通常情况下，需要定义条件，需要控制次数。

           for嵌套练习：

           *****

           ****

           ***

           **

           *

           for(int x=1;x<=5;x++){

              for(inty=x;y<=5;y++){

                  System.out.print("*");

              }

              System.out.println( );

           }

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

           *

           **

           ***

           ****

           *****

           for(int x=1;x<=5;x++){

              for(inty=1;y<=x;y++){

                  System.out.print("*");

              }

              System.out.println( );

           }

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

          

 

   54321

           5432

           543

           54

           5

           for(int x=1;x<=5;x++){

              for(inty=5;y>=x;y--){

                  System.out.print(y);

              }

              System.out.println( );

           }  

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

           1

           22

           333

           4444

           55555

           for(int x=1;x<=5;x++){

              for(inty=1;y<=x;y++){

                  System.out.print(x);

              }

              System.out.println( );

           }  

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

           九九乘法表：

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

           }

           \n：回车。

           \t：制表符。

           \b：退格。

           \r：按下回车键。

           windows系统中回车符其实是由两个符号组成的\r\n。linux系统中回车符是\n。

           * * * * *

            * * * *

             * * *

              * *

               *

           for(int x=1;x<=5;x++){

              for(int y=1;y<x;y++){

                  System.out.print("");//输出空格。

              }

              for(intz=x;z<=5;z++){

                  System.out.print("*");//输出*和空格。

              }

              System.out.println( );

           }

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

           break：跳出。

           break作用的范围：要么是switch语句，要么是循环语句。

           记住：当break语句单独存在时，下面不要定义其他语句，因为执行不到。

           break跳出所在的当前循环。

           如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。

           continue：继续。

           continue作用的范围：循环结构。

                  结束本次循环，继续下次循环。

                  如果continue单独存在时，下面不要有任何语句，因为执行不到。