java串讲Word下载.docx

java串讲Word下载.docx

《java串讲Word下载.docx》由会员分享，可在线阅读，更多相关《java串讲Word下载.docx（20页珍藏版）》请在冰豆网上搜索。

常量值：

123，1.23，’a’，”hello”，true

代表一个固定值的常量标识符：

final来定义。

4.变量

内存中的若干存储单元，与类型有关。

int型，4字节；

double型，8字节。

变量定义：

inta=5;

定义变量的同时赋值

doublex,y;

同时定义2个变量

floatf1=1.23f;

数值常量默认为double型，当把一个数值常量赋值给一个float型的变量时，在数值的后面加上f进行说明。

5.字符型

16位二进制（2个字节）表示的Unicode编码，包括26个字母（大小写），数字，键盘上的符号，转义字符，\u0000-\uffff。

可当做相应的整数进行+和-的运算。

charc=’a’//对应的unicode数值为97

c=c+1;

//此时c=’b’;

6.整型

8进制：

0开头

16进制：

0X或者0x开头

10进制：

正常数字

比如：

01231230x123

7.类型转换

隐含转换（自动转换），一个表达式中出现多种数据类型时，转换原则：

低精度向高精度转换，int转成long或者double，char转成int

强制转换：

（目标数据类型）变量

doublea=5.15;

（int）a;

通常用来对一个数取整，不四舍五入。

8.算术运算符

/：

如果是两个整型进行除法，得到整数的商

%：

整除的余数，余数的符号（正、负）与被除数相同

++和--：

加1和减1，

a++（在表达式中先使用a的原值进行运算，然后a再加1）

++a（在表达式中a先加1，然后使用a的新值进行运算）

记忆方法：

+在前，先加后用；

+在后，先用后加

9.关系运算符

>

<

>

=<

===或===，运算结果是布尔型，true或者false

10.逻辑运算符

||&

&

!

（非）：

运算结果是布尔型

11.System.out.print（）;

输出，双引号内部的，原样输出；

变量名，输出变量的值；

+表示字符串或者变量值的连接

第3部分分支结构

1.单分支

if（条件表达式）条件表达式为真时，执行{}内的语句；

否则不执行。

{}

条件表达式：

是关系表达式或者逻辑表达式，结果为布尔型

{}没有大括号时只执行if后面的一条语句

2.双分支

if（条件表达式）

{语句块1}

else

{语句块2}

条件表达式为真时，执行语句块1；

否则执行语句块2。

3.多分支

if（条件表达式1）

elseif（条件表达式2）

else.....

4.switch语句

switch（表达式）{

case常量值1:

语句块1;

break;

case常量值1:

.......

default:

语句块;

说明：

表达式通常为整型或者字符型的变量；

case后面的常量须与表达式中的变量的类型相同；

每个case语句后都有一个break，代表跳出switch语句

如果多个常量值对应相同的操作，可以共用一个语句块和break；

default不是必须的。

第4部分循环结构

1.while循环

初始化;

while（条件表达式）{

循环体;

while中的条件表达式成立时，执行循环体；

当循环体中的语句执行完毕，遇到大括号}时，返回到while处，再次判断条件表达式是否成立，如果成立，继续执行循环体，如果不成立，就结束循环，执行}后面的语句。

2.do....while循环

do{

}while（条件表达式）;

遇到do语句时，首先执行循环体；

当循环体中的语句执行完毕，遇到while处，判断条件表达式是否成立，如果成立，返回到do开头继续执行循环体，如果不成立，就结束循环，执行while后面的语句。

与while循环相比，do...while循环至少被执行1次。

3.for循环

for（表达式1;

条件表达式2;

表达式3）{

遇到for语句，首先执行表达式1，然后判断条件表达式是否成立，如果成立，执行循环体；

循环体执行完毕，遇到}大括号时，执行表达式3，然后返回到for开头，再次判断条件表达式是否成立，直到不成立时结束循环。

