Java基础教程

一.Java语法

        1.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中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

        2.Java基本语法

                大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。

                类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。

                方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

                源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。

                主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

        3.Java变量类型

                1）局部变量声明在方法、构造方法或者语句块中

                        局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

                        访问修饰符不能用于局部变量；

                        局部变量只在声明它的方法、构造方法或者语句块中可见；

                        局部变量是在栈上分配的。

                        局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

                2）实例变量

                        实例变量声明在一个类中，但在方法、构造方法和语句块之外；

                        当一个对象被实例化之后，每个实例变量的值就跟着确定；

                        实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

                        实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

                        实例变量可以声明在使用前或者使用后；

                        访问修饰符可以修饰实例变量；

                        实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

                        实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

                        实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

                3）类变量（静态变量）

                        类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。

                        无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

                        静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。

                        静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。

                        静态变量在程序开始时创建，在程序结束时销毁。

                        与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。

                        默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

                        静态变量可以通过：ClassName.VariableName的方式访问。

                        类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

        4.Java修饰符

                默认的，也称为 default，在同一包内可见，不使用任何修饰符。

                私有的，以 private 修饰符指定，在同一类内可见。

                共有的，以 public 修饰符指定，对所有类可见。

                受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。

                父类中声明为 public 的方法在子类中也必须为 public。

                父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

                父类中声明为 private 的方法，不能够被继承。

二.Java面向对象

        1.Java接口

                1）接口与类相似点

                        一个接口可以有多个方法。

                        接口文件保存在 .java 结尾的文件中，文件名使用接口名。

                        接口的字节码文件保存在 .class 结尾的文件中。

                        接口相应的字节码文件必须在与包名称相匹配的目录结构中。

                2）接口与类的区别

                        接口不能用于实例化对象。

                        接口没有构造方法。

                        接口中所有的方法必须是抽象方法。

                        接口不能包含成员变量，除了 static 和 final 变量。

                        接口不是被类继承了，而是要被类实现。

                        接口支持多重继承。

                3）接口特性

                        接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

                        接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。

                        接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

                4）抽象类和接口的区别

                        抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

                        抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

                        接口中不能还有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

                        一个类只能继承一个抽象类，而一个类却可以实现多个接口。

                5）重写接口中声明的方法时需要注意以下规则

                        类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。

                        类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。

                        如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

                6）在实现接口的时候要注意以下规则：

                        一个类可以同时实现多个接口。

                        一个类只能继承一个类，但是能实现多个接口。

                        一个接口能继承另一个接口，这和类之间的继承比较相似。

                7）没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

                        建立一个公共的父接口：正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

                        向一个类添加数据类型：这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

        2.Java包

                为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

                包的作用：

                        把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

                        如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

                        包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

                Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

