Java程序设计基础

本导图介绍了Java程序设计语言的基础原理和程序编写规则，适合对程序开发感兴趣的朋友和Java程序设计语言入门者参考使用。

Java

• 基础原理
  • Java程序设计基础
    • Java程序与运行
      • Java语言的特征
        • Java语言是一个简单的、面向对象的、分布的、解释（执行）的、健壮的、安全的、独立于平台的、可移植的、可扩展的、高性能的、多线程的以及动态的程序设计语言
      • Java的编译
        • 
      • Java的运行
        • 
      • Java虚拟机
        • 定义
          • 运行Java程序的支持系统，用于解释Java字节代码并执行代码所要完成的操作。
        • Java虚拟机与Java解释器
          • Java虚拟机针对特定CPU或操作系统时称为Java解释器
          • 对于不同的操作系统或CPU，Java解释器不同但Java虚拟机功能相同——平台无关性
        • 组成
          • 一组指令集
          • 一组寄存器
            • Java语言程序计数器pc
            • 指向操作数顶端的指针optop
            • 指向当前执行方法的执行环境指针frame
            • 指向当前执行方法局部变量区首个变量的指针var
          • 一个堆栈
            • 通过堆栈处理数据传递，不定义和使用寄存器传递参数
            • 分区
              • 局部变量区
              • 执行环境区
              • 操作数区
          • 一个无用内存单元收集器
          • 一个方法区域
      • Java语言应用程序
        • Application应用程序
          • 由Java虚拟机支持运行
        • Applet小程序
          • 由嵌入了Java虚拟机的Web浏览器支持运行
      • Java字节代码
        • 即Java语言指令集
        • 每条指令含有一个操作码，0个或多个操作数，操作码为1个字长，操作数无限制
      • Java编译单元
        • 源程序代码是由一个或多个编译单元组成的
        • 每个编译单元包含
          • 一个程序包语句（package statement）
          • 一组导入语句（import statements）
          • 一个或多个类的声明语句（class declarations）
          • 一个或多个接口声明（interface declarations）
        • 每个编译单元最多只能有一个类或者接口是公共的
        • 编译单元以公共的类或接口名为文件名，后缀.java
    • Java程序的开发
      • Java语言程序开发平台
        • J2EE
          • 网络中服务器端Java程序的开发并兼做程序运行平台
        • J2SE
          • 一般计算机的Java语言程序的开发兼做程序运行平台
        • J2ME
          • 消费类电子产品中嵌入式系统Java语言程序开发兼程序运行平台
        • JavaCard
          • 智能IC卡的Java语言程序开发兼做程序运行平台
      • Java程序基础开发运行平台——J2SDK
        • 基本编译器
        • 实用工具
        • 运行环境JRE
          • Java虚拟机
          • Java API（用于开发运行Application和Applet程序的API）
            • 基础类库
            • 工具类库
      • 在windows中搭建Java程序开发运行环境
        • javac.exe
          • 编译
        • java.exe
          • 运行Java程序
        • javadoc.exe
          • 生成帮助文档
        • appletviewer.exe
          • 运行Java Applet小程序
        • jar.exe
          • 将多个Java类文件压缩成一个jar
      • Java程序的编译与运行
        • 上机作业内容
    • Java语言的标识符和关键字
      • Java注释语句
        • 一行注释符 //
        • 一行或多行注释符 /* */
        • Java文档注释符 /** */
      • Java标识符
        • 以英文大写字母“A”～“Z”或小写字母“a”～“z”或“_”或“$”开头，后面可以跟包含英文字母和数字0～9的字符，区分大小写
      • Java关键字
        • 
          • 定义数据的关键字
            • boolean 布尔量 byte 字节量 char 单字符 double 双字浮点量 float 单字浮点量 int 整型量 long 长整型量 short 短整型量 Void 无类型
            • 类型名 变量宽度(Bits) 变量取值范围 byte short int long Float double char boolean 8 16 32 64 32 64 16 1 -128～127 -32768～32767 -2147483648～2147483647 -9223372036854775808～9223372036854775807 -3.4e-38~+3.4e+38 -1.7e-308~1.7e+308 Unicode0~ Unicode212-1 false true
          • 编程关键字
            • 
          • 表达式关键字
            • 算术： + - ++ -- * / % = += -= *= /=
            • 逻辑： ! ～ << >> < > <= >= == != & | ^ && || &= |= ^=
          • 操作符关键字
            • . 引用 [ ] 下标（指针） ( ) 转换 , 分隔
          • 修饰符关键字
            • abstract 抽象的 final 最终 finally 最终的 private 私有 protected 保护 public 公共 static 静态 synchronized 同步 void 无返回值
          • 最重要的关键字
            • 
    • Java基本数据类型
      • 数据值的表示法
        • 整数表示法
          • 进制
            • 十
            • 八
              • 0
            • 十六
              • 0X
        • 浮点数表示法
          • 形式
            • 十进制
            • 科学计数法
          • 特殊值
            • Infinity
            • -Infinity
            • -0.0
            • NaN
        • 布尔数表示法
          • true
          • false
          • 不对应任何数值
        • 字符数表示法
        • null值
          • 可赋给除基本数据类型外的其他类型变量
          • 当一个变量无用时给它赋予null值，让它消失
      • 变量
        • 整型变量
          • byte
          • short
          • int
          • long
        • 浮点型变量
          • float
          • double
        • 布尔型变量
          • boolean
        • 字符型变量
          • char
        • 基本数据类型变量的默认值
          • boolean
            • false
          • char
            • '\u0000'(null)
          • byte
            • 0
          • short
            • 0
          • int
            • 0
          • long
            • 0L
          • float
            • 0.0f
          • double
            • 0.0d
      • 变量的数据类型转换
        • 自动类型转换
          • 自动类型转换的原则是从在计算机中占内存位（bit）数少的类型向占位数多的类型方向进行转换（除了boolean类型）
        • 强制类型转换
          • 强制类型转换是指从在计算机中占内存位（bit）数多的类型向占位数少的类型方向进行转换
          • 使用
            • 除Boolean外的基本数据类型之间
            • 有继承关系的复合数据类型
      • 常量
        • 常量定义是“不变的变量”，或是“具有最终值的变量”
        • 当用Java关键字final（最终的）修饰声明的变量，同时又为变量赋予确切的数值时，该变量即被声明为常量
    • Java运算符和表达式
      • Java运算符
        • （1）算术运算符：+、-、*、/、%、++、-- （2）逻辑（布尔）运算符：!、&&、|| （3）关系（比较）运算符：＞、＜、＞=、＜=、==、!= （4）位（按位操作）运算符：&、|、^、～、＞＞、＜＜、＞＞＞ （5）赋值、扩展赋值、条件赋值运算符：=、+=、*=、&=、%=、…、?: （6）其他算运算符：.、[ ]、( )、,、new、instanceof
        • 运算符功能
          • ^
            • 按位异或
          • ~
            • 按位取反
          • >>
            • 右移（带符号）
          • <<
            • 左移（带符号）
          • >>>
            • 填零右移（无符号右移）
          • ？：
            • 条件赋值
        • 运算符优先级
          • 同其他语言
      • Java表达式
        • 单操作数运算（单目运算）
        • 双操作数运算（双目运算）
        • 三操作数运算（三目运算）
      • 表达式中运算符的使用规则
        • 算术运算符
          • d/0=Infinity
          • d/Infinity=0
          • 0/0.0=NaN
        • 逻辑运算符
        • 关系运算符
          • NaN无法比较大小和赋值
        • 位运算符
        • 赋值运算符
    • Java程序流控制语句
      • 分支结构语句
        • if-else
        • switch-case
      • 循环结构语句
        • for
        • while
        • do-while
      • 辅助流控制语句
        • break
        • continue
        • 可带标号
        • return
          • 退出方法并返回一个值
  • 面向对象编程
    • 面向对象程序设计
      • 面向对象的程序设计方法
        • 介绍
          • 使用软件对象表示现实世界中的对象
          • 软件对象是以现实世界中的对象为模型来描述它们的状态（对象属性特征特性）和行为（操作）
          • 状态
            • 数据常量和变量
          • 行为
            • 表达式、流控制结构等实现的数学模型
        • 优点
          • 提高代码重用性
          • 简化了应用软件的设计开发和维护
      • Java面向对象的程序设计
        • 通过类描述对象
        • 类
          • 量
            • 描述对象状态（属性）
          • 方法
            • 描述对象行为（操作）
          • 封装继承多态
    • Java类
      • Java类的定义
        • 类=数据+操作
        • 定义
          • [modifier] class className [extends SuperClass implements Interface]{ private: protected: public: }
        • 类名与文件名
          • 一个Java源文件中可以有多个类，但只能有一个public类，并且public类名必须和文件名一致
          • 一个文件中可以只有非public类，如果只有一个非public类，此类可以跟文件名不一样
        • 成员变量和局部变量
          • 在同一范围内不能定义两个同名变量
          • 类成员变量名可以和某方法名字相同，也可以和局部变量的名字相同
      • 方法的定义
        • 位置
          • 可以在类和接口中声明
          • 方法只能在类中实现
        • 类中普通方法的定义
          • [modifier] [static] ReturnType methodName ([parameterList]) {//方法体 }
          • static方法
            • 声明为static的变量和方法在程序被执行期间常驻内存
            • 修饰为static的方法调用的该方法外的变量或其他方法也应该是static的
        • 类构造方法的定义
          • public methodName([parameterList]){ //方法体 }//通常构造方法是public的
          • 名字与类名相同，无返回类型
          • 私有化构造方法通常用于单例设计模式
        • main方法的定义
          • public static void main(String[] args){ //方法体 }//语法格式固定，程序入口方法
      • Java修饰符及其权限
        • public
          • 可以被所有的类继承和访问
        • protected
          • 包内的任何类及包外那些继承了该类的子类可以访问
            • protected修饰符的修饰的成员变量和方法也称为受保护的成员变量和方法， 受保护的成员变量和方法可以在本类或同一个包中的其它类（包括子类）中通过类的实例进行访问，也可以被同一个包中的类或不同包中的类继承，但是不能在不同包中的其它类（包括子类）中通过类的实例进行访问。
        • default
          • 可以被同一个包中其他类继承和访问
        • private
          • 只能被同属类的其他成员访问
        • 总结
          • 访问级别 访问控制修饰符 同类 同包 不同包子类 不同的包 公开 public √ √ √ √ 受保护 protected √ √ √ -- 默认 没有访问控制修饰符 √ √ -- -- 私有 private √ -- -- --
    • Java对象
      • 对象的创建
        • 声明类变量
          • ClassName ObjectName
        • 创建对象
          • ObjectName=new ClassName()
        • 两步结合
          • ClassName ObjectName=new ClassName()
      • 构造方法的使用
        • 构造方法只能在创建对象时调用一次，不能被其他方法调用
        • Java虚拟机调用类的构造方法完成为对象分配其所占有的存储器空间，同时初始化对象
        • 一个类可以定义多个构造方法
      • 对象的使用
        • 访问对象变量
          • objectReference.variable
        • 调用对象方法
          • objectReference.methodName([paramlist(...)])
      • 对象的清除
        • Java的“无用单元自动收集器”自动扫描对象的动态内存区，对被引用的对象加标记，将没有引用的对象作为垃圾收集起来并且释放
        • 释放内存是系统自动处理的，收集器使得系统内存的管理变得更简单安全
      • Java类和对象的关系
        • 类是用来定义对象的状态和行为的模板，对象是类的一个具体实例
        • 类是描述现实世界的蓝图，对象是现实世界的电子模型，对象是根据类创建出来的
    • 数组对象
      • 一维数组的声明和创建
        • 声明
          • [modifier] type[] arrayName
        • 创建
          • arrayName=new type[arrayLength]
        • 两步结合
          • [modifier] type[] arrayName=new type[arrayLength]
      • 多维数组的声明和创建
        • 声明
          • [modifier] type[][] arrayName
        • 创建
          • arrayName=new type[arrayLength0][arrayLength1]
        • 两步结合
          • [modifer] type[][] arrayName=new type[arrayLength0][arrayLength1]
  • Java类的继承与多态
    • Java类的继承
      • 概念和语法
        • 概念
          • 对已有的类加以利用，并在此基础上为其添加新功能的一种方式。
        • Java类继承特点
          • 单一，链
            • 继承不仅是继承直接父类，父类包括所有直接或间接被继承的类，一直延续到Object类
          • 完全继承
            • 一个类继承了父类的所有成员变量和成员方法。
        • 语法
          • [modifer] class SubClassName extends SuperClassName{ ... }
        • 注意
          • Java所有的类都有父亲，若没有用extends指明，默认父类为Object类
        • Object类
          • Object类是java.lang基础包的一个类，被称为根类。Java体系中所有的类最终的父类就是Object类，即Java体系中所有的类都是Object类的子类。
        • 创建顺序
          • 根类——父类——子类
        • 父子关系
          • 所有父类对象的引用都是通过子类对象实现的，就好像所有父类中的成员变量和方法都包含在子类中一样
          • 类的继承允许子类使用父类的变量和方法，如同这些变量和方法是属于子类本身的
          • 类的继承有权限：子类可以继承父类中访问权限为public和protected的变量和方法，不能继承访问权限为private的变量和方法
      • Java类继承关系测试
        • 语法
          • [boolean b]=oneObj instanceof ClassName;
        • 功能
          • 判断oneObj对象是否为ClassName类（或它的父类）的一个实例
      • 隐藏、覆盖和重载
        • 注意
          • 隐藏、覆盖和重载针对非private成员变量和方法，因为private不被继承到子类中
        • 类型
          • 隐藏
            • 成员变量隐藏
              • 当子类中声明与父类成员变量具有相同变量名的变量时实现对父类成员变量的隐藏
            • 静态成员方法隐藏
              • 静态成员方法
              • 相同方法名
              • 相同输入参数列表和返回类型
          • 覆盖
            • 概念
              • 相同方法名
              • 相同输入参数表、返回值和访问权限
              • 仅方法体不同，子类中重新编写方法实现新功能
            • 与隐藏的区别
              • 父类中被隐藏的方法在子类中完全不可用，父类中被覆盖的方法可以通过其他方法引用
              • 覆盖常被用于对接口中声明的方法的实现
          • 重载
            • 位置
              • 子类与父类之间
              • 同一个类中
            • 概念
              • 相同方法名
              • 相同访问权限
              • 返回类型可以不同
              • 输入参数表要有不同（参数类型、个数、顺序）
              • 相当于定义新方法
      • 构造方法的重载
        • 默认构造方法
          • 当一个类没有定义构造方法时，其创建的类对象调用无任何操作的默认构造方法
          • 无参数列表的构造方法
        • 重载
          • 若父类的构造方法多于一个且有默认构造方法，应用子类创建类对象时先创建的父类对象使用父类中的默认构造方法
          • 若父类没有默认构造方法，在继承该父类时需要显式调用父类的某一个非默认构造方法实现父类对象的创建
    • abstract和final修饰符
      • abstract修饰符
        • 抽象类
          • 抽象类不可使用，不能建立抽象类的对象，抽象类只能作为父类应用。
          • 抽象类中抽象方法是没有方法体的空方法。abstract修饰方法时不与static、private、final同时使用
        • 使用
          • 修饰类
          • 修饰方法
            • 只能修饰抽象类中的方法
        • 语法
          • abstract class abstrctClass{ ...; abstract ReturnType methodName(parameterList); }
      • final修饰符
        • 终态类（叶子类）
          • 终态类不允许被其他的类继承，不能作为父类
        • 使用
          • 修饰类
            • 该类不能被继承
          • 修饰方法
            • 该方法不能被覆盖（static和private也有类似作用）
          • 修饰变量
            • 该变量为常量
        • 语法
          • final class finalClass{ final variableName[=initializationValue;] final ReturnType methodName(parameterList); }
    • this和super变量
      • this变量
        • 概念
          • 可作为当前对象使用，其访问变量和调用方法的作用域为整个类
        • 语法
          • this.variableName [methodName([parameterList])][expression];
        • 注意
          • this变量不能用在静态方法体中，因为this不是静态变量
      • super变量
        • 概念
          • 可作为当前类的父类对象来使用，访问父类非private变量，调用父类非private方法
        • 语法
          • super.variableName[methodName([parameterList])][expression];
        • 用途
          • super变量实现了访问在父类中被隐藏的变量，调用被覆盖的方法
          • 在子类的构造方法中调用直接父类的构造方法
            • super([parameterList]);
    • Java的多态性
      • 多态的概念
        • 多态
          • 一个对象的行为方式可以有多种不一样的操作形态，根据对象的不同进行不同的操作。
        • 绑定
          • 概念
            • 多态是与对象关联的，这种关联就是绑定。
          • 分类
            • 静态绑定
              • 编译时完成
            • 动态绑定
              • 程序运行时完成
        • 上塑造型
          • 将子类对象类型作为创建父类对象的基本对象类型
      • 多态的应用
      • 构造方法与多态
  • Java接口和Java包
    • Java接口
      • 接口的定义
        • 接口是一些抽象方法和固定变量（一定是常量）的集合
        • 语法
          • [modifer]interface InterfaceName[extends OtherInterfaceName]{ ... }
        • 接口和类
          • 接口和类都可以作为一种复合数据类型来声明，当接口作为类型时，其行为和类作为类型完全一样
          • 接口不能被修饰为private
          • 接口中的数据只能是常量，需要赋初值，常量只能是public(默认)/static和final
          • 接口中的方法只有声明，无方法体，即使无显式声明，也只能被修饰为public(默认)，一定是abstract
      • 接口的实现
        • 接口需要由一个类实现(继承)后方可使用
        • 语法
          • [modifer] class OneClass implements OneInterface { [modifer] returnType OneMethod([parameterList]) { …； // 编写方法体 } }
        • 一个类可以实现多个接口
      • 接口的继承
        • 与类的继承相同，但可以多重继承
        • 语法
          • [modifer] interface oneInterface extends Interface1,Interface2,…,InterfaceN{ …; // 定义新增加的接口成员 }
      • Java类同时继承父类并实现接口
        • 子类继承一个父类的同时，还可以实现多个接口
      • 接口与Java抽象类
        • 接口指示“做什么”，不关心“怎么做”，具体怎么做需要通过实现的类完成
        • 接口自动被修饰为abstract
        • 接口中的数据成员自动修饰为final，必须赋初值，抽象类中的数据成员不需要
        • 接口中所有方法自动定义为抽象方法而抽象类中既可以定义一般方法也可以定义抽象方法
        • 抽象类可以实现一个或多个接口，既可以覆盖接口中的方法，也可以不覆盖
      • 接口的应用
    • Java包
      • package语句
        • 包由一些类和接口组成
        • 语法
          • package packageFirstName[.packageSecondNAME...packageNoName]
        • 同一个包内所有类和接口不可重名
        • Java的应用程序类库是以包的形式提供的，按照功能和用途分为不同的包
        • package语句放在Java编译单元的第一行且只能有一条
        • 没有package语句的Java编译单元中的类和接口不属于任何包，不能被其他Java程序引用
      • Java包与路径
        • 包名采用树形结构，树根与树叶是由.分割，正好与计算机操作系统对磁盘文件目录的树形管理相一致
      • import语句
        • 导入一个包中类和接口到当前编译单元
        • import packagename.ClassName;
        • import packagename.*;
      • 直接引用Java包中的类和接口
        • packagename.ClassName objname=new packagename.ClassName
      • Java包的应用
        • 建议使用*.jar文件形式为用户提供其应用程序和类库
        • Java语言为方便程序提供了大量的类库
          • 最基础的类库为java.lang包，此包已嵌入Java虚拟机，不用导入直接用
          • 使用其他Java语言类库时需要import引入
        • 一个类通过包被引入后，还可以通过继承的方式被应用
  • Java异常处理
    • Java异常处理机制
      • 异常的类型
        • 程序逻辑错误
          • 没救
        • 程序控制操作错误
          • 不可控
            • 例如Java虚拟机产生错误
          • 可控
            • 可以做异常处理
      • 异常处理机制
        • 传统设计语言处理模式
          • 设计主体逻辑的同时考虑到可能出现的错误（逻辑复杂、错误信息不准确）
        • 面向对象语言异常处理机制
          • 规范化的异常处理接口（将处理异常的代码与常规代码分离）
      • Java的异常处理
        • 方式
          • 在程序运行时捕获已知可能发生的异常并对异常进行处理
          • 传播异常（抛出）
          • 人为处理
        • Java中每个异常都是一个对象，属于类Java.lang.Throwable
          • 派生类
            • Java.lang.Error严重错误，程序中断
            • Java.lang.Exception可处理的（捕获/抛出）
    • Java异常的捕获与处理
      • try{ //开始检测出现的异常 //可能引发异常的Java语句 //正常逻辑功能代码 } catch(SomeException se){ SomeException类型的异常对象，参数唯一 //对产生的se异常进行处理 //也可无程序代码（忽略异常） }
      • try { // 开始检测出现的异常 …； // 可能引发异常的Java语句 } catch(OneException oe) {// 捕获OneException类型的异常 …； // 对产生的oe异常进行处理 } catch(AnotherException ae) {// 捕获AnotherException类型的异常 …； // 对产生的ae异常进行处理 } catch(ElseException ee) {// 捕获ElseException类型的异常 …； // 对产生的ee异常进行处理 }
      • try { …； } catch(SomeException se) { …；//可以没有catch语句，也可有多个 } finally{ // 完成try-catch的结尾工作 …； // 清除异常，或结束时的操作 }
      • n当try和catch语句中有return、continue、break等分支语句时，Java虚拟机在转移程序执行流程之前总是执行完finally语句中的程序代码后才执行分支操作
    • Java异常的抛出
      • 语法
        • public void SomeMethod() throws OneException,AnotherException { …; // 可能会产生OneException或 AnotherException类型异常 }
      • 补充
        • 将异常抛给上一级方法
        • 不能通过更改方法抛出异常类型实现方法重载
    • Java基础包中定义的常用异常类
      • Throwable：异常根类
        • 
      • Exception：可处理异常类
        • 
      • Error：不可处理异常类
        • 
      • 继承关系
        • 
        • 
      • Java.lang包中的异常类
        • 
        • 
        • 
        • 
    • 自定义异常类
      • n自定义异常类与定义普通类是一样的，但是为适应Java异常处理机制，自定义异常类需要继承Throwable类或Throwable类的子类
      • 
      • 创建并抛出自定义异常对象语法
        • 
      • 传播异常的语法格式
        • 
  • Java基础类的应用
    • Java基础包
      • java.applet：创建applet小程序所需要的类
      • java.awt：包含用于创建用户界面和绘制图形图像的所有类
      • java.beans：包含与开发beans有关的类
      • java.io：提供与输入输出相关的类
      • java.lang：提供Java语言程序设计的基础类
      • java.net：提供实现网络操作的类
      • java.nio：为输入和输出操作提供缓冲区的类
      • java.text：提供处理文本、日期、数字和消息的类和接口
      • java.util：提供处理日期、时间、随机数生成等各种实用工具的类
      • javax.net：提供用于网络应用程序的类
      • javax.swing：提供一组与AWT功能相同的纯Java的组件类
    • java.lang包
      • Boolean：封装了一些boolean类型的值以及一些操作该类型的方法
      • Byte：封装了一些byte类型的值以及一些操作该类型的方法
      • Character：封装了一些char类型的值以及一些操作该类型的方法
      • Double：封装了一些double类型的值以及一些操作该类型的方法
      • Integer：封装了一些int类型的值以及一些操作该类型的方法
      • String：封装了一些有关字符串类型的操作方法
      • Math：用于实现基本数学运算
      • Number：Number为抽象类，它是基本数据类型类的父类
      • Object：所有Java类的根类
      • Runtime：Runtime类对象使Java应用程序与其运行环境相连接
      • StringBuffer：用于可变字符串的操作
      • StringBuilder：创建可变的字符串对象
      • System：封装了一些与Java虚拟机相关的方法
      • Thread：创建和控制线程
      • Throwable：定义了Java所有错误或异常的父类
    • Object类
      • Object：创建Object对象
      • Object clone throws CloneNotSupportedException：创建并返回复制的对象
      • boolean equals(Object)：比较两个对象是否相等，默认比较对象地址
      • Class getClass：返回对象运行时类
      • int hashCode：返回对象的哈希码值，利用对象地址计算hashcode
      • void notify throws IllegalMonitorStateException：唤醒等待的单个线程
      • void notifyAll throws IllegalMonitorStateException：唤醒等待的所有线程
      • String toString：返回对象的字符串表示
      • void wait throws InterruptedException：使当前线程等待
      • void wait(long) throws InterruptedException：使当前线程等待一段时间
      • void wait(long,int) throws InterruptedException：在每个线程中断前使当前线程等待一段时间
    • 类库方法调用
      • 操作功能
      • 方法名称
      • 返回类型
      • 输入参数
      • 抛出异常
    • 基本数据类型类
      • Number抽象类
        • 整数类
          • Byte、Integer、Long、Short
        • 浮点类
          • Float、Double
      • 其他类
        • Boolean、Character、String
    • 整型类
• 程序编写规则
  • 程序编写规则
    • 命名规则
      • Package
        • 一组小写单词
        • package myprogrampackage
      • Class
        • 名字由每个大写字母开头而其他字母都小写的单词组成。
        • ThisIsAClassName
      • Class变量
        • 用一个小写字母（表示变量类型等）或一个全部小写的英文（表示变量操作意义等）开头，后面的单词用大写字母开头。
        • String sHelloString
        • s_HelloString
          • s_Hello_String
        • oldHelloString
          • old_Hello_String
      • Static Final变量
        • 常量的名字应该都大写，并且指出完整含义。
        • 尽可能地在整个程序中都采用常数标识符。避免在程序中直接书写数字。
        • final static double PI = 3.14159
      • 参数
        • 参数名字的命名与变量的命名规范一致。
      • 数组
        • byte[] buffer;
      • 方法中的参数
        • 使用有意义的参数命名（可以使用和要赋值的字段一样的名字）。
        • void setS_HelloString(String s_HelloString) { this.s_HelloString = s_HelloString; }
    • 文件样式规则
      • 在Java语言程序文件的开头：
        • /** * Title: Hello程序 * Description: 教学示范 * Copyright: Copyright(c)2012 * Company: 北京师范大学人工智能学院 * @author gao * @version 1.0 */
      • package/imports位置：
        • 规则
          • package 行在 import 行前，在程序的最前一行。
          • import 行在 package 行后， import 中标准的包名要在本地的包名之前，按照字母顺序排列。
        • 例子
          • package sylproject; import java.awt.*; import java.awt.event.*; import javax.swing.*;
      • Class类的注释：
        • 规则
          • 要尽可能详细地加注释。以便用 javadoc 生成程序文档。
        • 例子
          • /** * 这是一个输出“ Hello ”字符串的类 */
      • Class类定义：
        • 规则
          • 封装性 —— 类不应该只是简单地容纳一些数据，类对象的行为也需要定义在类中。类声明时需要断行，则以“ extends ”和 implements ”为断行点。
        • 例子
          • public class MyHello extends MySuperHello implements MyHelloInterface{ ...}
      • 类的成员变量的定义：
        • 规则
          • public 的成员变量是需要生成 Java 文档（ JavaDoc ）的，所以，要有注释。
          • proceted 、private 定义的成员变量如果名字含义明确，可以没有注释。
        • 例子
          • /** * 定义字符串变量 */ protected String s_HelloString;
      • 类变量存取方法：
        • 规则
          • 尽可能地定义“ private ”类变量，避免定义 public ”类变量。
          • 让一切东西都尽可能地“私有”（ private ），即体现 Java 的安全性，通过类方法操作类变量。
        • 例子
          • /** * 类变量的存取的方法 */ public class MyHello { private String s_HelloString; public void setS_HelloString(String newS_HelloString) { s_HelloString = newS_HelloString; } public String getS_HelloString() {public String getS_HelloString() { return s_HelloString;return s_HelloString; } }
      • 类构造方法定义：
        • 规则
          • 通过构造方法创建类实例，为类分配内存空间，初始化类。
          • 访问类型 “public ”，初始化易读。
        • 例子
          • public MyHello(String init_HelloString){ this.s_HelloString = init_HelloString; }
      • 类方法定义：
        • 例子
          • /** * 输出“ Hello ”字符串 */ public void DisplayHello(){ System.out.println(s_HelloString); }
      • 类构造方法（构造器）与类方法：
        • 规则
          • 构造器是为了创建一个类的实例，在 new 时使用，但只用一次。
          • 构造器一般为 “public ”，构造器使用和类相同的名字，无返回值，也不是 void 类型。
          • 类方法不能取与类相同的名字，类方法有返回值，类方法在类实例化（ new ）后可以反复调用。
    • 代码编写格式
      • 代码可生成 javadoc文档
        • 编写的 Java 程序可以用 javadoc 生成类文档，即生成可读性强的 HTML 标准 JDK 类文档
      • 缩进规则
        • Java 程序中每条语句要作为单独一行。
        • 在 Java 程序中，提倡使用 {} 括号， {} 括号是成对出现，在有 {} 括号中的语句缩进 2个空格。
        • 不要在源文件中使用 Tab 字符
    • Java类文件规则
      • 类定义
        • 每一个类为一个编译单元，即定义一个类则对应一个 *.Java 文件。类名与文件名相同（大小写相同）。
        • class Hello{ // 文件名 Hello.Java }
      • 定义包
        • 应为每一个类定义一个（ package ）包，在同一工程中的所有类则定义在同一个包中，即该类可以为其他程序提供引用（ importimport）
      • Jar文档
        • 为每一个编译单元创建归档文件，即 *.jar 文件，实际为 *.zip 文件。 在其他 Java 文件中被引用（ import ）的文件应为 *.jar 文件
      • main方法
        • main(String[]) 一般写在类的底部，提倡每个类有一个 main 方法，即调试该类成员时方便。当不需要时将其注释。
    • 类文件规则程序内中英文的使用
      • 不使用中文 ：
        • 在编写Java 语言程序时，一般中文只用在“”（双引号）、‘’（单引号）中，以及注释语 句中，除此之外， Java 语言程序全部用英文字母书写，例如，类名、变量名等，甚至包括 Java 语言源程序文件名和存放源程序文件的文件夹（路径）最好都使用英文字母定义（创建），由 于 Java 的与平台无关性，为达到在任何计算机和计算机操作系统中都可执行 Java 程序，应尽 量避免使用中文。