4.break强制性结束循环，一般放在循环体中，与if语句结合使用，当满足某一条件时不再继续执行循环。

5.continue强制性结束本轮循环，continue后面的语句的不执行，直接到循环体后面的}大括号处，然后执行表达式3.......

第5部分数组

1.什么是数组

数组是内存中可以存放多个数据的存储区域，一个数组中存放的数据类型是相同的，数组中的每个数据叫做一个数组元素，数组对每一个元素进行编号，可以使用数组名[编号]的形式对数组元素进行存取。

编号从0开始。

2.定义数组

java中用[]表示数组，定义数组的语法形式：

数据类型[]数组名；

或者数据类型数组名[]；

例如：

int[]x;

或者intx[];

表示整型数组x，这样只是定义了x是一个整型数组，并没有为x分配存储空间，使用new关键字在内存中为数组分配空间。

int[]x=newint[5];

定义了整型数组x，并且在内存中为x开辟了长度为5个整型的存储空间，也就是20个字节，每个int为4个字节。

x[0]int型

←x，数组名x指向该存储区域第一个存储单元的地址号。

数组是一种引用数据类型。

x[1]int型

x[2]int型

x[3]int型

x[4]int型

3.数组的初值

使用new创建数组后，系统为每个数组元素赋初值。

int型初值为0，double型初值为0,0，float型初值为0.0f，char型初值为’‘，boolean型false。

4.数组的释放

当不再使用一个数组时，应释放数组占用的存储空间，也就是赋值数组名为null，此后数组名将不再指向该片存储区域。

这片不再使用的存储区域成为垃圾，java的垃圾清理机制会自动释放这些垃圾区域。

5.数组区域的共享

int[]x=newint[5];

分配了空间，也就是x为一个地址号

int[]y;

没有分配空间

y=x;

将x的地址号赋给y，这时y也指向x数组，x和y数组共享一片存储区域，只是数组名不同，x[1]的值与y[1]的值相同，用这种方法可以在函数中传递多个返回值。

6.定义数组的同时为数组元素赋值

int[]x=newint[]{1,2,3,4,5};

不需要指明数组元素的个数，也可以在等号后面直接写{}，如int[]x={1,2,3,4,5};

7.数组的遍历

数组名[下标]如x[3]表示一个数组元素，将下标从0变化到数组长度-1，这样就能表示每一个数组元素，如

int[]x=newint[5];

x[0]第1个元素

x[1]第2个元素

x[2]第3个元素

x[3]第4个元素

x[4]第5个元素

通常会使用变量i表示数组下标，然后i的变化是从0到数组长度-1，在循环中访问每一个数组元素，这叫做数组的遍历。

length是数组的一个属性，用来获取数组的长度，所以在循环中会使用length，而不会直接写出表示数组长度的数字。

for（inti=0;

i<

x.length;

i++）

System.out.print（“x[“+i+”]=”+x[i]）;

8.数组的最大最小值

使用下面的代码获取数组的最大最小值，对这段代码从算法上还不明白的，观看提供的视频“数组常见操作-求最值”。

int[]x={5,9,8,10,16,7,3,2};

intmax,min;

max=x[0];

min=x[0];

for（inti=1;

{

if（max<

x[i]）max=x[i];

if（min>

x[i]）min=x[i];

}

System.out.print（"

max="

+max+"

min="

+min）;

思考：

上面的代码中，变量i为什么从1开始？

如果要记录最大或者最小值是数组中出现的位置，也就是数组中的第几个元素，也即下标，应如何修改程序？

9.数组的排序

这部分总体较难，要想理解者几个算法需要花费一些时间和精力，可以暂时放一放，如果考试题中有数组排序方面的编程的话，可以使用数组类的sort方法，这个我们后面会讲到。

第6部分函数

1.什么是函数

函数又称方法，是一段具有独立功能的代码。

