Java语言基础组成

2.1关键字

main不是关键字，但被JVM所识别的名称。

2.2标识符

• 在程序中自定义的一些名称
• 由26个英文字母大小写，数字：0-9，符号：“$” “_”  组成。
• 定义合法标识符规则：1，数字不可以开头  2，不可以使用关键字。
• Java中严格区分大小写
• 注意：在起名字时，为了提高阅读性，要尽量有意义。

Java中的名称规范：

• • 包名：多单词组成时所有字母都小写。xxxyyyzzz
  • 类名接口名：多单词组成时，所有字母的首字母大写。XxxYyyZzz
  • 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单子首字母大写。xxxYyyZzz
  • 常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

2.3注释

• 用于注解说明解释程序的文字就是注释。
• 提高了代码的阅读性。
• Java中的注释格式：

1)单行注释　　格式：//注释文字

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

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

• 对于单行和多行注释，被注释的文字，不会被JVM（Java虚拟机）解释执行。
• 对于文档注释，是Java特有的文档注释，其中注释的内容可以被JDK提供的工具javadoc.exe所解析生成一套从网页形式体现的该程序的说明文档。（给开发者用的）
• 注释是一个程序员必须要具有的良好编程习惯。
• 初学者编写程序可以养成习惯：先注释在写代码。
• 将自己的思想通过注释先整理出来，再用代码去体现。
• 因为代码仅仅是思想的一种体现形式而已。

 /**

 这是我的Hello World程序。

 @author 小强

 */

 class Demo

 {

      /*

     这是主函数，程序的入口。

     他的出现可以保证程序的独立运行。

      */

     public static void main(String[] args)

     {

            //这是输出语句用于将括号内的数据打印到控制台。

            System.out.println("Hello World")

      }

18 }

2.4常亮和变量

1）常量

• 常量表示不能改变的数值。
• Java中常量的分类：

1. 整数常量，所有整数。
2. 小数常量，所有小数。
3. 布尔型常量，所有小数。
4. 字节常量。将一个数字字母或者符号用单引号（‘’）标识。（单引号里只能放一个字符！）
5. 字符串常量。将一个或者多个字符用双引号（“”）标识。
6. null常量。只有一个数值就是null。（对象，引用数据类型）

• 对于整数：Java有四种表现形式。进制越大，表现形式越短。

1. 十进制：0-9，满10进1。
2. 八进制：0-7，满8进1，用0开头表示。
3. 十六进制：0-9.A-F，满16进1，用Ox开头表示。
4. 二进制：0和1，满2进1。

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

由八个开关来表示一个最小的单位，叫字节。即八个二进制代表一个字节。

ascii编码表：用0和1不同的排列组合把生活中数据一一对应的表现出来。

进制转换：

十进制--->二进制　　原理：对十进制数进行除2运算。

二进制--->十进制　　原理：二进制乘以2的n次幂的过程。（从右开始乘）

十进制--->十六进制　　原理：四个二进制位代表一个十六进制位。

十进制--->八进制　　原理：三个二进制位代表一个八进制位。

负数的二进制表现形式：正数二进制取反加1.

取反：将二进制的1变成0,0变成1。

负数的二进制最高位都是1，正数的最高位为0。

2）变量

• 变量的概念：
  • 内存中的一个存储区域
  • 该区域有自己的名称（变量名）和类型（数据类型）。
  • 给区域的数据可以在同一类型范围内不断变化。
• 为什么要定义变量：
  • 用来不断地存放同一类型的常量，并可以重复使用。（就是将不确定的数据进行存储。）
• 使用变量注意：
  • 变量的作用范围（一对{}中有效）
  • 初始化值
• 定义变量的格式：
  • 数据类型    变量名=初始化值;
  • 注：格式是固定的，记住格式，以不变应万变。　　
• 理解：变量就如同数学中的未知数。
• 通过明确数据类型，变量名称，数据来完成。
• Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

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

long  l=4l      float  f=2.3f

• 自动类型转换（也叫隐式类型转换）
• 强制类型转换（也叫显式类型转换）
• 类型转换的原理
• 什么时候要用强制类型转换？
• 表达式的数据类型自动提升
  • 所有的byte型，short型和char的值将被提升到int型
  • 如果一个操作数是long型，计算结果就是long型。
  • 如果一个操作数是float型，计算结果就是float型。
  • 如果一个操作数是double型，计算结果就是double型。
• 分析：System.out.println('a')与System.out.println('a'+1)的区别。
  • char类型也可以进行运算，因为字符在ASCII编码表里面都有对应的数字。
  • 所有的计算机都支持ASCII编码表。

2.5运算符

• 算术运算符

知识点：