三.Java高级教程

        1.Java序列化

                1） 一个类的对象要想序列化成功，必须满足两个条件

                        该类必须实现 java.io.Serializable 对象。

                        该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的（transient）。

                2）反序列化时需要注意

                        readObject() 方法中的 try/catch代码块尝试捕获 ClassNotFoundException 异常。对于 JVM 可以反序列化对象，它必须是能够找到字节码的类。如果JVM在反序列化对象的过程中找不到该类，则抛出一个 ClassNotFoundException 异常。

        2.Java多线程

                1）通过实现 Runnable 接口来创建线程

                         创建一个实现 Runnable 接口的类。为了实现 Runnable，一个类只需要执行一个方法调用 run()。

                         创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。

                         新线程创建之后，你调用它的 start() 方法它才会运行。

                2）通过继承Thread来创建线程

                         创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。

                         继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

                         该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

                3）通过 Callable 和 Future 创建线程

                         创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

                         创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

                         使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

                         调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

                4）创建线程的三种方式的对比

                         采用实现 Runnable、Callable 接口的方式创见多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

                         使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

        3.Java Applet

                1）独立的 Java 应用程序和 applet 程序之间重要的不同

                        Java 中 Applet 类继承了 java.applet.Applet 类。

                        Applet 类没有定义 main()，所以一个 Applet 程序不会调用 main() 方法。

                        Applet 被设计为嵌入在一个 HTML 页面。

                        当用户浏览包含 Applet 的 HTML 页面，Applet 的代码就被下载到用户的机器上。

                        要查看一个 Applet 需要 JVM。 JVM 可以是 Web 浏览器的一个插件，或一个独立的运行时环境。

                        用户机器上的 JVM 创建一个 Applet 类的实例，并调用 Applet 生命周期过程中的各种方法。

                        Applet 有 Web 浏览器强制执行的严格的安全规则，Applet 的安全机制被称为沙箱安全。

                        Applet 需要的其他类可以用 Java 归档（JAR）文件的形式下载下来。

                2）Applet的生命周期

                        Applet 类中的四个方法给你提供了一个框架，你可以再该框架上开发小程序：

                        init: 该方法的目的是为你的 Applet 提供所需的任何初始化。在 Applet 标记内的 param 标签被处理后调用该方法。

                        start: 浏览器调用 init 方法后，该方法被自动调用。每当用户从其他页面返回到包含 Applet 的页面时，则调用该方法。

                        stop: 当用户从包含 Applet 的页面移除的时候，该方法自动被调用。因此，可以在相同的 Applet 中反复调用该方法。

                        destroy: 此方法仅当浏览器正常关闭时调用。因为 Applet 只有在 HTML 网页上有效，所以你不应该在用户离开包含 Applet 的页面后遗漏任何资源。

                        paint: 该方法在 start() 方法之后立即被调用，或者在 Applet 需要重绘在浏览器的时候调用。paint() 方法实际上继承于 java.awt。

                3）应用程序转换成 Applet

                        编写一个 HTML 页面，该页面带有能加载 applet 代码的标签。

                        编写一个 JApplet 类的子类，将该类设置为 public。否则，Applet 不能被加载。

                        消除应用程序的 main()方法。不要为应用程序构造框架窗口，因为你的应用程序要显示在浏览器中。

                        将应用程序中框架窗口的构造方法里的初始化代码移到 Applet 的init() 方法中，不必显示的构造 Applet 对象，浏览器将通过调用 init() 方法来实例化一个对象。

                        移除对 setSize() 方法的调用，对于 Applet 来讲，大小已经通过 HTML 文件里的 width 和 height 参数设定好了。

                        移除对 setDefaultCloseOperation() 方法的调用。Applet 不能被关闭，它随着浏览器的退出而终止。

                        如果应用程序调用了 setTitle() 方法，消除对该方法的调用。applet 不能有标题栏。（当然你可以给通过 html 的 title 标签给网页自身命名）

                        不要调用 setVisible(true),Applet 是自动显示的。

                4）事件处理

                       Applet 类从 Container 类继承了许多事件处理方法。Container 类定义了几个方法，例如：processKeyEvent() 和processMouseEvent()，用来处理特别类型的事件，还有一个捕获所有事件的方法叫做 processEvent。

               5）显示图片

                       Applet 能显示 GIF,JPEG,BMP 等其他格式的图片。为了在 Applet 中显示图片，你需要使用 java.awt.Graphics 类的drawImage()方法。

               6）播放音频

                       Applet 能通过使用 java.applet 包中的 AudioClip 接口播放音频。AudioClip 接口定义了三个方法：

                               public void play(): 从一开始播放音频片段一次

                               public void loop(): 循环播放音频片段

                               public void stop(): 停止播放音频片段

                      为了得到 AudioClip 对象，你必须调用 Applet 类的 getAudioClip() 方法。无论 URL 指向的是否是一个真实的音频文件，该方法都会立即返回结果。

                      直到要播放音频文件时，该文件才会下载下来。

        4.Java文档注释

                Java 只是三种注释方式。前两种分别是 // 和 /* */，第三种被称作说明注释，它以 /** 开始，以 */结束。

                说明注释允许你在程序中嵌入关于程序的信息。你可以使用 javadoc 工具软件来生成信息，并输出到HTML文件中。

                说明注释，使你更加方面的记录你的程序的信息。

                在开始的 /** 之后，第一行或几行是关于类、变量和方法的主要描述。

                之后，你可以包含一个或多个何种各样的 @ 标签。每一个 @ 标签必须在一个新行的开始或者在一行的开始紧跟星号(*).

                多个相同类型的标签应该放成一组。

                javadoc 工具将你 Java 程序的源代码作为输入，输出一些包含你程序注释的HTML文件。

                每一个类的信息将在独自的HTML文件里。javadoc 也可以输出继承的树形结构和索引。

                由于 javadoc 的实现不同，工作也可能不同，你需要检查你的 Java 开发系统的版本等细节，选择合适的 Javadoc 版本。

        5.Java 8新特性

                Java8 新增了非常多的特性，我们主要讨论以下几个：

                Lambda 表达式 − Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

                方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

                默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。

                新工具 − 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。

                Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。

                Date Time API − 加强对日期与时间的处理。

                Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。

                Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。