当我们想要使用这段代码的功能时，只需要指出函数名就可以，这就是函数的调用，也称为调用函数。

如果在使用函数的功能时，必须提供一些必要的条件，比如，函数的功能是计算两个数的和，那么在调用函数时需要告诉函数，这两个数是什么，也就是向函数传递参数。

2.定义函数

修饰符返回值类型函数名（形式参数1类型形式参数1，形式参数2类型形式参数2......）{

实现函数功能的代码段;

return返回值;

}

形式参数：

函数带有参数，说明要执行这段代码需要一定的前提条件，以参数的形式传递给函数，在定义函数时，这时候参数是没有具体值的，所以称为形式参数，也就是在这占一个参数的位置。

写形式参数时，先写参数的类型，再写参数名，如果有多个相同类型的形式的参数，也不能将数据类型写成一个，而是应该每个参数写一个。

例如sum（inta,intb）不可以写成sum（inta,b）。

返回值：

如果没有返回值，返回值类型的地方写void。

修饰符：

修饰符有3类，访问控制修饰符、存在修饰符、操作修饰符，这里我们先了解一下访问控制修饰符，其他2类修饰符在学习完类之后再提及。

访问控制修饰符：

有public、protected、private、default。

public：

该方法可以被该类及子类、其他类使用；

protected：

该方法可以被该类及其子类（可以在其他包）使用；

private：

该方法只能被该类使用，不包含子类；

default：

默认，可以被同一个包中的类使用。

3.调用函数

可以在其他函数和main函数中调用函数，调用时需要给参数具体的值，这时叫做实际参数，简称实参。

调用函数的返回值可以被当做一个具体的数值来对待，可以出现在任何能够出现该数据类型的位置。

比如，函数sum是计算两个整数的和，可以定义为