1. 取模“%”：取余数。
2. 左边小于右边，结果是左边。例：1%5
3. 左边等于右边，结果是0。
4. 右边等于1，结果是0。
5. 取模时，负数只看左边被模数，右边正负都不管。例：1%-5  结果1      -1%5  结果-1
6. 字符串连接符“+”：字符串数据和任何数据使用+都是相连接，最终都变成字符串。例：“5+5=”+5+5  结果“5+5=55”
7. 打印时，输出结果要直观有意义，用+连接起来。把固定的用双引号引起来，不固定的变量用+想连接。如：“a="+a+",b="+b

转义字符：通过\来转变后面字母或者符号的含义。

1. \n：换行。
2. \b：退格。相当于backspace。
3. \r：按下回车键。windows中，回车符是由两个字符来表示\r,\n
4. \t：制表符。相当于tab键。
5. println:"ln":在结尾处换行。
6. 转义字符要写在被转义符号的前面。如：”\“hello\”“

• 赋值运算符

  • 符号：=  +=  -=  *=  /=  %=
  • 示例：int a,b,c; a=b=c=3;  int a=3;a+=5,等同运算a=a+5
  • 思考：short s=3; s=s+2   s+=2  有什么区别？
  • s=s+2:编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
  • s+=2：编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。

• 比较运算符

注意：

1. 比较运算符的结果都是boolean型，即true/false.
2. 比较运算符”==“不能误写成”=“。

• 逻辑运算符:用于连接boolean类型的表达式。

&：只要两边的boolean表达式结果，有一个为false,那么结果为false。只有两边都为true，结果为true。(有假它就假，主要看false)

|：两边只要有一个为true，结果为true。只有两边都有false,结果为false.（有真它就真,主要看true）

^异或：就是和|有点不一样，当true^true=false

^:两边相同结果是false,两边不同结果是true。

"！"：！true  非真。

&和&&的特点：

&：无论左边是true是false,右边都运算。

&&：当左边为false时，右边不运算。（效率更高）

|和||的特点：

|：两边都参与运算。

||：当左边为true,右边不运算。

• 位运算符

• • <<:其实就是乘以2的移动的位数次幂。
  • >>：就是除以2的移动的位数次幂。

细节：

• • 位运算是直接对二进制进行运算。（此时0视为假，1视为真）
  • >>：最高位补什么有原有数据的最高位而定，最高位为0，右移后用0补空位，最高位为1，右移后用1补空位。
  • >>>：无论最高位是什么，右移后都用0补。
  • <<：空位补0，被移除的高位丢弃，空缺位补0。
  • &：二进制位进行&运算，只有1&1时结果是1，否则是0。
  • |：二进制进行|运算，只有0|0时结果是0，否则是1。
  • ^：任何相同二进制位进行^运算，结果是0,1^1=0,0^0=0. 不相同二进制位^运算结果是1,1^0=1,0^1=1　
  • 反码“~”：取反的意思。
  • 注意：一个数异或同一个数两次，结果还是那个数。相当于加密，然后再解密。

位运算练习：

1、最有效率的方式算出2乘以8等于几？  2<<3（8相当于2³，乘以就是向左移3位）

2、对两个整数变量的值进行互换（不需要第三方变量）

int n=3,m=8

（1）通过第三方变量：

 int n=3,m=8

 //1,通过第三方变量

 int temp;

 temp=n;

 n=m;

 m=-temp;

 //2,不用第三方变量(求和的方式)

 n=m+n;//11=3+8  如果n和m的值非常大，容易超出int 范围，损伤精度。

 m=n-m;//3=11-8

 n=n-m;//8=11-3

 //3,异或的方式

 n=n^m;

 m=n^m;//即m=(n^m)^m

 n=n^m;//即n=n^(n^m)

 class OperateDemo3

 {

     public.static.void.main(String[] args)

     {

         int num=60;

         //获取60的最低4位，通过&15

         int n1=num&15//=12;

         System.out.println(n1>9?(char)(n1-10+'A'):n1);//得到67，不是字符，后期会学到！

         //要获取下一组四位，将60右移4位

         int temp=60>>>4;//>>>:目的要把原有数值移光

         //对temp的值进行最低四位的获取

         int n2=temp&15//=3;

         System.out.println(n2>9?(char)(n1-10+'A'):n2);

         //0-9 'A'   'B'   'C'   'D'   'E'   'F'

         //      10  11   12   13  14   15

     }

 }

• 三元运算符

  • 格式：（条件表达式）？表达式1：表达式2；
  • 如果条件为true,运算后的结果为表达式1，若条件为false,运算后的结果为表达式2.
  • 示例：获取两个数中的大数。
    • int x=3,y=4,z;
    • z=(x>y)?x:y;//z变量存储的就是两数中的大数。

