黑马程序员——第二章 Java编程基础

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1.关键字

关键字是被Java语言赋予了特殊含义的单词。

所有的关键字都由小写字母组成。

main、sizeof不是关键字。

2.标识符

Java中包、类、方法、常量、变量、接口的名字。

由字母（汉字）、数字、下划线_、$组成，不能以数字开头。

不能使用java中的关键字和保留字。

为提高阅读性，尽量起得有意义。

命名规范：

常量名：                          格式：XXX_YYY_ZZZ

变量名和方法名：          格式：xxxYyyZzz

类名和接口名：              格式：XxxYyyZzz

包名：                              格式：xxx.yyy.zzz

3.常量

常量表示固定不能改变的数值。

常量的分类：

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

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

3，布尔型常量。只有true和false 。

4，字符常量。将一个数字、字母（汉字）或者符号用单引号( ' ' )标识。

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

6，null常量。只有null，表示对象的引用为空。

浮点数值不适用于禁止出现舍入误差的金融计算中。

原因：浮点数值采用二进制系统表示

例1：命令System.out.println(2.0－1.1)将打印出0.8999999999999999，而不是0.9。

例2：  doubled1=10.0%3.7;  //d1=2.5999999999999996

        doubled2=10.0%3.4;  //d2=3.2

 

char为无符号的数据类型，范围：0-65535，遵循ASCII码表。

字母a-z       ：          对应97-122

字母A-Z：        对应65-90

数字0-9：          对应48-57

 

4.进制和进制的转换：

二进制：0-1，满2进1 ，用0b或0B开头表示。

十进制：0-9 ，满10进1。

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

十六进制：0-9，A-F，满16进1.，用0x或者0X开头表示。

 

进制的转换：

十进制转二进制：循环模2取余数，值为余数倒着相加。

例：十进制数10转为二进制数

结果为余数倒着相加：0b1010

 

二进制转十进制：乘以2的幂数

例：二进制数1011转为十进制数

结果为：11

 

二进制转八进制：从右向左3位组成一位，不足3位补0

例：二进制数1100转为八进制数

结果为：014

 

二进制转十六进制：从右向左4位组成一位，不足4位补0

例：二进制数1001010转为十六进制数

结果为：0x4A

十进制、八进制、十六进制之间的转换都是先转换为二进制，再转换成目标进制数。

二进制正数：源码=反码=补码

二进制负数：反码=源码取反（最高位即符号位不变），补码=反码+1

计算机是采用二进制补码进行运算，显示的都是源码。

5.变量

内存中的一个有自己的名称（变量名）和类型（数据类型）存储区域，该区域的数据可以在同一类型范围内不断变化。

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

变量的作用范围：一对{}之间有效

变量的数据类型：

基本数据类型（8种）：

整数型：字节型（byte，占1个字节）

 短整型（short，占2个字节）

 整型（int，占4个字节）

 长整型（long，占8个字节，值后加l或L）

       浮点型：单精度浮点型（float，4个字节，值后加f或F）

 双精度浮点型（double，8个字节）

字符型：（char，2个字节，有且只有1个字符）

布尔型：（boolean）

引用数据类型：

类（class）

接口（interface）

数组（[]）

Java中整数类型默认为整型（int），浮点类型默认为双精度浮点型（double）。

 

数据类型转换：

大小关系：byte,short,char→ int → long → float → double（左到右依次增大）

结论：

小转大，自动类型转换（也叫隐式类型转换） 

大转小，强制类型转换（也叫显式类型转换）

 

成员变量和局部变量：

局部变量：在方法、语句或代码块中定义，没有默认初始化值，使用前必须初始化值，作用域是整个方法、语句或代码块，在栈中存储，生命周期相对较短。

 

成员变量：用域在类中，方法体外定义，有默认初始化值，作是整个类中，在堆中存储，生命周期相对较长。

6.运算符

算术运算符

 

% 取模运算，获取余数。

结论：

若%左边小于右边。

结果就是左边，被模数的正负不管。

%2用于判断奇偶数。

%10和/配合用于取十进制数的各个位的值

 

++i或--i，i先自增1或自减1，再参与运算；

i++或i--，i先参与运算，再自增1或自减1。

 

例：   floatf=(float)(-0.0/4.0);//f=-0.0

        doubled=-0.0/4.0;//d=-0.0