publicintsum（inta,intb）{

returna+b;

调用函数时，可以写成System.out.print（sum（3,2））;

直接输出结果。

4.函数应用

理解了函数的知识之后，如何根据需要声明函数呢？

首先分析想要实现的功能，确定有没有返回值，要想实现这个功能的话，是否需要已知一些条件，作为参数。

第7部分类与对象

1.类与对象的概念

对象是现实世界中的实体在计算机中的体现，也可以说是将现实中的实体表示成计算机中能够存储的形式，比如，一个学生张三，在现实世界中我们看到的是一个人的样貌和动作，那么在计算机中如何存储呢？

姓名：

张三

年龄：

20

性别：

男

专业：

计算机网络技术

特长：

打篮球

这样表示之后，就可以把现实中活生生的一个人物以抽象数据的形式存储到计算机中，可以理解为计算机以对象的形式存储现实世界的实体。

类是具有一定共性的对象的抽象。

比如，上面对象的例子，我们说了一个张三，那么还会有李四、王五，那么这些学生的共性是什么呢？

他们都具有下面的属性：

也可以理解为，类是对象的模板，对象是类的一个实例。

类与对象的概念较为抽象，一时难以完全领悟，大家可以将这种概念放一放，重点是学会用java的代码表示类和对象，预计不会考查到让大家从现实世界中分析出一个类和对象。

2.面向对象的特征

抽象、封装、继承和多态是面向对象的基本特征。

（如果有3个空的话，就不用写抽象。

）

抽象：

是指将现实世界中实体，分析出他们的特征，在计算机中以对象和类的形式表示。

封装：

是将对象和类的属性和行为，封装在一个盒子里，程序中在使用时，只需要给类的属性赋值，和调用类的方法，而不需要去了解这些方法是用什么代码来实现的。

继承：

是指类和类之间可以共享一些属性。

比如，学生类和班长类，学生类和班长类都具有姓名、年龄等属性，学生类包含班长类，那么就可以设定为班长类继承学生类的某些属性。

多态：

是指类中的方法（函数），不改变方法名，只改变方法的参数个数或者参数类型，也就是说一个方法名，因为不同的参数，具有了多个功能，共用一个方法名，便于记忆。

publicintsum（inta,intb）和publicintsum（inta,intb,intc）方法名sum既可以进行两个数相加，也可以进行三个数相加。

当系统调用这个方法时，会根据参数的个数（类型），找到相应的代码。

3.类的定义

包含类头和类体两部分。

修饰符class类名{

每个成员变量的类型和变量名；

每个成员方法的方法名和代码段；

类的修饰符有3个：

public、abstract、final。

表示类的访问权限，表示该类可以被任何其他类所使用；

abstract：

表示该类是一个抽象类，抽象类的成员方法值给出方法名，没有代码段，具体的代码段由子类进行定义。

final：

最终类，表示该类不能被继承。

类的定义是java考试的必考内容，通常会给出需要定义的属性和方法，我们应根据题目要求，做到：

（1）确定属性的数据类型和合适的标识，写在{}中；

（2）分析方法的功能，确定返回值类型和形式参数，以及能够实现功能的代码，写在成员方法的位置。

4.变量的作用范围

类体中有类的成员变量，我们之前写的代码中，main函数和自定义的函数中，也有变量。

根据变量的作用范围不同，将变量分为局部变量和全局变量，main函数、自定义的函数已经for循环语句中定义的变量，只能在本函数内（循环体）使用，叫做局部变量。

而类中的成员变量，可以有类的所有成员方法共同使用，称为全局变量。

在定义类的成员变量时，在变量前加上static修饰符，这时变量就成为类变量，没有static的成员变量叫做实例变量。

类变量由所有该类的对象统统使用，而实例变量只能有某个特定的实例使用。

5.类的对象

声明对象：

类名对象名；

创建对象：

对象名=new类名（参数）//参数可有可无，应与类的构造方法一致

声明的同时创建对象：

类名对象名=new类名（参数）

访问类的成员变量：

对象名.成员变量名

访问类的成员方法：

对象名.成员方法名（必要的参数）

销毁对象：

对象名=null，释放了对象占用的存储空间，垃圾回收机制会收回这部分空间

6.构造方法

构造方法是一种特殊的类方法，其特殊性在于：

（1）构造方法与类名相同，没有返回值，一般为public

（2）构造方法在创建对象时由系统自动调用；

（3）可以对构造方法进行重载，同一个构造方法名（类名）有不同的参数（类的成员变量），这样就可以使用多种构造方法创建对象。

（4）如果没有显式地定义构造方法，系统自动提供一个构造方法，该方法没有任何参数也没有任何语句。

如果显式地定义了构造方法，而有想使用无参数的方法创建对象时，必须将此空的构造方法显式地写出来。

publicclassc6{

publicstaticvoidmain（String[]args）{

inta=123,b,c;

c=a%10;

//个位

b=（a/10）%10;

//十位

a=a/100;

//百位

System.out.print（a+"

"

+b+"

+c）;

第8部分异常

1.异常类

程序运行过程中产生的意外事件，将会中断指令的正常执行。

产生异常的情况很多，比如除数为0、数组下标越界、找不到文件等。

Java中也是采用类的形式来管理异常，一个异常事件的发生就是产生了一个异常类的对象。

异常类的最上层是Throwable类，它是所有异常类的基类（祖先），Throwable有两个直接子类，Exception类和Error类，Exception类是用户在程序中能够捕获并且处理的异常，也就是用户已知在某个代码段中有可能产生的异常。

Error类是系统内部错误，产生的是代码不可控的结果。

如虚拟机错误、内存耗尽。

Exception类分为RuntimeException运行时异常类和非运行时异常（编译异常，如IOException），非运行时异常必须处理，否则不能通过编译。

RuntimeException类的常见子类有ArrayIndexOutOfBoundsException（数组下标越界）、ArithmeticException（算术运算异常）、ClassNotFoundException（找不到类异常）。

2.异常处理机制

当代码出现异常时，如何对异常进行处理。

默认情况下，当某一条语句产生异常时，该异常会交给调用者来处理，逐级向上反馈，一直到JVM（java虚拟机），JVM终止程序运行，并且反馈给用户英文的错误信息。

为了让用户弄明白程序为什么会停止运行，应该以用户能够接受的形式通知用户所发生的事情，这就是程序的友好性，这也就要求必须在程序中对发生的异常进行处理，而不是交给虚拟机。

异常处理包括抛出异常和捕获异常。

抛出是指JVM在运行某一程序的过程中，发生了异常（产生了一个异常对象），将此异常对象交给产生异常的程序。

捕获是指程序得到此异常后，交给专门的处理方法来处理异常，这就要求程序代码中有这个处理方法。

3.捕获异常

try/catch/finally语句块

try{

可能产生异常的代码段

catch（异常类1）{//Exception类的各个子类RuntimeException

发生异常类1的异常事件时的处理方法

.....多个catch语句块

finally{

无论是否发生异常，都将执行的语句块

（1）执行顺序：

try语句块；

某一个catch语句块；

finally语句块。

（2）当try语句块中的一条语句发生异常后，该条语句后面的语句不会被执行。

（3）catch和finally可以都有，也可以只有一个。

（4）多个catch语句块时，最先匹配的一个语句块被执行，后面的catch语句块不会被执行，所以应将底层的异常类放在最前面，这样可以得到特定的异常。

ArithmeticException是RuntimeException的一个子类，catch（RuntimeException）也会匹配ArithmeticException的异常。

4.声明异常

一个方法（代码段）可能产生异常，自身不进行处理，而是交给其调用者处理，此时将可能产生的异常写在方法头中，用throws。

声明异常：

方法头throws异常列表（也就是各个异常类的名称）

方法名（参数列表）throws异常列表,{

语句;

没有try/catch

main（）{

不是一条一条的语句，而是调用一个方法

catch（异常异常对象名）{

用对象名来访问异常

5.抛出异常

在程序代码中产生一个异常，

thrownewArithmeticException（）;

第9部分多线程

1.什么是线程

在理解线程的概念之前，我们先来了解一下进程。

我们现在使用的Windows操作系统，是一个多任务的操作系统，我们可以在玩游戏的同时听音乐，也就是游戏程序和音乐播放程序都在运行。

一个程序在不运行时，是保存在硬盘上的，双击启动后，将指令序列调入到内存，分配所需要的内存空间和软硬件资源，比如音乐播放程序，除了分配内存空间存放数据，还需要分配声卡。

简单理解，进程就是程序的一次执行，或者说正在进行中的程序叫做进程，进程是由操作系统调度和分配资源的。

在单CPU的系统中，某一个时刻只有一个进程在执行，而我们感受到的多个任务同时执行的状况，是因为CPU轮转时间片给各个进程，比如时间片0.1秒，进程A执行完0.1秒，CPU就去执行进程B，也是01.秒，直到进程A后面的所有进程各执行0.1秒后，再次执行进程A。

因为CPU执行速度很快，使人类感受不到时间片的停留，就好像多个进程在同时执行一样。

我们之前所编写的代码，不论代码多还是少，都是只有main函数作为程序入口，然后按照语句的先后顺序，逐条执行，不会出现写在后面的语句比它前面的语句先执行的情况，也不会出现一个语句块与其他语句块同时（时间片造成的假象）执行的情况。

如果一条语句在执行时需要外部资源，而此时外部资源正在被其他进程使用，也就是说这条语句需要等待外部资源释放后才能继续执行，导致该条语句后面所有的语句都进入到等待状态。

我们使用过的软件，例如电脑管家，在“查杀病毒”的同时，还可以进行其他操作。

这说明在一个软件内部，也可以存在多个同时执行的代码段，这就是线程。

从定义上说，线程是