2.6语句

• 2.6.1判断结构

1、if（条件表达式）

　　{

　　　　执行语句；

　　}

　　2、if（条件表达式）//if else结构简写格式：变量=（条件表达式）？表达式1：表达式2；

　　{　　　　　　　//三元运算符　　好处：可以简化if else代码。弊端：因为是一个运算符，所以运算完必须有一个结果。

　　　　执行语句；

　　}

　　else

　　{

　　　　执行语句；

　　}

3、if（条件表达式）

　　{

　　　　执行语句；

　　}

　　else if

　　{

　　　　执行语句；

　　}

　　……

　　else

　　{

　　　　执行语句；

　　}

• 2.6.2选择结构

switch 语句格式：

switch(表达式)

{

　　case 取值1：

　　　　执行语句；

　　　　break;

　　case 取值2：

　　　　执行语句；

　　　　break;

　　……

　　default：

　　　　执行语句；

　　　　break;

　　}

switch语句特点：

1. switch语句选择的类型只有4种：byte，short，int，char
2. case之间与default没有顺序。先执行第一个case,没有匹配的case 才执行default。
3. 结束switch语句的两种情况：遇到break。或者，执行到语句结束。
4. 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

if和switch语句很像，

具体什么场景下，应用哪个语句呢？

1.如果判断的具体数值不多，而是符合byte，short，int，char，这四种类型。

虽然两个语句都可以使用，建议使用switch语句，效率稍高。

2.其他情况：对区间判断，对结果为Boolean类型判断，使用if，if的使用范围更广。

• 2.6.3循环结构

代表语句：while,do while,for

1）while语句格式：（先判断条件，只有条件满足才执行循环体）

while(条件表达式)

{

　　执行语句：

}

2）do while语句格式：（先执行循环体，再判断条件，条件满足，再执行循环体。）

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

do

{

　　执行语句；

}

while(条件表达式)

3）for 格式：

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

{

　　执行语句；

}

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

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

3.最简单无限循环格式：while(true),for（;;）【条件表达式默认为true】，无限循环存在的原因是并不知道循环多少次，而是根据某些条件来控制循环。

4.变量有自己的作用域。对于for来讲，如果将用于控制循环的增量，定义在for语句中。那么该变量只在for语句内有效。for语句执行完毕，该变量在内存中被释放。

5.for和while可以进行互换，如果需要定义循环增量，用for更为合适。

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

当要对某些语句执行很多次时，就使用循环结构。

for语句练习（累加&计数器）

（1）累加思想：原理：通过变量记录住循环操作后的结果。通过循环的形式，进行累加的动作。

（2）计数器思想：通过一个变量记录住数据的状态变化，也许通过循环完成。

语句嵌套形式：语句中还有语句。

循环嵌套：循环中还有循环。（毕老师形象说法：大圈套小圈。）

System.out.println();　　　　//只有一个功能就是换行。

对于打印长方形：外循环控制行数。内循环控制的是每一行的列数。也就是一行中元素的个数。

不是规律的规律：图形尖朝上，可以改变条件。让条件随着外循环变化。

　　　　　　　　图形尖朝下，可以改变初始化值，让初始化值随着外循环变化。

九九乘法表：空格用\t(制表符)

• 2.6.4其他流程控制语句

　　break（跳出），continue（继续）

　　break语句应用范围：选择结构和循环结构。

　　continue语句：应用于循环结构。

注：

1. 1. 这两个语句离开应用范围，存在时没有意义的。
   2. 这两个语句单独存在下面都不可以有语句，因为执行不到。(重点)
   3. continue语句是结束本次循环继续下次循环。
   4. 标号的出现，可以让着两个语句作用于指定范围。（例：w:for　q:for   break w/continue w）

2.7函数

• 2.7.1函数的定义

  • 什么是函数？
    • 函数就是定义在类中的具有特定功能的一段独立小程序。函数也称方法。
  • 函数的格式：
    • 修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，……）

{

　　　　执行语句；

　　　　return返回值；

}

• • 返回值类型：函数运行后的结果的数据类型。
  • 参数类型：是形式参数的数据类型。
  • 形式参数：是一个变量，用于储存调用函数时传递给函数的实际参数。
  • 实际参数：传递给形式参数的具体数值。
  • return：用于结束函数。
  • 返回值：该值会返回给调用者。

• 2.7.2函数的特点

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

• 2.7.3函数的应用

  • 如何定义一个函数呢？（两个明确）
    • 既然函数是一个独立的功能，呢么该功能的运算结果是什么要先明确。
    • 在明确定义该功能的过程中是否需要未知的内容参与运算。
  • 其实这两个功能就是在明确函数的定义
    • 是在明确函数的返回值类型
    • 明确函数的参数列表（参数的类型和参数的个数）
  • 示例：
    • 需求：定义一个功能，可以实现两个整数的加法运算。
    • 分析：
      • 该功能的运算结果是什么？两个数的和，也是一个整数（int）
      • 在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。（两个参数int，int）
      • 代码：