赋值运算符

= 、+=、-=、*=、/=、%=

例：short s = 1;

 s = s + 1;//编译失败，要强转，改为：s=(short)(s+ 1)

 s+=1;//编译成功，+=给s赋值时已自动强转

比较运算符

 

结果都是布尔类型：true或false

“==”不能误写成“=”

逻辑运算符

 

用于连接布尔型表达式，在Java中不能写成3<x<6，只能写成x>3 & x<6 。

&和&&的区别：单与两边都要参与运算；双与若左边为假，右边不参与运算。

|和||的区别同理，双或左边为真，右边不参与运算。

^ 异或可用于互换两个变量的值，可以用来加密。

位运算符

 

直接对二进制进行运算。

i<<n，相当于i = i*2的n次幂，右边空出位补0 

i>>n，相当于i = i/2的n次幂，左边空出位和最高位一致

>>> 左边空出位补0，配合&可用于进制转换

负数右移可能不相当于/2的n次幂。

左移和右移时，若数据为int要先对32取模，后移位；若数据为long，要先对64取模，后移位。

三元运算符

三元运算符的标准格式：  布尔表达式?表达式1:表达式2;

若布尔表达式为true，则结果是表达式1，否则就是表达式2，运算必然有结果，和if(){}else{}比简化了代码。

转义字符

通过\来转变后面字母或数字的含义

\n：换行

\t：制表符，相当于Tab键

\’：单引号

\”：双引号

\\：反斜杠

\b：退格，相当于Backspace

\r：相当于按下回车键

运算符的优先级

 

7.程序流程控制

Java里有顺序、选择、循环三大结构。

 

if条件语句

三种格式：

if(条件表达式){执行语句；}

if(条件表达式){执行语句；}else{执行语句；}，相当于三元运算符，但三元运算符必须要有运算结果。

if(条件表达式){执行语句；}else if(条件表达式){执行语句；}……else{执行语句；}

 

if()里表达式结果必须为boolean类型，建议常量写前面，防止误把==写成=。

if、else if、else语句中的{}可以不写{}，但 if只能控制距离他最近的一个复合语句，新手建议写{}。

 

switch选择语句

格式：

switch(表达式)

{

       case 取值1:

              执行语句；

              break；

       case 取值2:

              执行语句；

              break；

       …

       default:

              执行语句；

              break；

}

 

switch()表达式类型：byte、short、int、 char，JDK1.5时增加了枚举enum，JDK1.7时增加了字符串String。

case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

结束switch语句的两种情况：遇到break，执行到switch语句结束。

如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。 

 

while循环语句

格式：

while(条件表达式)

{

       执行语句；

}

 

先判断逻辑表达式的值。若=true.则执行循环体,然后再次判断条件并反复执行，直到条件不成立为止。

while(true)最简单的死循环。

 

do while循环语句

格式：

do

{

       执行语句；

}while(条件表达式);

 

先执行循环体,再判断逻辑表达式的值,若为true,再执行语句,否则结束循环。

无论条件是否满足，循环体至少被执行一次。

 

for循环语句

格式：

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

{

              执行语句；4

}

执行顺序：1 → 2 → 4 → 3 → 2 → 4 → 3

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

 

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

 

for(;;)最简单死循环格式。

 

增强for循环

  JDK1.5新特性：是一个简化书写的循环格式，前提是泛型技术。接口Iterable，凡是实现这个接口的类，都可以使用增强for循环进行遍历，包括数组。

  好处：简化书写，方便遍历

  弊端：不能操作数组或者是集合中的元素。

  格式:

    for(数据类型 变量 : 数组或者集合){

                     循环体;

    }

 

循环嵌套

累加思想：通过定义一个变量记录住每次变化的结果，通过循环完成累加。

计数器思想：通过定义一个变量记录住数据的状态变化，需要通过循环完成计数。

 

 

break(跳出)流程控制语句

用于选择结构和循环结构。

用于循环结构表示跳出当前循环，开始执行循环语句后面的语句。

 

continue(继续)流程控制语句

用于循环结构，结束本次循环继续下次循环。

 

标号可以让break和continue两个语句作用于指定的范围。

8.方法

方法的定义

方法也称为函数，就是定义在类中的具有特定功能的一段独立代码块。

