黑马程序员——Java语言基础

本文主要是介绍黑马程序员——Java语言基础，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

关键字

        定义：被Java赋予特殊含义的英文单词。

        特点：都是小写的英文单词。

       

标识符

        ·在程序中自定义的一些名称

        ·由26个英文字母大小写，数字：0-9，符合：_$组成

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

        ·Java中严格区分大小写

        ·注意：在起名字时，为了提高阅读性，要尽量起有意义的名字。

注释

        ·定义：用于注解说明解释程序的文字就是注释。

        ·作用：提高代码的阅读性，以及对程序进行调试

        ·Java中的注释格式：

               1）单行注释——格式：//注释文字

               2）多行注释——格式：/*注释文字*/

               3）文档注释——格式：/**注释文字*/

        ·对于单行和多行注释，被注释的文字，不会被JVM（Java虚拟机）解析执行。

        ·对于文档注释，是Java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。

        ·注释是一个程序员必须要具有的良好编程习惯。

        ·初学者编写程序可以养成习惯：先写注释再写代码。  

        ·将自己的思想通过注释先整理出来，再用代码去体现。

        ·因为代码仅仅是思想的一种体现形式而已。

        ·注释的应用，例如：

     

常量和变量

      （一）、常量：表示不能改变的数值

            ·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、为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

               2、使用变量注意：变量的作用范围，初始化值

               3、定义变量的格式：数据类型 变量名 = 初始化值;，比如 int a = 1; 格式是固定的，记住格式，以不变应万变。

         用一个例子演示一下变量的运算：

        

          上面说到了数据类型，那么数据类型有哪些呢？

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

         

进制

       1、进制的转换，十进制转换成二进制，比如十进制的9转成二进制

      

       2、那么二进制怎么转成十进制呢？用二进制的1001转成十进制，看看是不是9

             我们十进制转二进制是除2的操作，那么二进制转十进制就是反过来，乘2的操作，所以

                      ——方法一：1001：1 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 8 + 0 + 0 + 1 = 9，很显然二进制1001表示成十进制就是9

                      ——方法二：二进制每一位从右往左分别对应的是1 2 4 8 16 32 ..... 其实就是对应方法一里的2的次方：2^0 2^1 2^2 2^3.....  ， 1 * 8 + 0 * 4 + 0 * 2 + 1 * 1 = 9

             二进制转换成八进制：比如，10101110转成八进制

                       ——先把10101110以3位为一段分成3段，因为三个二进制位为一个八进制位，前面不够补0 --> 010 101 110 --> 每一段对应一个数字，用上面的方法计算即可得：2 5 6 那么转成八进制就是0256.

            二进制转成十六进制：比如，10101110转成十六进制

                        ——把10101110以四位一段分开，因为四个二进制位为一个十六进制位，就是1010 1110，用上面的方法计算就是10 14，那么计算的结果就是0xAE

            负数的二进制表现形式

                       ——对应的整数二进制取反+1  ： 比如，求-6的二进制表现形式

                               首先，计算出6的二进制为：0000-0110 （用一个8位表示）

                               然后，对0000-0110进行取反：1111-1001（实际就是0变1，1变0）

                               最后，对1111-1001 进行 +1 操作，得1111-1010，那么1111-1010就是十进制-6的表现形式

类型提升和强制转换

1、自动类型提升（也叫隐式类型转换）：只有类型一致的才可做运算，类型不同，内存就不同，那么Java中有自动类型提升来处理类型不同的运算，但是前提都是数值。

2、强制类型转换（也叫显示类型转换）：在不同类型数值做运算的时候，运算结果由于自动类型提升的原因，用内存小的变量接收结果，但由于结果内存大于用于接收的变量内存时，可以使用强制类型转换，但是要慎用，因为用得不准确，会损失精度。

所有的byte型、short型和char型的值都被提升到int型；

如果有一个操作数是long型，计算结果就是long型；

如果有一个操作数是float型，计算结果就是float型；

如果有一个操作数是double型，计算结果就是double型。

System.out.print('a'+1);这个语句输出的结果是：98，因为char和int运算结果提升为int型的。

运算符