int getSun(int x,int y)

{

　　return x+y;

}

• 2.7.4函数的重载

  • 重载的概念

　　　　　　在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数和参数类型不同即可。

• • 重载的特点

　　　　　　与返回值无关，只看参数列表。  注意参数是有顺序的。

• • 重载的好处

　　　　　　方便与阅读，优化了程序设计。

• • 重载示例

　　　　　　1、返回两个整数的和：int add（int x,int y）{return x+y;}

　　　　　　2、返回三个整数的和：int add(int x,int y,int z){return x+y+z;}

　　　　　　3、返回两个小数的和：double add(bouble x,double y){return x+y;}

什么时候用重载？

　　当定义的功能相同，但参与运算的未知内容不同，那么这是就定义一个函数名称以表示其功能，而通过参数列表的不同区分多个同名函数。

例如：加法运算，99乘法表。

2.8数组

2.8.1数组的定义

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

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

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

　　示例：int [] arr = new int[5]　　//arr不是int类型，为数组类型（引用数据类型）

格式2：元素类型 [] 数组名 = new 元素类型{元素，元素，元素，……}

　　示例：int [] arr = new int[]{3,5,1,7,……}

　　　　　int [] arr = new int{3,5,1,7,……}

2.8.2数组的内存分配及特点

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：数组和对象，通过new出来的实例都存放在堆内存中。

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不再被使用，会在不确定的时间内被垃圾回收器回收。

方法区，本地方法区，寄存器。

2.8.3数组操作常见问题

格式3：int arr [] = new int[5]  //是对的！

arrayindexoutofboundsexception:数组角标越界异常。操作数组时，访问到了数组中不存在的角标。注：编译只检查语法。运行时异常就要修改程序了。

arr =null  ：nullpointerexception:空指针异常。当引用没有任何指向，值为空的情况，该引用还在操作该实体。

2.8.4数组常见操作

数组的操作：获取数组中的元素，通常会用到遍历。

数组中有一个属性可以直接获取数组中的元素个数。length.  使用方式：数组名称.length =

1，打印数组中的元素

2，获取数组中的最值（可以初始数组中的元素或者角标）

3，对给定数组进行排序（选择排序和冒泡排序）

　　选择排序：内循环结束一次，最值出现头角标位置上。（x+1：前后比，arr.length-1:少取最后一个元素角标的值，少比较一次）

　　冒泡排序：相邻的两个元素进行比较，如果符合条件换位。第一圈，最值出现在最后一位。(-X:让每一次比较的元素减少，-1：表面角标越界。）

　　array.sort(arr):Java中已经定义好的一种排序方式。开发中对数组进行排序，要使用该句代码。

4，位置置换功能抽取

　　发现无论什么排序，都需要对满足条件的元素进行位置置换，所以把相同的代码提取出来，封装成一个函数。

5，折半查找

　　return -1:数组角标都是从0开始，-1代表这个角标不存在，没有找到的这种情况。

　　定义功能，获取key第一次出现在数组中的位置。如果返回时-1，呢么该key代表在数组中不存在。

　　折半查找：提高效率，但是必须要保证该数组是有序的数组。

6.进制转换

　　十进制转换成二进制

StrimgBuffer sb = new StringBuffer//存储数据的容器，是一个对象

sb.append(num%2)//对象的存储数据方法

sb.reverse()//反转数据的功能

　　十进制转换成十六进制

sb.append((char)(temp-10+'A'))

num>>>4

　　查表法：

定义二进制的表：char [] chs = {'0','1'……};

定义一个临时储存器：char [] arr = new char[32];

定义一个操作数组的指针（与、查表、右移）,再打印。

2.8.5数组中的数组（二维数组[][]）

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

• 定义了名称为arr的二维数组
• 二维数组中有3个一维数组
• 每个一位数组中有两个元素
• 一维数组的名称分别为：arr[0],arr[1],arr[2].
• 给第一个一维数组1脚标位赋值为78的写法是：arr[0][1];

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

• 二维数组中有三个一维数组
• 每一个一维数组都是默认初始化值null
• 可以对着三个一维数组分别进行初始化

arr [0] = new int [3];

arr [1] = new int [1];

arr [2] = new int [2];

格式3：int [] [] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};

System.out.println(arr.length);//打印的是二维数组的长度。

System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度。

 int sum = 0;

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

 {

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

           {

                 sum = sum + arr[x][y];

            }

 }

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