Java入门学习笔记

 Object 类是所有 Java 类的根基类，如果类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类。
    class Cat extends java.lang.Object{    ....    }

    定义成员变量时可以对其初始化，如果不对其初始化， Java 使用默认的值对其初始化。成员变量的作用范围为整个类。

    方法的重载（voerload）：重载构成的条件：方法的名称相同，但参数类型或参数个数不同。

    static 关键字：在类中用 static 声明的成员变量为静态变量，它为该类的公共变量，在第一次使用时被初始化，对于该类的所有对象来说，static 成员变量只有一份。
    用 static 声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在 static 方法中不可访问非 static 成员。
    静态方法不再是针对某个对象调用，所以不能访问非静态成员，可以通过对象引用或类名（不需要实例化）访问静态成员。

    特殊变量 this：一个类所有的实例（对象）调用的成员方法在内存中只有一份拷贝，尽管在内存中可能有多个对象，而数据成员在类的每个对象所在的内存中都存
在着一份拷贝。this 变量允许相同的实例方法为不同的对象工作。每当调用一个实例方法时，this 变量将被设置成引用该实例方法的特定的类对象。方法的代码接着会与 this 所代表的对象的特定数据建立关联。

    常量的定义：使用关键字final定义常量，例如 final double PI=3.1415926;
    作为一种约定，在定义常量时，通常采用大写形式。
    final 常量可以再声明的同时赋初值，也可以再构造函数中赋初值。
    为了节省内存，我们通常将常量声明为静态的（static）。

    方法的覆盖（override）：在子类中定义一个与父类同名、返回类型、参数类型均相同的一个方法，称为方法的覆盖。注意：覆盖发生在子类与父类之间。

    特殊变量 super：提供了对父类的访问。可以使用 super 访问父类被子类隐藏的变量或覆盖的方法。
    每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

    多态性：通过覆盖父类的方法来实现，在运行时根据传递的对象引用，来调用相应的方法。多态执行的条件：1.要有继承；2.要有重写；3.父类引用指向子类对象。

    import 语句：引入包中的类  import java.io.File;
    引入整个包  import java.io.*;
    在同一个包中的类可以互相引用，无需 import 语句。

    类的说明符：
    类的访问说明符
    public
    default（不加访问说明符时）    -- 只能在同一个包中使用
    类的其它修饰符
    final
    abstract

    方法的说明符：
    方法的访问说明符
    public
    protected
    default（不加访问说明符时）
    private

    方法的访问控制：
        public  protected  default  private