定义方法可以将功能代码进行封装，实现独立的功能，提高了代码的复用性。

 

方法的格式

修饰符 返回值类型方法名(参数类型形式参数1，参数类型形式参数2，…)

       {

                     执行语句;

                     return返回值;//考虑有无返回值

       }

修饰符：public、protected，无访问控制符,private。

       返回值类型：方法运行后返回的数据类型，无返回则写void。

参数列表：(参数类型 形式参数1，参数类型 形式参数2，…)。

       参数类型：是形式参数的数据类型。

       形式参数：用于存储调用函数时传递给函数的实际参数。

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

       return：用于结束方法，指定返回数据。

       返回值：该方法运算后返回给调用者的结果。

 

方法的特点

1，必须定义在类里面。

2，函数只有被调用才会被执行。

3，方法结束后方法里的对象失去引用。

4，若方法无返回值，则返回值类型用void表示，return语句如果在最后一行可以省略不写。

 

方法的应用

两个明确

明确要定义的功能最后的结果是什么？  （确定返回值类型，没有为void）

明确在定义该功能的过程中，是否需要未知内容参与运算     （确定参数列表）

 

方法的重载(overload)

概念：

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

特点：

方法名相同，参数列表不同。

好处：

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

 

可变参数

JDK1.5的新特性，可变参数其实就是一个数组。

格式：

   修饰符 返回值类型 方法名 (参数类型...形式参数){}

使用条件：当定义一个方法时候，参数的数据类型已知，但是参数的个数不同。

使用注意事项：

一个方法中，只能定义1个可变参数。

如果方法中有多个参数，可变参数只能写在参数列表的最后。

 

9.数组

概念

同一种类型数据的集合，数组就是一个容器。

 

动态初始化：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

示例：int[] arr =new int[6];

 

静态初始化：

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

简化格式：元素类型[] 数组名 = {元素，元素，……};

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

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

 

数组的特性

1，可以自动给数组中的元素从0依次递增开始编号。

2，编号叫索引(index)，下标，角标，可以直接通过索引操作数组中存储的数据。

 

数组操作常见问题

1，不能静态初始化和动态初始化同时使用。

2，数组脚标越界异常(ArrayIndexOutOfBoundsException)，访问到了数组中的不存在的脚标时发生。

示例：

int[] arr = new int[2];

System.out.println(arr[3]);

3，空指针异常(NullPointerException)，数组的内存指向是null，但是继续操作数组。

示例：

int[] arr = null;

System.out.println(arr[0]);

 

内存结构

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

JVM在程序的运行时期把内存分为5片区域：栈内存、堆内存、方法区、本地方法区、寄存器。

   寄存器：JVM通过Windows和CPU对话的时候使用。

   方法区：存储写的方法。

   本地方法栈：JVM调用Windows底层功能使用。

   栈内存：运行方法，存储局部变量。

   当数据使用完，所占空间会自动释放。

   堆内存：存储实体对象的，数组，成员变量。

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

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

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

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

 

数组常见操作

数组的长度.length

遍历数组

       publicstatic void printArr(int[] arr)

{

              System.out.print("[");

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

 {

                     if(i != arr.length - 1)

 {

                            System.out.print(arr[i] + ",");

                     }

else {

                            System.out.println(arr[i] +"]");

                     }

              }

       }

 

获取最值

int[] arr ={10,78,93,-19,847,-7894,1,4,-3};

//方法一

public staticvoid getMax(int[] arr)

       {           

              int max = arr[0];

              for (int i = 1;i<arr.length;i++)

{

                     if(arr[i] > max)

                            max = arr[i];

}

              System.out.println(“max=”+max);//max=847

}

//方法二

       publicstatic void getMin(int[] arr)

       {

              int min = 0;

              for (int i = 1;i<arr.length;i++)

              {

                     if(arr[i]< arr[min])

                            min = i;

              }

              System.out.println("min="+arr[min]);//min=-7894

       }

 

查表法

importjava.util.*;//导入包

       publicstatic void main(String[] args)

       {

//创建Scanner类的对象，传递字节输入流

              Scanner sc = new Scanner(System.in);

              System.out.println("请在下面输入星期数");

//调用Scanner类的方法nextInt()获取键盘录入

              int week = sc.nextInt();

              if (week <= 0 || week >7)

              {

                     System.out.println("星期数输入错误");

                     return;   

              }

              //查表法输出星期数

              String[] arr = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

              System.out.println(arr[week]);

       }

 

