null第二章 Java的基本语法第二章 Java的基本语法第一节 Java程序规范
第二节 Java的基本符号
第三节 数据类型和变量
第四节 数组第一节 Java程序规范——源程序第一节 Java程序规范——源程序package语句； //该部分至多只有一句，必须放在源程序的第一句
import语句； /*该部分可以有若干import语句或者没有，必须
放在所有的类定义之前*/
public classDefinition； //公共类定义部分，至多只有一个公
共类的定义
classDefinition; //类定义部分，可以有0个或者多个类定义
interfaceDefinition; //接口定义部分，可以有0个或者多个接
口定义第一节 Java程序规范——示例第一节 Java程序规范——示例package javawork.helloworld; /*把编译生成的所有.class文件放到包 javawork.helloworld中*/
import java.awt.*; //告诉编译器本程序中用到系统的AWT包
import javawork.newcentury; /*告诉编译器本程序中用到用户自定义
的javawork.newcentury*/
public class HelloWorldApp{......} /*公共类HelloWorldApp的定义，名
字与文件名相同*/
class TheFirstClass{......} //第一个普通类TheFirstClass的定义
class TheSecondClass{......} //第二个普通类TheSecondClass的定义 …… //其它普通类的定义
interface TheFirstInterface{......} /*第一个接口TheFirstInterface的定
义*/ …… //其它接口定义第一节 Java程序规范——命名第一节 Java程序规范——命名为了提高程序的可读性，Sun公司推荐在Java编程时使用以下的习惯约定：
包名（packages）：包名是全小写的名词，中间可以由点分隔开，如：java.awt.event
类名（classes）：有一个或若干个名词组成，开头大写，名词间的区分也用大写，其他小写。如：class AccountBook
接口名（Interfaces）：规则同类名。如：Interface Account
方法名（methods）：由一个或多个动词组成，开头小写，动词间区分用大写，其他小写。如：balanceAccount()
变量名：小写字母开头，单词间用大写字母分隔，不要用下划线和$，如：currentCustomer
常量名：所有字母大写，单词间用下划线区分，如：MAX_SIZE第三章 Java的表达式和
流程
快递问题件怎么处理流程河南自建厂房流程下载关于规范招聘需求审批流程制作流程表下载邮件下载流程设计
控制第三章 Java的表达式和流程控制第一节 操作符和表达式
第二节 语句的分类
第三节 分支语句
第四节 循环语句第 一节 Java的操作符和表达式第 一节 Java的操作符和表达式算术操作符
赋值操作符与复合赋值操作符
位操作符和移位操作符
关系操作符
逻辑操作符
其他操作符
操作符的优先级和结合规则
Java的表达式Java的操作符Java的操作符根据操作对象的个数操作符可分为一元、二元或三元操作符。
根据操作符的功能，又可分为算术、逻辑、关系等操作符。算术操作符算术操作符一元操作符：
+（正） - （负） ++（加1） --（减1）
值得注意的是 ++ 和-- 操作符
如：int a，x=1，y=5；a = ++x；b=y++；
此时a的值为2（先加1，后赋值），b的值为5（先赋值，后加1）。
二元操作符：
+（加） -（减） *（乘） /（除） %（取余）
二元操作符两侧的操作对象数据类型不同时，先自动进行类型转换，再进行操作。赋值操作符与复合赋值操作符赋值操作符与复合赋值操作符赋值操作符
赋值运算符“=”的作用是将一个数据赋值给一个变量
格式
pdf格式笔记格式下载页码格式下载公文格式下载简报格式下载
：变量 = 表达式
“=”两边的操作数的类型应该匹配，如果左操作数精度高于右操作数，Java自动提升右操作数类型使之与左操作数一致，再进行赋值；如果右操作数精度高于左操作数，应使用强制类型转换。
复合赋值操作符
在赋值运算符前加上其他运算符，成为复合赋值运算符
如：x+=20 （等同于x=x+20）
使用复合赋值运算符可使程序更加简练，并且还能提高程序的编译效率。注意：= 与 = = 的不同，Java中赋值用=，比较用==。位操作符和移位操作符位操作符和移位操作符位操作符
&（按位与） |（按位或） ^（按位异或）
移位操作符
E<
>n
右移n位，空位用原最高位的位值补足，相当于E/2n
称为算术右移，能保留原数的符号
E>>>n
右移n位，空位补0
称为逻辑右移关系操作符关系操作符关系操作符有6个：
>（大于） >=（大于等于） <（小于）
<=（小于等于） !=（不等于） = =（相等）
关系操作符的结果为boolean型数据（true或false）。
逻辑操作符有3个：
！（逻辑非） &&（逻辑与） ||（逻辑或）
逻辑操作符的操作对象和结果均为boolean型其他操作符其他操作符其他操作符
条件操作符 E1?E2:E3
表达式E1若成立，执行表达式E2，否则执行E3。
逗号操作符 “,”可用于分隔语句
如 int x,y; for (x=0,y=0;x<10;x++) 在for语句中用“,”分割两个赋值语句
实例操作符 op1 instanceof op2
这里 op1表示一个对象，op2表示一个类，用来判断左边的对象是否属于右边的类，结果为boolean型
操作符的优先级和结合规则
优先级：
一元 〉算术 〉移位 〉关系 〉按位 〉逻辑 〉三元 〉（复合）赋值 〉逗号
结合规则：
除一元、三元和赋值操作符是自右至左结合外，其他均自左至右结合。Java的表达式Java的表达式用操作符把操作对象连接起来的、符合一定规则的式子称为表达式。
表达式的值只有两类：数值和逻辑值
相应的，操作数类型也分为数值型和逻辑型两大类，只有同一大类之间才能进行比较和赋值，否则语法出错。
如表达式 1==true 不合法第二节 语句的分类第二节 语句的分类Java语句按是否改变运行的状态可分为：
执行语句（如表达式语句）
非执行语句（如声明语句）
执行语句按其组成可分三类：
空语句
只有一个语句结束符“；” ，无任何内容。
基本语句（单语句）
独立的、完整的不能再分割为更小的可执行单元。
复合语句（块语句）
包含在{ }内的一条或若干条语句。 Java基本语句的结构Java基本语句的结构可分为四类：
顺序结构语句
分支语句
循环语句
例外处理语句 后三种语句又称为流控制语句。这一章将主要介绍分支语句和循环语句。例外处理语句包括try、catch、finally以及throw语句，是Java所特有的，我们将在后面专门章节介绍。第三节 分支语句第三节 分支语句if-else语句
switch语句
break语句
return语句分支语句提供了一种控制机制，使得程序可以跳过一些语句，转去执行特定的语句。if-else语句（1）if-else语句（1）if-else语句根据判定条件的真假来执行两种操作中的一种
格式：
if (条件表达式)
语句1;
[else
语句2;] - else子句是任选的注意：条件表达式必须是一个返回布尔型数据的表达式。另外，语句1和语句2可以是用{}包含的复合语句。if-else语句（2）if-else语句（2）if-else语句的一种特殊形式为: （用于多分支）
if (条件1){
语句1；
} else if (条件2){
语句2；
}……
}else if (条件N){
语句N；
}注意：else子句必须和if配对使用。else总是与离它最近的if配对。可以通过使用花括号{}来改变配对关系。 switch语句（1）switch语句（1）switch语句是一种多分支选择语句，可根据switch中表达式的值，来执行多个操作中的一个。
格式：
switch (表达式){
case value1: 语句序列1;
break;
…………
case valueN: 语句序列N;
break;
[default: 缺省语句;]
}switch语句（2）switch语句（2）switch中的表达式可以返回任一简单类型的值(如整型、字符型)，该值与每个case子句中的值（一个常量）相比，如果匹配成功，则执行该case子句后的语句序列。
default子句是任选的。当表达式的值与任一case子句中的值都不匹配时，程序执行default后面的语句。如果表达式的值与任一case子句中的值都不匹配且没有default子句，则程序直接跳出switch语句。
break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。注：switch语句的功能可以用if-else来实现，但在某些情况下，使用switch语句更简炼，且程序的执行效率提高。 break语句break语句在switch语句中，break语句用来终止switch语句的执行，使程序从switch语句后的第一个语句开始执行。
循环语句中使用break语句可以退出当前循环。
带标号的break语句
在Java中，一个代码块通常是用花括号{}括起来的一段代码。可以为每个代码块加一个标号。格式为：
标号: {代码块}
break 标号；-- 程序将跳出标号所指定的代码块，并从紧跟该块的第一条语句处执行。return语句return语句return语句用于从当前执行的方法中退出, 并返回到调用该方法的语句处继续执行。
有两种格式:
return 表达式：将表达式的值返回给调用该方法的语句
返回值的数据类型必须与方法声明中的返回值类型一致。
return：不返回任何值
当方法说明中用void声明返回类型为空时, 可以使用这种格式
此类return语句有时可省略第四节 循环语句第四节 循环语句while语句
do-while语句
for语句
continue语句循环语句概述循环语句概述循环语句的作用是反复执行一段代码，直到满足循环终止条件为止。一个循环一般应包括四部分内容：
初始化部分(initialization): 用来设置循环的一些初始条件，计数器清零等。
循环体部分(body): 这是反复循环的一段代码，可以是单一的一条语句，也可以是复合语句。
迭代部分(iteration): 这是在当前循环结束，下一次循环开始前执行的语句，常常用来使计数器加1或减1。
终止部分(termination): 通常是一个布尔表达式，每一次循环要对该表达式求值，以验证是否满足循环终止条件。while语句while语句while语句的一般格式为：
[初始化]
while (条件表达式E){
语句序列S; //循环体
}
当条件表达式E的值为true时，反复执行语句序列S（即循环体）。S中包括了迭代部分。
while语句首先计算条件表达式E是否成立，当条件成立(true)时，才去执行循环中的语句。所以有可能循环体一次也不执行。do-while语句do-while语句do-while语句的一般格式为:
[初始化]
do {
语句序列S; //循环体
} while (条件表达式E);
do-while语句首先执行循环体, 然后再计算终止条件, 若结果为true, 则循环执行语句序列S, 直到条件表达式E的结果为false。
与while语句不同的是, do-while语句的循环体至少执行一次。for语句（1）for语句（1）for语句的一般格式为:
for (初始表达式; 条件表达式; 迭代表达式) {
语句序列S; //循环体
}
for语句执行时，首先执行初始化操作，然后判断条件表达式对应的循环条件是否满足，如果满足，则执行循环体中的语句。最后执行迭代部分。完成一次循环后，重新判断循环条件。
可以在for语句的初始化部分声明变量，它的作用域为整个for语句。for语句（2）for语句（2）for语句通常用来执行循环次数确定的情况(如对数组元素进行操作)。
在初始化部分和迭代部分可以使用逗号语句来分隔多个操作。例如:
for (int i=0,j=10; i＜j; i++,j--) {
……
}continue语句continue语句continue语句用来结束本次循环, 跳过循环体中下面尚未执行的语句, 接着进行终止条件的判断, 以决定是否继续循环。
格式：
continue;
跳过本轮循环尚未执行的语句，开始下一轮循环
continue 标号;
跳到标号指明的外层循环中开始新的一轮循环第一节 Java程序规范——注释第一节 Java程序规范——注释单行注释：从"//"开始到本行结束的内容都是注释
如：//Comment on one line
多行注释：在"/*"和"*/"之间的所有内容都是注释
如：/* Comment on one
or more lines */
文档注释：当程序员编完程序以后，可以通过JDK提供的javadoc命令，生成所编程序的API文档，而该文档中的内容主要就是从文档注释中提取的。该API文档以HTML文件的形式出现，与java帮助文档的风格与形式完全一致。凡是在"/**"和"*/"之间的内容都是文档注释。
如：/** Document
Comment */ 第一节 Java程序规范—块、分号和空白第一节 Java程序规范—块、分号和空白一个语句是以;为终止的代码
totals=a+b+c+d+e+f；
块的使用
一个块是以上括号和下括号为边界的语句集合
{
x=y+1;
y=x+1;
}
一个块可被用在一个类的定义中
块语句可被嵌套
空白：源代码元素之间允许空白，空白的数量不限。空白(包括空格、tabs 和新行)可以改善你的对源代码的视觉感受。第二节 Java的基本符号第二节 Java的基本符号 Java的基本符号包括：关键字、标识符、常量、分隔符和操作符Java的字符集和标识符Java的字符集和标识符字符集
采用一种称为unicode的字符集，该字符集合是一种新的编码
标准
excel标准偏差excel标准偏差函数exl标准差函数国标检验抽样标准表免费下载红头文件格式标准下载
，与常见的ASCII码的区别在于：
unicode使用16位二进制而不是8位来表示一个字符。
unicode字符集中增加了许多非拉丁语字符。
标识符
赋予变量、类和方法的名称
以字母，数字，美元符号"$"，下划线"_"组成，标识符第一个字符不可用数字。
Java语言对字母的大小写是敏感的，在语法中严格区分大小写，但无长度限制Java的关键字Java的关键字关键字
关键字是为特定目的而保留的保留字，Java的关键字有：
abstract boolean break byte case catch char class continue do double else extends false find finally float for implements import instanceof int interface long native new null package private public return short static super switch synchronized this throw true try void while
编程时不要将关键字作为自己的标识符第三节 Java的数据类型第三节 Java的数据类型Java的基本数据类型
Java的变量和常量
数据类型的转换Java的基本数据类型Java的基本数据类型逻辑类 boolean
文本类 char
整数类 byte, short, int, long
浮点类 double, float
第四章 类、对象和接口第四章 类、对象和接口第一节 面向对象程序设计的基本概念
第二节 Java的类
第三节 Java的对象
第四节 Java中面向对象的特性
第五节 抽象类和接口
第六节 内部类
第七节 Java的包第一节 面向对象程序设计的概念第一节 面向对象程序设计的概念面向过程编程 Vs 面向对象编程
对象和类
面向对象程序设计的特点
封装性（Encapsulation）
继承性（Inheritance）
多态性（Polymorphism） 面向过程编程 Vs 面向对象编程面向过程编程 Vs 面向对象编程面向过程编程
传统的程序设计方法，按工作流程来编写程序，比如：Pascal、C
缺点：程序往往缺乏对代码重用的支持，并且缺乏统一的接口，使得当程序的规模达到一定程度时，程序员很难控制其复杂性。
面向对象编程（OOP）
按照现实世界的特点来管理复杂的事物，并把它们抽象为对象，每一对象具有自己的状态和行为，通过对消息的反应来完成一定的任务。
克服了面向过程程序设计方法的主要缺点对象和类对象和类对象
对象是系统中用来描述客观事物的一个实体（如汽车） ，它是构成系统的一个基本单位。
事物的特性就是数据（载客数量、燃料容量、耗油均值），在编程语言中对应变量
事物的行为就是方法（行驶、起动、刹车）
一个对象就是变量和相关的方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。对象和类对象和类类（class）
对象是一个具体的事物，例如每辆汽车都是一个不同的对象。但是多个对象常常具有一些共性，如所有的汽车都有轮子、方向盘、刹车装置等。将一类对象的共性抽象出来，就形成了类。
类中定义了一类对象共有的变量和方法。
把一个类实例化即生成该类的一个对象。 面向对象的程序设计方法就是将客观事物抽象成为“类”，并通过类的“继承”实现软件的可扩充性和可重用性。面向对象程序设计的特点面向对象程序设计的特点封装性
通过封装可以隐藏类的实现细节，也可以避免对类中数据的直接操作。类是封装的基本单元。
继承性
继承是对类的功能的重用和扩充。
多态性
多态性是指方法的名字相同，但实现不同。Java是一种完全面向对象的程序设计语言，具有上述三个特点封装性（Encapsulation）封装性（Encapsulation）封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节
封装的目的是实现数据隐藏
使我们不必关心对象的行为是如何实现的这样一些细节
通过对对象的封装，实现了模块化和信息隐藏，有利于程序的可移植性和安全性，同时也利于对复杂对象的处理。
封装的原则（软件）：要求使对象以外的部分不能随意存取对象的内部数据（属性），从而有效的避免了外部错误对它的"交叉感染"，使软件错误能够局部化，大大减少查错和排错的难度。继承性（Inheritance）继承性（Inheritance）特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。 比如轮船，客轮；人，大人。在java中，通常我们称一般类为父类（superclass，超类），特殊类为子类(subclass)。
通过继承可实现代码的复用，大大减少了程序的工作量。
Java的继承机制 VS C++的继承机制
在C++中支持多重继承，但Java只支持单一继承，即一个子类只能有一个父类。
单继承大大降低了复杂度。
在Java中可通过接口来实现多重继承。多态性（Polymorphism）多态性（Polymorphism）对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。
也就是相同的语言结构，用来表示不同类型的实体或对不同类型的实体进行操作。即“相同的界面，不同的内部实现形式”。
Java通过方法重载(overloading method) 和方法重写(overriding method)来实现多态性。第二节 Java的类第二节 Java的类类的定义
成员变量
成员方法
方法重载
构造方法类的定义类的定义类声明
[public|abstract|final] class className [extends superclassName] [implements interfaceNameList] { …… }
修饰符public,abstract,final 说明了类的属性
className为类名
superclassName为类的父类的名字
interfaceNameList为类所实现的接口列表。
类的定义类的定义类体：类具体实现的部分
类体中定义了该类所有的变量和该类所支持的方法，变量通常在方法前声明。
{[public | protected | private ] [static] [final] [transient] [volatile] type variableName; //成员变量 [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList])
[throws exceptionList] {statements} //成员方法 }成员变量成员变量声明
[public | protected | private ] [static] [final] [transient] [volatile] type variableName;
修饰符
static: 静态变量（类变量）；相对于实例变量
final: 常量
transient: 暂时性变量，用于对象存档
volatile: 贡献变量，用于并发线程的共享成员方法成员方法方法的实现包括方法声明和方法体
[public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList] //方法声明 {statements} //方法体
方法声明中的限定词的含义
static: 类方法，可通过类名直接调用
abstract: 抽象方法，没有方法体
final: 方法不能被重写
native: 集成其它语言的代码
synchronized: 控制多个并发线程的访问
类的定义（例）类的定义（例）class EmpInfo {
String name;
String designation;
String department;
void print() {
System.out.println(name + " is " + designation + " at " + department);
}
}
定义了一个名为EmpInfo的类，类中声明了两三个String型变量name、designation、department，并定义了一个print()方法，通过该方法对输出变量值参数传递参数传递Java通过传值来传递参数
C语言中传递参数有传值和传指针等多种方式，而Java只有传值一种方式，所以Java中实在参数在函数调用中不会被改变。
实在参数是指方法调用时实际给出的参数，而形式参数是指方法声明时给出的参数
当一个对象实例作为一个参数传给方法时，实际传递的参数值是该对象的引用。
在方法调用中，如果传递的参数是一个对象，那么调用前后对象的引用不会改变，而对象的值能够被改变。
参看示例PassTest.java 程序浅析程序浅析对于简单变量，Java通过传值来传递参数，实在参数在函数调用中不会被改变，所以打印的实在参数Val的值仍为11
对于字符串变量str，其实它是一个指向串“hello”的引用，当str作为实在参数传入方法changeStr时，形式参数value开始指向同一个串“hello”，然后通过赋值语句指向另一个串“different”，但实在参数str不会改变
pt是一个当前类的实例（即对象），pt实际上是指向该对象的引用。pt作为实在参数传递给changeObjValue()方法，虽然pt本身不改变，但对象的内容可以改变，所以在对象的成员变量ptValue改变后，打印的值为99.0方法体方法体方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。
方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名，则类的成员变量被隐藏（参见示例VariableTest.java）。
通常Java为所有定义在类中未置初值的类的成员变量预置初值。
变量的分类变量的分类类的成员变量
类中声明的变量称类的成员变量，这些变量声明在类的所有方法之外
类的成员变量的作用域是整个类。
类的成员变量可分为实例变量和类变量两种
类变量是用static关键字说明的变量，除类变量外，其他类的成员变量均为实例变量
局部变量
局部变量定义在方法的内部，其作用域限于方法内，在方法执行时创建，在方法结束时消亡，所以又称临时变量或自动变量。方法重载(overloading method)方法重载(overloading method)同一类中有多个同名的方法，但有不同的实现
方法重载是让类以统一的方式处理不同类型数据的一种手段。
Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但有不同的参数和不同的实现。
调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。
示例MethodOverloadingTest.java注意：Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法。构造方法(constructor) 构造方法(constructor) 构造方法是一个特殊的方法。Java 中的每个类都有构造方法，用来初始化该类的一个对象
构造方法具有和类名相同的名称，而且不指出返回任何数据类型，它的缺省返回类型就是对象类型本身
构造方法只能由new运算符调用
如果在类中没有明确地给出一个构造方法，java就会自动构造一个缺省的、不带参数的构造方法（称为default constructor）并执行
事实上，这个缺省的构造方法是通过调用其父类的构造方法来实现的
Java支持构造方法的重载
示例PointCreate.java第三节 Java的对象第三节 Java的对象对象的生成
对象的使用
对象的清除类和对象的关系类和对象的关系类是对象的
模板
个人简介word模板免费下载关于员工迟到处罚通告模板康奈尔office模板下载康奈尔 笔记本 模板 下载软件方案模板免费下载
，也是对象的原型。类通过new操作符生成的实例就是对象。
通常通过类来创建该类的实例（即对象），然后在实例上工作。
一个对象的生命周期包括生成、使用和清除。对象的生成对象的生成对象的生成包括声明、实例化和初始化。 type objectName=new type([paramlist]);
声明：type objectName
声明并不为对象分配内存空间，而只是分配一个引用空间
实例化：运算符new为对象分配内存空间，它调用对象的构造方法，返回引用；一个类的不同对象分别占据不同的内存空间
生成：执行构造方法，进行初始化；根据参数不同调用相应的构造方法
举例
Student s=new Student（”小张”,”22”,”清华大学”）；对象的使用对象的使用通过运算符“.”可以实现对变量的访问和方法的调用。变量和方法可以通过设定访问权限来限制其它对象对它的访问
调用对象的变量：objectReference.variable
调用对象的方法：objectReference.methodName([paramlist]); 对象的清除对象的清除当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。 内存垃圾回收内存垃圾回收Java的内存管理机制与C、C++不同
C、C++的内存资源由使用者（程序员）来释放
而Java系统具有自动 “内存垃圾回收”机制
当对象不再被引用时，Java将自动回收并释放该对象使用的内存
Java系统中有一个名为gc(Garbage Collector)的线程，该线程会在系统空闲时自动运行，销毁不再使用的对象，收回对象所占用的内存资源
当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行第四节 Java中面向对象的特性第四节 Java中面向对象的特性封装性
继承性
多态性
其他Java中的封装性Java中的封装性在Java语言中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的状态，方法表明了对象具有的行为。通过对象的封装，实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限，实现了类中成员的信息隐藏。 Java的封装性Java的封装性类的定义
class className { [public | protected | private ] [static] [final] [transient] [volatile] type variableName; //成员变量
[public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList] {statements} //成员方法 } Java的封装性Java的封装性Java类和方法中的限定词提供了不同的存取控制权限（访问权限）
存取控制权限的含义
一个类A能存取另一个类B意味着
能建立类B的实例
能继承类B
能存取类B中的方法和变量 Java的封装性Java的封装性Java类中的限定词
private
类中限定为private的成员，只能被这个类本身访问
如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例
default
类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问
protected
类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问
public
类中限定为public的成员，可以被所有的类访问Java中类的限定词的作用范围比较 Java中类的限定词的作用范围比较 X 表示有存取权限Java中的继承性Java中的继承性类继承的目的是以原有的类为基础创建新的类，从而达到代码复用的目的。
被继承的类称为父类。从父类派生出来的新类称子类。
子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量
Java只支持单重继承，不支持多重继承，所以一个类只能有一个父类。Java中的继承性Java中的继承性创建子类
class SubClass extends SuperClass { … }
成员变量的隐藏：将父类的状态转变换为自身的状态Java中的继承性Java中的继承性方法重写（overriding method）：将父类的行为转变为自身行为
在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
举例SubClassTest.java注意：子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同。Java中的继承性Java中的继承性super: Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。
访问父类被隐藏的成员变量，如：super.variable;
调用父类中被重写的方法，如： super.Method([paramlist]);
调用父类的构造函数，如：super([paramlist]);
示例Inheritance.javaJava中的多态性Java中的多态性编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
——方法重载
运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。——方法重写
重写方法的调用原则：java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。
示例Dispatch.java其他面向对象的属性其他面向对象的属性final关键字
使用final关键字修饰的类不能被其他类所继承
一个类用final 限定，往往是出于安全方面的考虑，比如java.lang.String，就是一个这样的类。
用final关键字修饰的方法不能被重写
一个方法用final限定，主要也是基于安全方面的考虑，有时，方法的实现不想被外界改变，可用final限定。
变量前如使用final关键字修饰，该变量相当于常量，其值不能被修改。
习惯上变量名全用大写，单词间区分用下划线
定义时必须预置初值其他面向对象的属性其他面向对象的属性实例成员和类成员
用static 关键字可以声明类变量和类方法，如果在声明时不用static 关键字修饰，则声明为实例变量和实例方法。
实例变量 vs 类变量
每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。
类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，无需先生成一个实例对象。其他面向对象的属性其他面向对象的属性实例成员和类成员
实例方法 vs 类方法
实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用
类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字
示例MemberTest .java其他面向对象的属性其他面向对象的属性类java.lang.Object
类java.lang.Object处于java开发环境的类层次的根部，其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。
常用方法
equals() ：比较两个对象(引用)是否相同
getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息
toString()：用来返回对象的字符串表示
finalize()：用于在垃圾收集前清除对象
notify(),notifyAll(),wait()：用于多线程处理中的同步。 第五节 抽象类和接口第五节 抽象类和接口抽象类
接口抽象类抽象类用abstract 关键字来修饰一个类时，这个类叫做抽象类
abstract class abstractClass{ …}
用abstract 关键字来修饰一个方法时，这个方法叫做抽象方法。 abstract returnType abstractMethod([paramlist])抽象类的特点抽象类的特点抽象类必须被继承，抽象方法必须被重写
抽象方法只需声明，无需实现
抽象类不能被实例化
抽象类不一定要包含抽象方法。若类中包含了抽象方法，则该类必须被定义为抽象类。抽象类的实例生成抽象类的实例生成public abstract class Drawing {
public abstract void drawDot(int x,int y);
public void drawLine(int x1,int y1,int x2,int y2) {
… //drawLine方法的具体实现
}
}
public class MachineDrawing extends Drawing {
public void drawDot(int x,int y) {
// Draw the dot
}
}
可以将MachineDrawing的实例赋值给抽象类Drawing的变量d
Drawing d = new MachineDrawing();接口接口接口是抽象类的一种，只包含常量和方法的定义，而没有变量和方法的实现，且其方法都是抽象方法。
接口的用处
通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系
通过接口指明多个类需要实现的方法
通过接口了解对象的交互界面,而无需了解对象所对应的类。 接口的定义接口的定义接口的定义包括接口声明和接口体。 [public] interface interfaceName [extends listOfSuperInterface]
//接口声明
{ … } //接口体
extends 子句与类声明的extends子句基本相同，不同的是一个接口可有多个父接口，用逗号隔开，而一个类只能有一个父类。接口的定义接口的定义接口体包括常量定义和方法定义
常量定义格式为：type NAME=value
该常量被实现该接口的多个类共享; 具有public ,final, static的属性。
方法体定义格式为：(具有 public和abstract属性) returnType methodName([paramlist])； 接口的特点接口的特点接口是从抽象类变化来的，所有接口中定义的方法均是抽象方法。
所以接口也不能用new操作符直接生成自己的实例。
接口中的方法只能被声明为public和abstract，如果什么也不声明，则默认为public abstract，接口内的变量也只能被public,static和final三者限定，如果什么也不声明，则默认为public static final。
通过接口可实现类的多重继承。
Java中
规定
关于下班后关闭电源的规定党章中关于入党时间的规定公务员考核规定下载规定办法文件下载宁波关于闷顶的规定
类的继承只能是单继承，即一个类只能有一个父类。但一个类可继承多个接口，即继承多个接口中声明的方法。接口的例子接口的例子public interface Transparency {
public static final int OPAQUE=1;
public static final int BITMASK=2;
public static final int TRANSLUCENT=1;
public int getTransparency(); //缺省为abstract
}
在接口Transparency中，定义了三个类变量和一个抽象方法getTransparency()。实施接口实施接口类使用implements关键字来继承接口，在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法。一个类可以实现多个接口,在implements子句中用逗号分开。一般我们更倾向使用“实施”某个接口的说法。
在下面的例子中，类MyApplet继承了Applet类，并实施了Runnable和MouseListener两个接口。
public class MyApplet extends Applet
implements Runnable,MouseListener {
// ………
}
要注意的是，一个类实施了某一接口，就必须实现该接口中声明的所有方法。这些方法都要被说明为public，否则会产生访问权限错误。实施接口的例子实施接口的例子interface SayHello {
public void printMessage();
} //定义了接口SayHello
class SayHelloImpl implements SayHello {
public static void main(String args[]) {
SayHelloImpl aa = new SayHelloImpl();
aa.printMessage();
}
public void printMessage() {
System.out.println("Hello");
}
} //类SayHelloImpl实施了SayHello接口，并实现了抽象方法printMessage()接口的使用接口的使用接口作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中，通过这些变量可以访问类所实现的接口中的方法。 接口的继承和适用场合接口的继承和适用场合接口也可以继承，并可以有多个父接口，在继承时，父接口传递给子接口的只是方法的说明，而不是具体实现。这在一定程度上消除了完全的多继承所带来的复杂性。
接口通常用于以下场合：
定义一个和多个类均需实施的方法。
在不相关的类中提取它们的共同特点而不需强制它们之间有继承关系。
定义类似函数的对象，这些对象能作为参数传给其他对象中的方法。
给出对象的编程接口而不给出其具体实现，这在协作开发中很有用。 第六节 内部类第六节 内部类内部类的定义和使用
内部类的优缺点 内部类的定义和使用内部类的定义和使用内部类是在一个类的内部嵌套定义的类，它可以是其它类的成员，也可以在一个语句块的内部定义，还可以在表达式内部匿名定义
内部类也称为嵌套类，是JDK1.1后才有的。可以用嵌套类联系两个逻辑上相关的类，定义格式如下
class EnclosingClass{
// ………
class ANestedClass { //该类为嵌套类
// …………
}
}内部类的特性内部类的特性一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称.名字不能与包含它的类名相同
可以使用包含它的类的静态和实例成员变量,也可以使用它所在方法的局部变量
可以定义为abstract，也可以声明为private或protected
若被声明为static,就变成了顶层类,不能再使用局部变量
若想在Inner Class中声明任何static成员,则该Inner Class必须声明为static
举例TwoListenInner .java
内部类MouseMotionHandler用来处理鼠标移动事件
内部类MouseEventHandler 用来处理鼠标点按事件内部类的优缺点内部类的优缺点优点:节省编译后产生的字节码文件的大小
缺点:使程序结构不清楚 第七节 Java的包(package)第七节 Java的包(package)包(package)是类的逻辑组织形式。Java使用包将相关的类组织起来。
有两类包：
系统包
Java系统预定义好的包，包含在系统类库中
用户自定义包
用户自己定义的包
package的命令规则是层次型的，中间用“.”分割。
如：java.lang.Object 系统包系统包系统包包含在Java类库中，每个包中都有大量与某一主题相关的系统类，可供编程使用。
java常用的包有：
java.lang 基础包
java.util 实用工具包
java.awt 抽象窗口工具包
java.text 文本包
java.io 输入输出包
java.applet Applet包
java.net 网络功能包
…..Import语句Import语句当使用包时，你可以使用import语句来告诉编译器到哪里去找相应的类。如：
import java.io.*;
public class Example{
FileReader fl = new FileReader("abc.txt");
……
}
若不用import语句，编译器就无法知道到哪里去找FileReader这个类，除非在程序中使用包含包前缀的完整类名，如java.io.FileReader。
java.lang.*是系统自动import 的，所以该包中的String等类可直接使用。 用户自定义包用户自定义包用户可使用package语句自己来定义包。
包定义必须放在源文件的开头。每个源文件只能有一个包定义语句。定义在源文件中的所有类均属于这个包。例：
package myPackage;
public class Employee{
……
} //类Employee定义在包myPackage中
通过 包名.类名 来引用包中的类
习惯上，package名用小写字母。为了避免package的重名，Sun推荐这样一套命名模式：即将URL地址反过来，再加包名。如：cn.edu.ecnu.cs.ym.myPackage第五章 例外处理第五章 例外处理第一节 例外的概念
第二节 例外对象类型
第三节 例外处理机制
第四节 用户自定义例外第一节 例外的概念第一节 例外的概念例外（Exception）
例外又称异常。在Java中，它定义了程序运行中可能遇到的轻微错误或异常情况。
如发生下列情况时均会产生异常：
要打开的文件并不存在。
网络连接不可用。
进行操作的操作数超越了指定的边界。
需要载入的类或类文件未找到。
当发生例外时，如果不进行处理，系统往往会终止运行。程序员可以通过自己编写有针对性的代码来对它进行处理，以让程序继续运行下去。异常的一个例子异常的一个例子该程序在运行时会产生一个例外并终止。产生的例外是：java.lang. ArrayIndexOutOfBoundsException。这是因为while循环中当i=3时下标已超出了允许的范围。Java的例外处理机制Java的例外处理机制在Java程序的执行过程中，如果出现了异常事件，就会生成一个例外对象。生成的例外对象将传递给Java运行时系统，这一例外的产生和提交过程称为抛弃(throw)例外。
Java的例外处理机制将例外处理与正常的程序流分开，两者的代码相隔离，可使程
浙公网安备 33021202002483