同类     yes       yes       yes      yes
同包     yes       yes       yes      no
子类     yes       yes       no       no
通用性   yes       no        no       no

    方法的其它修饰符
    static
    final
    abstract
    native
    synchronized

    final 方法：为了确保某个函数的行为在继承过程中保持不变，并且不能被覆盖（overridden），可以使用final方法。
    为了效率上的考虑，将方法声明为 final，让编译器对此方法的调用进行优化。要注意的是：编译器会自动对 final 方法进行判断，并决定是否进行优化。通常在方法的体积很小，而我们不希望它被覆盖时，才将它声明为 final。class中所有的 private 和 static 方法自然就是 final。

    抽象方法和抽象类：在类中没有方法体的方法，就是抽象方法。含有抽象方法的类，即为抽象类。如果一个子类没有实现抽象基类中所有的抽象方法，则子类也成为一个抽象类。

    native 方法：native 方法是用户在java中可以使用，但不能编写的方法。
    JNI(Java Native Interface)，它允许 java 虚拟机（JVM）内部运行的 java 代码能够与用其它语言（如C、C++、汇编语言）编写的应用程序和库进行互操作。JNI 最大的好处是它没有对底层 java 虚拟机的实现施加任何限制，因此，java 虚拟机厂商可以在不影响虚拟机其它部分的情况下添加对 JNI 的支持。程序员只需要编写一种版本的本地（Native）应用程序和库，就能够与所有支持 JNI 的 java 虚拟机协同工作。JNI 可以理解为 java 和本地应用程序之间的中介。

    interface 接口：接口中所有的方法都是 public abstract。
    在接口中声明方法时，不能用 native、static、final、synchronized、private、protected 等修饰符。和 public 类一样，public 接口也必须定义在与接口同名的文件中。接口中可以有数据成员，这些成员默认都是 public static final。一个接口可以继承自另一个接口（extends）。java中不允许类的多继承，但允许接口的多继承（implements）。在 java 中，一个类可以实现多个接口。一个类在继承另外一个类的同时，可以实现多个接口。

    内部类：在一个类中定义另外一个类，这个类就叫做内部类或内置类（inner class）。
    内部类可以让我们将逻辑上相关的一组类组织起来，并由外部类（outer class）来控制内部类的可见性。
    当我们建立一个inner class 时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的 this reference 形成的，使得内部类对象可以随意的访问外部类中所有的成员。
    在方法中定义的内部类，如果要访问方法中定义的本地变量或方法的参数，则变量必须被声明为 final。
    内部类可以声明为 private 或 protected；还可以声明为 abstract 或 final。
    内部类可以声明为 static 的，但此时就不能再使用外部类的非 static 的成员变量和非 static 的成员方法；非 static 的内部类的成员不能声明为 static 的，只有在顶层类或 static 的内部类中才可以声明 static 成员。

    异常处理：java 程序在执行过程中如出现异常，会自动生成一个异常类对象，该异常对象将被提交给 java 运行时系统，这个过程称为抛出（throw）异常。
    当java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。
    如果 java 运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的java程序也将退出。
    try/catch/finally 语句。
    对于 RuntimeException，通常不需要我们去捕获，这类异常有 java 运行时系统自动抛出并自动处理。
    如果父类中的方法抛出多个异常，则子类中的覆盖方法要么抛出相同的异常，要么抛出异常的子类，但不能抛出新的异常（注：构造方法除外）。
    我们可以在方法声明时，声明一个不会抛出的异常，java 编译器会强迫方法的使用者对异常进行处理。这种方式通常应用于 abstract base class 和 interface中。

    “==”和“equals”的用法
    在java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型，其余的都是引用类型。
    “==”是比较两个变量的值是否相等；“equals”是比较两个对象变量所代表的对象的内容是否相等。

    函数的调用：在 java 中，传参时，都是以传值得方式进行。
    对于基本数据类型，传递的是数据的拷贝；对于引用类型，传递的是引用的拷贝。

    对象的克隆（clone）
    为了获取对象的一份拷贝，我们可以利用 Object 类的clone() 方法。
    在派生类中覆盖基类的 clone() 方法，并声明为 public。
    在派生类的 clone() 方法中，调用 super.clone()。
    在派生类中实现 Cloneable 接口。

    数组的相关操作
    在java中，所有的数组都有一个缺省的属性length，用于获取数组中元素的个数。
    数组的复制：System.arraycopy()。
    数组的排序：Arrays.sort()。
    在已排序的数组中查找某个元素：Arrays.binarySearch()。   
    int[] num1 = new int[]{1,2,3};
    int[] num2 = new int[3];
    Point[] pts1 = new Point[]{new Point(1,1),new Point(2,2),new Point(3,3)};
    Point[] pts2 = new Point[3];

    Class 类：在 java 中，每个 class 都有一个相应的 Class 对象。也就是说，当我们编写一个类，编译完成后，在生成的 .class 文件中，就会产生一个 Class 对象，用于表示这个类的类型信息。
    获取 Class 实例的三种方式：
    1.利用对象调用 getClass() 方法获取该对象的 Class 实例；
    2.使用 Class 类的静态方法forName()，用类的名字获取一个 Class 实例；
    3.运用 .class 的方式来获取 Class 实例，对于基本数据类型的封装类，还可以采用 .TYPE 来获取相对于基本数据类型的 Class 实例。 
    在运行期间，如果我们要产生某个类的对象，java 虚拟机（JVM）会检查该类型的 Class 对象是否已被加载。如果没有被加载，JVM 会根据类的名称找到 .class 文件并加载它。一旦某个类型的 Class 对象已被加载到内存，就可以用它来产生该类型的所有对象。

    java 对多线程的支持：java 在语言级提供了对多线程程序设计的支持。
    实现多线程程序的两种方式：
    1.从 Thread 类继承；
    2.实现 Runnable 接口。
    java运行时系统实现了一个用于调度线程执行的线程调度器，用于确定某一时刻由哪一个线程在 CPU 上运行。
    在 java 技术中，线程通常是抢占式的，而不需要时间片分配进程（分配给每个线程相等的 CPU 时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。
    java 线程调度器支持不同优先级线程的抢占方式，但其本身不支持相同优先级线程的时间片轮换。
    java 运行时系统所在的操作系统（例如：windows2000）支持时间片的轮换，则线程调度器就支持相同优先级的时间片轮换。

    线程的同步
    The code segments within a program that access the same object from separate, concurrent threads are called "critical sections".
    同步的两种方式：同步块和同步方法
    每个对象都有一个监视器，或者叫做锁。
    同步方法利用的是this所代表的对象的锁。
    每个 class 也有一个锁，是这个 class 所对应的 Class 对象的锁。

    wait、notify、notifyAll
    每个对象除了有一个锁之外，还有一个等待队列（wait set），当一个对象刚创建的时候，它的等待队列是空的。
    我们应该在当前线程锁住对象的锁后，去调用该对象的 wait 方法。
    当调用对象的 notify 方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。
    当调用对象的 notifyAll 方法时，将从该对象的等待队列中删除所有的线程，这些线程将成为可运行的线程。
    wait 和 notify 主要用于 producer-consumer 这种关系。