数组的排序

  在数组中，按照小到大的排序，升序排列。

  选择排序，冒泡排序，快速排序，插入排序，希尔排序。

  选择排序的原理：数组中的下标，从0开始，和后面的下标比较换位置，第一次就把最小值放在arr[0]。

  冒泡排序的原理：数组中相邻的两个位置，比较换位，第一次就吧最大值放在arr[length-1]。

//练习选择排序

packagecn.itcast;

public classArraysDemo {

       public static void main(String[] args) {

              int[]arr = { 2, 21, 0, 5, -3, 89, 45, 14 };

              selectSort(arr);

              printArr(arr);//遍历数组，arr=[-3,0,2,5,14,21,45,89]

       }

       // 选择排序，第一次就把最小值放在arr[0]

       public static void selectSort(int[] arr){

              for(int i = 0; i < arr.length; i++) {

                     for (int j = i + 1; j < arr.length;j++) {

                            if(arr[i] > arr[j]) {

                                   int temp = arr[i];

                                   arr[i] = arr[j];

                                   arr[j] = temp;

                            }

                     }

              }

       }

 

//练习冒泡排序

       publicstatic void main(String[] args) {

              int[] arr = { 2, 5, 1, 6, 24, 89, 45, 36,41, 12 };

              bubbleSort(arr);

              printArr(arr);//遍历数组，arr=[1,2,5,6,12,24,36,41,45,89]

       }

       //第一次就把最大值放在arr[length-1]

       publicstatic void bubbleSort(int[] arr) {

              for (int i = 0; i < arr.length; i++) {

                     for(int j = 0; j < arr.length - i - 1; j++) {

                            if (arr[j] > arr[j + 1]) {

                                   inttemp = arr[i];

                                   arr[i]= arr[j];

                                   arr[j]= temp;

                            }

                     }

              }

       }

 

数组折半查找

已知一个数组，找一个数据，在不在数组中，如果在，返回数组所在的下标，如果不在返回负数。

遍历数组查找，性能低；折半查找，提高查找效率。

折半查找的前提是数组必须有序排列，每次查找，减少一半的数组元素。

如果是无序数组，使用折半查找不能保证结果正确性。

注意：不要先排序无序数组，再用折半查找。

              int[] arr = {1,4,6,8,11,15,18,21,24};

              int index = binarySearch(arr, 8);//在arr里找8

              System.out.println(index);//index=3

//折半查找  

       public static int binarySearch(int[]arr,int key){

              //定义变量，保存大，小 中间针的下标

              intmin = 0 ,max = arr.length-1 ,mid = 0;     

              while(min<= max){   //判断条件：是否有折半的可能性

                     //计算中间下标

                     mid = (min + max) / 2;

                     //用中间针下标上的元素，关键字比较

                     if(key > arr[mid])

                            min= mid + 1;

                     else if( key < arr[mid])

                            max= mid - 1;

                     else

                            returnmid;

              }

              return-1;//没有找到返回-1

       }

 

数组工具类

java.util.Arrays类，工具类中方法都是静态。

1，Arrays.sort()数组的排序，升序排序，面试考试千万别写。

       例：int[] arr ={3,1,5,6,2,7,9,8,18,12};

              Arrays.sort(arr);//给数组arr进行升序排序

 

2，intbinarySearch(数组，关键字)数组的折半查找，找到则返回下标，否则返回

（-插入点-1)。

   例：int[] arr = {1,2,5,6,8,9};

              int i = Arrays.binarySearch(arr, 7);//i=-5，对数组arr进行折半查找

 

3，static String toString(数组)将数组变成字符串，不是重写Object类的。

   例：int[] arr = {1,2,5,6,8,9};

              String s = Arrays.toString(arr);//将arr数组转成字符串

二维数组

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

定义了名称为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];

 

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

定义一个名称为arr的二维数组，二维数组中的有三个一维数组，每一个一维数组中具体元素也都已初始化。

 第一个一维数组 arr[0] = {3,8,2};

 第二个一维数组 arr[1] = {2,7};

 第三个一维数组 arr[2] = {9,0,1,6};

 第三个一维数组的长度表示方式：arr[2].length;

 

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。