Java自学笔记 同步印象笔记
Java自学笔记
java简介：
-
Java语言是简单的：Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用。另外一方面，Java丢弃了C++中不多使用的、很难理解的、使人迷惑的那些特性，如操做符重载、多继承、自动的强制类型转换。特别地，Java语言不使用指针，而是引用。并提供了自动的废料收集，使得程序员没必要为内存管理而担心。
-
Java语言是面向对象的：Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
-
Java语言是分布式的：Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
-
Java语言是健壮的：Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。
-
Java语言是安全的：Java一般被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具备的许多安全特性之外，Java对经过网络下载的类具备一个安全防范机制（类ClassLoader），如分配不一样的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。
-
Java语言是体系结构中立的：Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），而后能够在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
-
Java语言是可移植的：这种可移植性来源于体系结构中立性，另外，Java还严格规定了各个基本数据类型的长度。Java系统自己也具备很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。
-
Java语言是解释型的：如前所述，Java程序在Java平台上被编译为字节码格式，而后能够在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程当中须要的类在联接阶段被载入到运行环境中。
-
Java是高性能的：与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time）编译器技术的发展愈来愈接近于C++。
-
Java语言是多线程的：在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来建立。一般有两种方法来建立线程：其一，使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类建立的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，所以，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。
-
Java语言是动态的：Java语言的设计目标之一是适应于动态变化的环境。Java程序须要的类可以动态地被载入到运行环境，也能够经过网络来载入所须要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
java第一个程序
首先须要先建立项目，而后是穿件包，建立类，最后经过调用一个输出函数来达到打印“hello world ！”的目的，很麻烦
，
java基础语法
一个 Java 程序能够认为是一系列对象的集合，而这些对象经过调用彼此的方法来协同工做。下面简要介绍下类、对象、方法和实例变量的概念。
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类能够有不少方法。逻辑运算、数据修改以及全部动做都是在方法中完成的。
实例变量：每一个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
Java中的Project、Package和Class
在Java编程以前，咱们首先须要建立新的project、package以及class。
Project：项目，是最大的范围，能够被认为是Java程序的最上层。一个项目能够包含若干个Package。不一样Project之间，基本上没有任何关系。
Package：包，能够包含若干个Class。包的引入，我的认为是为了对各个类进行分层管理，在同一个包与不一样的包之中，权限会有所不一样。同时，这样也可使程序的结构清晰，有点像文件目录的感受。（推荐资料）
Class：类文件。同一个类中，没有访问权限的限制。可是，请注意一点，每个.class文件中最多只能有一个public类，而且类名称必须和文件名称一致。
注意若是安装了多个版本的java须要先检查 java -version 和javac -version 的版本是否一致，不然会成功编译但没法运行，运行会报错
注意：还有事公共类须要在与类名相同的java文件中进行声明，不然编译程序会报错
运行java文件，能够从编译器中直接运行，也能够在cmd中javac编译成功后，java运行
（附件：历年java版本比较，日后每6个月进行一次版本的迭代）
heap size eclipse 堆内存
能够根据eclipse 或 myeclipse heapstats 使用状况调整堆内存大小，heap size 设置，-vmargs-Xms256-Xmx1024 ，其中Xms表示初始值，Xmx表示最大值，最大值最好少于机器内存80%。
编写 Java 程序时，应注意如下几点：
大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不一样的。
类名：对于全部的类来讲，类名的首字母应该大写。若是类名由若干单词组成，那么每一个单词的首字母应该大写，例如
MyFirstJavaClass 。
方法名：全部的方法名都应该以小写字母开头。若是方法名含有若干单词，则后面的每一个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名做为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为
.java。（若是文件名和类名不相同则会致使编译错误）。
主方法入口：全部的 Java 程序由 public static void main(String []arg s) 方法开始执行。
Java 标识符
Java 全部的组成部分都须要名字。类名、变量名以及方法名都被称为标识符。
关于 Java 标识符，有如下几点须要注意：
全部的标识符都应该以字母（A-Z 或者 a-z）,美圆符（$）、或者下划线（_）开始
首字符以后能够是字母（A-Z 或者 a-z）,美圆符（$）、下划线（_）或数字的任何字符组合
关键字不能用做标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
Java修饰符
像其余语言同样，Java可使用修饰符来修饰类中方法和属性。主要有两类修饰符：
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized
Java 变量
Java 中主要有以下几种类型的变量
局部变量
类变量（静态变量）
成员变量（非静态变量）
Java 数组
数组是储存在堆上的对象，能够保存多个同类型变量。
Java 枚举
Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举能够减小代码中的 bug。
例如，咱们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不容许顾客点除了这三种尺寸外的果汁。
Java 关键字
下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
|
类别
|
关键字
|
说明
|
|
访问控制
|
private
|
私有的
|
|
protected
|
受保护的
|
|
|
public
|
公共的
|
|
|
类、方法和变量修饰符
|
abstract
|
声明抽象
|
|
class
|
类
|
|
|
extends
|
扩充,继承
|
|
|
final
|
最终值,不可改变的
|
|
|
implements
|
实现（接口）
|
|
|
interface
|
接口
|
|
|
native
|
本地，原生方法（非 Java 实现）
|
|
|
new
|
新,建立
|
|
|
static
|
静态
|
|
|
strictfp
|
严格,精准
|
|
|
synchronized
|
线程,同步
|
|
|
transient
|
短暂
|
|
|
volatile
|
易失
|
|
|
程序控制语句
|
break
|
跳出循环
|
|
case
|
定义一个值以供 switch 选择
|
|
|
continue
|
继续
|
|
|
default
|
默认
|
|
|
do
|
运行
|
|
|
else
|
不然
|
|
|
for
|
循环
|
|
|
if
|
若是
|
|
|
instanceof
|
实例
|
|
|
return
|
返回
|
|
|
switch
|
根据值选择执行
|
|
|
while
|
循环
|
|
|
错误处理
|
assert
|
断言表达式是否为真
|
|
catch
|
捕捉异常
|
|
|
finally
|
有没有异常都执行
|
|
|
throw
|
抛出一个异常对象
|
|
|
throws
|
声明一个异常可能被抛出
|
|
|
try
|
捕获异常
|
|
|
包相关
|
import
|
引入
|
|
package
|
包
|
|
|
基本类型
|
boolean
|
布尔型
|
|
byte
|
字节型
|
|
|
char
|
字符型
|
|
|
double
|
双精度浮点
|
|
|
float
|
单精度浮点
|
|
|
int
|
整型
|
|
|
long
|
长整型
|
|
|
short
|
短整型
|
|
|
变量引用
|
super
|
父类,超类
|
|
this
|
本类
|
|
|
void
|
无返回值
|
|
|
保留关键字
|
goto
|
是关键字，但不能使用
|
|
const
|
是关键字，但不能使用
|
|
|
null
|
空
|
Java 空行
空白行或者有注释的行，Java 编译器都会忽略掉。
继承
在 Java 中，一个类能够由其余类派生。若是你要建立一个类，并且已经存在一个类具备你所须要的属性或方法，那么你能够将新建立的类继承该类。
利用继承的方法，能够重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
接口
在 Java 中，接口可理解为对象间相互通讯的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，可是方法的具体实现彻底取决于派生类。
Java 源程序代码与编译型源程序代码运行区别
以下图所示：
java一直是运行在一个“虚拟机”（解释器）之上的，经过虚拟机进行解释编译，而后运行也是架空与操做系统的；这也能够解释为何java能够轻松地跨平台运行而不须要繁琐复杂的修改代码的缘由了
Java 对象和类
对象：对象是类的一个实例（
对象不是找个女友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
一个类能够包含如下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体以外的变量。这种变量在建立对象的时候实例化。成员变量能够被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体以外，但必须声明为static类型。
一个类能够拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。
建立对象
对象是根据类建立的。在Java中，使用关键字new来建立一个新的对象。建立对象须要如下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来建立一个对象。
初始化：使用new建立对象时，会调用构造方法初始化对象。
Java源程序框架概念
project（项目）：下可包含多个class（类）
class（类）{
构造方法{
建立对象的同时必须赋予一个以上的方法，构造方法的名称必须与类同名
public static void main(String[] args){
经过构造器建立运行java程序的入口
建立对象
调用类方法，建立实例...
}
源文件声明规则
在本节的最后部分，咱们将学习源文件的声明规则。当在一个源文件中定义多个类，而且还有import语句和package语句时，要特别注意这些规则。
一个源文件中只能有一个public类
一个源文件能够有多个非public类
源文件的名称应该和public类的类名保持一致。例如：
源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
若是一个类定义在某个包中，那么package语句应该在源文件的首行。
若是源文件包含import语句，那么应该放在package语句和类定义之间。若是没有package语句，那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的全部类都有效。在同一源文件中，不能给不一样的类不一样的包声明。
类有若干种访问级别，而且类也分不一样的类型：抽象类和final类等。这些将在访问控制章节介绍。
除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。
Java包
包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，所以颇有必要对类和接口进行分类。
Java 基本数据类型
变量就是申请内存来存储值。也就是说，当建立变量的时候，须要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
所以，经过定义不一样类型的变量，能够在内存中储存整数、小数或者字符。
Java 的两大数据类型:
内置数据类型
引用数据类型
内置数据类型
byte： 默认值是 0；
short： 默认值是 0；
int： 默认值是 0 ；
long： 默认值是 0L；
float： 默认值是 0.0f；
double： 默认值是 0.0d；
boolean： 默认值是 false；
char： char 数据类型能够储存任何字符ASCII；
String： 默认值是 null；
Java语言支持一些特殊的转义字符序列
|
符号
|
字符含义
|
|
\n
|
换行 (0x0a)
|
|
\r
|
回车 (0x0d)
|
|
\f
|
换页符(0x0c)
|
|
\b
|
退格 (0x08)
|
|
\0
|
空字符 (0x20)
|
|
\s
|
字符串
|
|
\t
|
制表符
|
|
\"
|
双引号
|
|
\'
|
单引号
|
|
\\
|
反斜杠
|
|
\ddd
|
八进制字符 (ddd)
|
|
\uxxxx
|
16进制Unicode字符 (xxxx)
|
实例变量
实例变量声明在一个类中，但在方法、构造方法和语句块以外；
当一个对象被实例化以后，每一个实例变量的值就跟着肯定；
实例变量在对象建立的时候建立，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部可以经过这些方式获取实例变量信息；
实例变量能够声明在使用前或者使用后；
访问修饰符能够修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。通常状况下应该把实例变量设为私有。经过使用访问修饰符可使实例变量对子类可见；
实例变量具备默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值能够在声明时指定，也能够在构造方法中指定；
实例变量能够直接经过变量名访问。但在静态方法以及其余类中，就应该使用彻底限定名：ObejectReference.VariableName。
Java 修饰符
Java语言提供了不少修饰符，主要分为如下两类：
访问修饰符
非访问修饰符
访问控制修饰符
Java中，可使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不一样的访问权限。
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。
注意：不能修饰类（外部类）
public : 对全部类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和全部子类可见。使用对象：变量、方法。
注意：不能修饰类（外部类）。
接口及接口的成员变量和成员方法不能声明为 protected
咱们能够经过如下表来讲明访问权限：
非访问修饰符
为了实现一些其余的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不可以被继承，修饰的方法不能被继承类从新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来建立抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，不管一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非 静态变量。静态方法从参数列表获得数据，而后计算这些数据。
final 修饰符
final 变量：
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被从新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符一般和 static 修饰符一块儿使用来建立类常量。
final 方法
父类中的 final 方法能够被子类继承，可是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
以下所示，使用 final 修饰符声明方法。
final 类
final 类不能被继承，没有类可以继承 final 类的任何特性。
abstract 修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的惟一目的是为了未来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。若是一个类包含抽象方法，那么该类必定要声明为抽象类，不然将出现编译错误。
抽象类能够包含抽象方法和非抽象方法。
抽象方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的全部抽象方法，除非该子类也是抽象类。
若是一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类能够不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。
synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符能够应用于四个访问修饰符。
transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中从新读取该成员变量的值。并且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任什么时候刻，两个不一样的线程老是看到某个成员变量的同一个值。
一个 volatile 对象引用多是 null。
java运算符
条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操做数，而且须要判断布尔表达式的值。该运算符的主要是决定哪一个值应该赋值给变量。
// 若是 a 等于 1 成立，则设置 b 为 20，不然为 30
b = (a == 1) ? 20 : 30;
instanceof 运算符
该运算符用于操做对象实例，检查该对象是不是一个特定类型（类类型或接口类型）。
Java 循环结构
顺序结构的程序语句只能被执行一次。若是您想要一样的操做执行屡次,，就须要使用循环结构。
Java中有三种主要的循环结构：
while 循环
do…while 循环
for 循环
在Java5中引入了一种主要用于数组的加强型for循环。
for循环
虽然全部循环结构均可以用 while 或者 do...while表示，但 Java 提供了另外一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就肯定的。语法格式以下：
for(初始化; 布尔表达式; 更新) { //代码语句 }
Java 加强 for 循环
Java5 引入了一种主要用于数组的加强型 for 循环。
Java 加强 for 循环语法格式以下:
for(声明语句 : 表达式) {
//代码句子
}
Java Number & Math 类
通常地，当须要使用数字的时候，咱们一般使用内置数据类型，如：byte、int、long、double 等。
然而，在实际开发过程当中，咱们常常会遇到须要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每个内置数据类型提供了对应的包装类。
全部的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
Java Math 类
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，经过 Math 类能够在主函数中直接调用。
Java Character 类
Character 类用于对单个字符进行操做。
Character 类在对象中包装一个基本类型 char 的值
实例
char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A';
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
Character 方法
下面是Character类的方法：
|
序号
|
方法与描述
|
|
1
|
是不是一个字母
|
|
2
|
是不是一个数字字符
|
|
3
|
是不是一个空白字符
|
|
4
|
是不是大写字母
|
|
5
|
是不是小写字母
|
|
6
|
指定字母的大写形式
|
|
7
|
指定字母的小写形式
|
|
8
|
toString()
返回字符的字符串形式，字符串的长度仅为1
|
Java String 类
字符串普遍应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来建立和操做字符串。
字符串长度
用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
链接字符串
String 类提供了链接两个字符串的方法：
string1.concat(string2); //同PHP同样的~
返回 string2 链接 string1 的新字符串。也能够对字符串常量使用 concat() 方法，如：
"个人名字是 ".concat("Runoob");
更经常使用的是使用'+'操做符来链接字符串，如：
"Hello," + " runoob" + "!"
结果以下:
"Hello, runoob!"
Java 数组
数组对于每一门编程语言来讲都是重要的数据结构之一，固然不一样语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你能够声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。
多维数组
多维数组能够当作是数组的数组，好比二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组，例如：
String str[][] = new String[3][4];
Arrays 类
java.util.Arrays 类能方便地操做数组，它提供的全部方法都是静态的。
具备如下功能：
给数组赋值：经过 fill 方法。
对数组排序：经过 sort 方法,按升序。
比较数组：经过 equals 方法比较数组中元素值是否相等。
查找数组元素：经过 binarySearch 方法能对排序好的数组进行二分查找法操 做。
获取当前日期时间
Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间，以下所示：
实例
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
}
}
Java 休眠(sleep)
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留必定时间给其余线程执行的机会。
你可让程序休眠一毫秒的时间或者到您的计算机的寿命长的任意段时间。
Java 正则表达式
正则表达式定义了字符串的模式。
正则表达式能够用来搜索、编辑或处理文本。
正则表达式并不只限于某一种语言，可是在每种语言中有细微的差异。
Java 方法
在前面几个章节中咱们常用到 System.out.println()，那么它是什么呢？
println() 是一个方法。
System 是系统类。
out 是标准输出对象。
这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
那么什么是方法呢？
Java方法是语句的集合，它们在一块儿执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被建立，在其余地方被引用
方法的优势
1. 使程序变得更简短而清晰。
2. 有利于程序维护。
3. 能够提升程序开发的效率。
4. 提升了代码的重用性。
方法的命名规则
1.方法的名字的第一个单词应以小写字母做为开头，后面的单词则用大写字母开头写，不使用链接符。例如：
addPerson。
2.下划线可能出如今 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：
test<MethodUnderTest>_<state>
，例如
testPop_emptyStack
。
方法的定义
通常状况下，定义一个方法包含如下语法：
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
... return 返回值;
}
方法包含一个方法头和一个方法体。下面是一个方法的全部部分：
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操做，但没有返回值。在这种状况下，returnValueType 是关键字
void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法能够不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。
构造方法
当一个对象被建立时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
一般会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来建立一个完整的对象。
无论你是否自定义构造方法，全部的类都有构造方法，由于Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改成 protected，构造函数也改成 protected)。
一旦你定义了本身的构造方法，默认构造方法就会失效。
FileInputStream
该流用于从文件读取数据，它的对象能够用关键字 new 来建立。
有多种构造方法可用来建立对象。
可使用字符串类型的文件名来建立一个输入流对象来读取文件：
InputStream f = new FileInputStream("C:/java/hello");
也可使用一个文件对象来建立一个输入流对象来读取文件。咱们首先得使用 File() 方法来建立一个文件对象：
File f = new File("C:/java/hello"); InputStream out = new FileInputStream(f);
FileOutputStream
该类用来建立一个文件并向文件中写数据。
若是该流在打开文件进行输出前，目标文件不存在，那么该流会建立该文件。
有两个构造方法能够用来建立 FileOutputStream 对象。
使用字符串类型的文件名来建立一个输出流对象：
OutputStream f = new FileOutputStream("C:/java/hello")
也可使用一个文件对象来建立一个输出流来写文件。咱们首先得使用File()方法来建立一个文件对象：
File f = new File("C:/java/hello"); OutputStream f = new FileOutputStream(f);
读取目录
一个目录其实就是一个 File 对象，它包含其余文件和文件夹。
若是建立一个 File 对象而且它是一个目录，那么调用 isDirectory() 方法会返回 true。
能够经过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表。
删除目录或文件
删除文件可使用 java.io.File.delete() 方法。
如下代码会删除目录 /tmp/java/，须要注意的是当删除某一目录时，必须保证该目录下没有其余文件才能正确删除，不然将删除失败。
测试目录结构：
Java Scanner 类
java.util.Scanner 是 Java5 的新特征，咱们能够经过 Scanner 类来获取用户的输入。
Java 继承
继承的概念
继承是java面向对象编程技术的一块基石，由于它容许建立分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具备父类的实例域和方法，或子类从父类继承方法，使得子类具备父类相同的行为。
生活中的继承：
兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
因此继承须要符合的关系是：is-a，父类更通用，子类更具体。
虽然食草动物和食肉动物都是属于动物，可是二者的属性和行为上有差异，因此子类会具备父类的通常特性也会具备自身的特性。
类的继承格式
在 Java 中经过 extends 关键字能够申明一个类是从另一个类继承而来的，通常形式以下：
类的继承格式
class 父类 {
}
class 子类 extends 父类 {
}
为何须要继承
简单地说就是建立一个类模板，使得后面的建立新实例能够重复利用这个模板以达到减小代码长度，提升代码效率的目的
继承的特性
子类
拥有父类非 private 的属性、方法。
子类能够拥有本身的属性和方法，即子类能够对父类进行扩展。
子类能够用本身的方式实现父类的方法。
Java 的继承是单继承，可是能够多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，因此按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提升了类之间的耦合性（继承的缺点，耦合度高就会形成代码之间的联系越紧密，代码独立性越差）。
extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，因此 extends 只能继承一个类。
implements关键字
使用 implements 关键字能够变相的使java具备多继承的特性，使用范围为类继承接口的状况，能够同时继承多个接口（接口跟接口之间采用逗号分隔）。
super 与 this 关键字
super关键字：咱们能够经过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向本身的引用。
final关键字
final 关键字声明类能够把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。若是父类的构造器带有参数，则必须在子类的构造器中显式地经过 super 关键字调用父类的构造器并配以适当的参数列表。
若是父类构造器没有参数，则在子类的构造器中不须要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
重写(Override)
重写是子类对父类的容许访问的方法的实现过程进行从新编写, 返回值和形参都不能改变。 即外壳不变，核心重写！
方法的重写规则
参数列表必须彻底与被重写方法的相同。
返回类型与被重写方法的返回类型能够不相同，可是必须是父类返回值的派生类（java5 及更早版本返回类型要同样，java7 及更高版本能够不一样）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：若是父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，可是可以被再次声明。
子类和父类在同一个包中，那么子类能够重写父类全部方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只可以重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法可以抛出任何非强制异常，不管被重写的方法是否抛出异常。可是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更普遍的强制性异常，反之则能够。
构造方法不能被重写。
若是不能继承一个方法，则不能重写这个方法。
Super 关键字的使用
当须要在子类中调用父类的被重写方法时，要使用 super 关键字。
重载(Overload)
重载(overloading) 是在一个类里面，方法名字相同，而参数不一样。返回类型能够相同也能够不一样。
每一个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最经常使用的地方就是构造器的重载。
Java 多态
多态是同一个行为具备多个不一样表现形式或形态的能力。
多态就是同一个接口，使用不一样的实例而执行不一样操做，如图所示：
多态性是对象多种表现形式的体现。
现实中，好比咱们按下 F1 键这个动做：若是当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；若是当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不一样的对象上会产生不一样的结果。
多态的优势
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
多态存在的三个必要条件
继承
重写
父类引用指向子类对象
虚函数
虚函数的存在是为了多态。
Java 中其实没有虚函数的概念，它的普通函数就至关于 C++ 的虚函数，动态绑定是Java的默认行为。若是 Java 中不但愿某个函数具备虚函数特性，能够加上 final 关键字变成非虚函数。
重写
咱们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。
咱们已经讨论了方法的重写，也就是子类可以重写父类的方法。
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字 super。
Java 抽象类
在面向对象的概念中，全部的对象都是经过类来描绘的，可是反过来，并非全部的类都是用来描绘对象的，若是一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象以外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类同样。
因为抽象类不能实例化对象，因此抽象类必须被继承，才能被使用。也是由于这个缘由，一般在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，可是因为父类自己是抽象的，因此不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却能够实现多个接口。
抽象类总结规定
1. 抽象类不能被实例化(初学者很容易犯的错)，若是被实例化，就会报错，编译没法经过。只有抽象类的非抽象子类能够建立对象。
2. 抽象类中不必定包含抽象方法，可是有抽象方法的类一定是抽象类。
3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
Java 封装
在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装能够被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须经过严格的接口控制。
封装最主要的功能在于咱们能修改本身的实现代码，而不用修改那些调用咱们代码的程序片断。
适当的封装可让程式码更容易理解与维护，也增强了程式码的安全性。
封装的优势
1. 良好的封装可以减小耦合。
2. 类内部的结构能够自由修改。
3. 能够对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。
Java 包(package)
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的做用
一、把功能类似或相关的类或接口组织在同一个包中，方便类的查找和使用。
二、如同文件夹同样，包也采用了
树形目录的存储方式。同一个包中的类名字是不一样的，不一样的包中的类的名字是能够相同的，当同时调用两个不一样包中相同类名的类时，应该加上包名加以区别。所以，包能够避免名字冲突。
三、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
package 的目录结构
类放在包中会有两种主要的结果：
包名成为类名的一部分，正如咱们前面讨论的同样。
包名必须与相应的字节码所在的目录结构相吻合。
下面是管理你本身 java 中文件的一种简单方式：
将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java做为扩展名。例如：
// 文件名 : Car.java package vehicle; public class Car { // 类实现 }
接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。
....\vehicle\Car.java
如今，正确的类名和路径将会是以下样子：
类名 -> vehicle.Car
路径名 -> vehicle\Car.java (在 windows 系统中)
Java 数据结构
Java工具包提供了强大的数据结构。在Java中的数据结构主要包括如下几种接口和类：
枚举（Enumeration）
位集合（BitSet）
向量（Vector）
栈（Stack）
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）