1、算术运算符：

              +（加）  -（减）  *（乘）  /（除）  %（取余，模运算）  +（连接符）  ++（自增，在原有数据基础上+1，再赋给原有数值）  --（自减）

     

2、赋值运算符：

               +=   -=   *=   /=   %=

     

3、比较运算符：

       ==（相等于）  !=（不等于）  <（小于）  >（大于）  <=（小于等于）  >=（大于等于）  instanceof（检查是不是类的对象）

      例子：System.out.print(3==2);//结果是false，因为事实上3用于不等于2，所以是false，比较运算符的结果要么是true，要么是false

4、逻辑运算符：

      用于连接多个boolean类型的表达式。

      &（与）的运算规律：只要运算的两边只有有一个false，结果就肯定是false；只有两边都为true，结果就是true；

       | （或）的运算规律：只要运算的两边只有有一个true，结果就肯定是true；只有两边都为false，结果才是false；

       ^（异或）的运算规律：两边符号如果相同，那么结果就是false；如果两边不同，结果就是true；

       ! （非），就是判断事物的另一面，运算规律：!true = false ; !false = true; !!true = true;；

       &&（双与）：和&运算结果一样的，但是过程有点区别。只要一为false，后边的就不再执行，比如x = 1; x > 2 && x < 5 ; 当判断了1 > 2 时 为false，那么 x < 5 就不执行了。

        | | （双或）：和 | 运算结果一样的，但是过程有点区别。只要一为true，后边的就不再执行，比如x = 1; x < 5  ||  x > 2; 当判断了1 < 5 时 为true，那么 x < 5 就不执行了。

5、位运算符：

     

6、三元运算符：

                顾名思义，有三个元素符号参与运算，二话不说，直接上例子代码：int x = 3 > 1 ? 6 : 8;首先判断3 > 1是否为true，如果是true，那么x = 6 , 否则x = 8；

程序的流程控制

1、if语句的三种格式：

        判断结构

      

2、switch语句

        就是选择结构体，如果有符合switch(表达式)里的表达式的结果的，就执行对应的case里的语句，如果没有那就执行default的里边默认的执行语句。

        建议：虽然在靠近结束的大花括号的可以不添加break；，但是我觉得添加会更好，因为在阅读性上有一点点优势，此外，break；的添加根据自己程序的逻辑需求。

       

if和switch的应用：

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

            2、对区间判断。

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

      switch：

           1、对具体的值进行判断。

           2、值的个数通常是固定的。

       注意：对于几个固定的值判断，建议使用switch语句，因为switch语句将具体的答案都加载进内存。效率相对高一点。

3、循环结构

       代表语句：while , do while , for

       while语句格式：

       while(条件表达式){

              执行语句;

       }

       do while语句格式：

       do{

             执行语句;

        }while(条件表达式);

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

       

         for语句格式：

         for(初始化表达式; 循环条件表达式; 循环后的操作表达式)｛

              执行语句;（循环体）

        ｝

         注：

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

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

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

        

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

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

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

注意：

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

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

public class FunctionDemo 
{public static void main(String[] args) {//求1 + 2 + 3 + 4 + 5 的和int sum = sum(1 , 5);System.out.println("区间[1, 5]的和为："+sum);myHello();//调用输出Hello World方法}/*** 方法1，用于求区间[a,b]的和* 参数a 左闭区间 参数b 右闭区间* return 区间的和 sum*/public static int sum(int a,int b){//用于累计和int sum = 0;//循环累加区间里的每一个元素，直到b为止while(a <= b){sum += a;a++;}return sum;//将结果和返回，并结束函数}/*** 方法2，用于输出"Hello World"* 方法是可以无参数传入的* 也可以无返回值，那就要用void表示返回值类型*/public static void myHello(){System.out.println("Hello World!"); //return; 可省略不写}
}

 
   函数的特点：

• 定义函数可以将功能代码进行封装
• 便于对该功能进行复用
• 函数只有被调用才会被执行
• 函数的出现提高了代码的复用性
• 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中return语句如果在最后一行可以省略不写。
• 注意：函数中只能调用函数，不可以在函数内部定义函数；定义函数时，函数的结果应该返回给调用者，交由调用者处理。

   4.函数的重载：

• 重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
• 重载的特点：与返回值类型无关，只看参数列表。
• 重载的好处：方便于阅读，优化了程序设计。
• 重载的示例：

  //返回两个整数的和
  int add(int x, int y)
  {return x + y;
  }
  //返回三个整数的和
  int add(int x, int y, int z)
  {return x + y + z;
  }
  //返回两个小数的和
  double add(double x, double y)
  {return x + y;
  }

数组

数组的定义

• 概念：同一种类型数据的集合。其实数组就是一个容器。
• 数组的好处：可以自动给数组中的元素0开始编号，方便操作这些元素。
• 格式1：数据类型[ ] 数组名字 = new 数据类型[元素个数或者数组长度]；示例：int [ ] arr = new int [5];
• 格式2：元素类型[ ] 数组名字 = new 数据类型[ ]{元素，元素，......}；示例：int [ ] arr = new int[ ]{3, 5, 7, 1}; 或者 int [ ] arr = new {3, 5, 1, 7};

JVM的内存的划分

1. 寄存器
2. 本地方法区
3. 方法区
4. 栈内存：1、存储的都是局部变量；2、而且变量所属的作用域一旦结束，该变量就自动释放。
5. 堆内存：存储的是数组和对象（其实数组就是对象），凡是new建立都在堆中。 特点：1、每一个实体都有首地址值；2、堆内存中的每一个变量都有默认的初始化值，根据类型的不同而不同。整数是0，小数是0.0或者0.0f，boolean false ， char ‘\u0000’；3、垃圾回收机制。
   

      

             注意常见错误：

class ArrayDemo 
{public static void main(String[] args) {int[] arr = new int[3];//	System.out.println(arr[3]);//ArrayIndexOutOfBoundsException //当访问到数组中不存在的角标时，就会发生该异常。arr = null;System.out.println(arr[0]);//NullPointerException//当引用型变量没有任何实体指向时，还在用其操作实体。就会发生该异常。}
}

数组的遍历

数组的基本动作就是存和储，核心思想就是对角标的操作。

例子，获取数组长度，输出每一个元素，以及获取最值：

class ArrayDemo 
{public static void main(String[] args) {int arr[] = {12, 523, 6, 12, 6, 7, 1234};//打印数组arr的元素个数（长度）System.out.println("lenght："+ arr.length);//遍历输出数组的每一个元素for(int i = 0; i < arr.length ; i++){System.out.println("arr[" + i + "] = " + arr[i] + ";");}/* 获取数组中的最大值和最小值* min用于记录在数组前i个中的最小值，max是最大值* min和max，一开始初始化为数组中的第一个元素*/int min = arr[0] , max = arr[0];for(int i = 1; i < arr.length ; i++){//发现有比min还小的，那就更新minif(min > arr[i])min = arr[i];//发现有比max还大的，那就更新maxif(max < arr[i])max = arr[i];}System.out.println("arr数组中最大值max="+max);System.out.println("arr数组中最小值min="+min);}
}

数组的排序

数组元素查找

二分查找：

//给定有序的数组arr，以及查找的元素public static int halfSearch(int[] arr, int key){int min = 0;int max = arr.length - 1;int mid = (min + max) / 2;while(arr[mid] != key){// 要找的数在角标mid的左边if(arr[mid] > key)max = mid - 1;// 要找的数在角标mid的右边else if(arr[mid] < key)min = mid + 1;			// 不能再折半了，数组里没有这个数if(max < min)return -1;// 继续折半mid = (max + min) / 2;}return mid;}

数组中的数组

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

• 定义l名称为arr的二维数组
• 二维数组中有3个一维数组
• 每一个一维数组中有2个元素
• 一维数组的名称分别为arr[0],arr[1],arr[2]
• 给第一个一维数组1角标为赋值为78的写法是：arr[0][1] = 78；

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

• 二维数组中有3个一维数组
• 每个一维数组都是默认初始化值null
• 可以对这个三个一维数组分别进行初始化
• arr[0] = new int[3];
• arr[1] = new int[1];
• arr[2] = new int[2];

这篇关于黑马程序员——Java语言基础的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---