1. 变量
   1. 基本数据类型
      1. 类似C的define声明的常量
         1. 用final实现 例如：double PI=3.14159
      2. 按作用域划分的变量
         1. 局部变量
            1. 代码块中声明，作用域为代码块
         2. 类变量
            1. 类中声明，而不是类的方法中声明，作用域为整个类
         3. 方法参数
            1. 传递给方法，作用域是这个方法
         4. 例外处理参数
            1. 传递给例外处理代码，作用域为例外处理部分
      3. 按数据类型划分变量
         1. 整形数据
            1. 常量
            2. 十、八、十六进制
            3. 123, 0123, 0x123
            4. 变量
            5. byte, short, int, long
         2. 字符型数据
            1. 常量
            2. ‘A’, 'a'
            3. 变量
            4. char a = 'a';
            5. 字符串常量
            6. "This is a string.\n"
         3. 布尔型数据
            1. ture, false
            2. boolean a = ture;
         4. 浮点型（实型）数据
            1. 常量
            2. 十进制实型
            3. 1234123.123f
            4. 科学计数法
            5. 123e3
            6. 变量
            7. float, double
      4. 各类数值型数据间的混合运算
         1. 自动类型转换（向上转）
         2. 强制类型转换
            1. int i; byte b = (byte) i;
   2. 引用数据类型
      1. 类
      2. 接口
      3. 数组
2. 关键字
   1. this
      1. 使用this调用成员变量和成员函数
         1. class A { int a; A(int age) { this.a = age; } void intro(){ System.out.println("I'm " + this.a + " old"); } }
         2. this代表了调用这个函数或者变量的当前对象
      2. 使用this调用本类中的其他构造函数
         1. class A{ int a; int b; A (int age){ this.a = age; } A (int age, int telNumber) { this(age); b = telNumber; } }
         2. 对this的调用必须是构造函数中的第一个语句
         3. 不能在一个构造函数中同时使用本类中的其他两个构造函数
   2. static
      1. 静态成员变量
         1. class A { static int a; }
         2. 可以直接用类名来调用
         3. 所有由这个类生成的对象，都使用同一个静态变量
      2. 静态成员函数
         1. class A { static void func(){ xxx; } }
         2. 可以直接用类名来调用
         3. 静态函数中，只能使用类的静态变量，不能使用非静态变量
      3. 静态代码块
         1. class A { static { xxx; } }
         2. 装载这个类的时候，会执行静态代码块
            1. 类的操作步骤，装载->解释->执行
         3. 一般用来初始化静态变量
   3. extends
      1. 继承父类
         1. class child extends parents { xxx; }
   4. super
      1. 在子类的构造函数中，使用super调用父类的构造函数
         1. class A{ A(); } class B extends A{ B(){ super(); } }
      2. 使用super调用父类的成员函数
         1. class A{ funA(){ xxx; } } class B extends A{ funB(){ xxx; super.funA(); xxx; } }
      3. 代表父类
   5. abstract
      1. 抽象类
         1. abstract class A { xxx; }
      2. 抽象方法
         1. abstract void fun();
   6. package
      1. 用于将类封装成包
         1. javac -d [dir] 需要编译java文件
         2. package bob_package_name;
   7. public
      1. 将类或者成员设定为没有任何限制，自由访问的权限
         1. public String s;
         2. public void func(){};
         3. public class A {}
   8. private
      1. 用于限定成员或者类为私有、只能在本类中使用
         1. private class A {}
         2. private void func(){};
         3. private String s;
   9. protected
      1. 定义一个包中的父类的成员可以被其他包的子类所继承
         1. package A class A{ protected int a; }
            1. package B import A.A class B extends A{ this.a = 1; }
   10. import
       1. 包含java软件包
          1. import bob.package
          2. import bob.*
             1. 偷懒的做法
   11. interface
       1. 定义一个接口
          1. interface A{ void fun(); xxx; }
   12. implements
       1. 实现一个接口
          1. class B implements A{ xxx; }
   13. try..catch...finally
       1. 用于异常的捕捉、处理、善后
          1. try{ xxx; } catch (Exception e) { e.xxx(); } finally{ xxx; }
   14. throw
       1. 抛出异常
          1. RuntimeException e = new RuntimeException("xxx"); Exception e = new Exception("xxx"); throw e;
   15. throws
       1. 声明这个函数可能会出现异常
          1. public void func(xxx) throws Exception{ if (age < 0) { Exception e = new Exception("xxx"); throw e; } this.age = age; }
   16. final
       1. final用来声明一个常量，在程序中不能改变它，一般都用大写字母
          1. final int CONSTANT = 50;
   17. synchronized
       1. 同步代码块
          1. synchronized(this){ xxx; }
   18. instanceof
       1. 判断全面的对象是不是后面这种类型
          1. boolean b = obj instanceof User
3. 面向对象
   1. 面向对象的思维方式
      1. 首先确定谁来做，其次确定怎么做
      2. 首先考虑整体，其次考虑局部
      3. 首先考虑抽象，其次考虑具体
   2. 构造函数的作用
      1. 特征
         1. 构造函数没有返回值
         2. 构造函数的名称必须和类名相同
         3. 如果没有自己定义构造函数，编译器会在编译时加一个参数为空，函数体为空的构造函数 如果有自己定义的构造函数，编译器则什么也不做
         4. 构造函数也可以重载
   3. 继承
      1. 什么是继承
         1. 一个类得到了另一个类的成员变量和成员方法
      2. 为什么要使用继承
      3. 继承的基本语法点
      4. 生成子类的过程
      5. 使用super调用父类构造函数的方法
         1. super必须是第一条语句
         2. 子类无法继承父类的构造函数
         3. 在子类的构造函数当中，必须调用父类的构造函数
      6. 使用super调用父类的成员函数
      7. 如果子类和父类不再同一个包当中，则子类无法访问到父类当中的default权 限的成员变量和成员函数，但可以找到对应的成员变量和成员函数
   4. 封装
      1. 对象：变量和方法组成
      2. 类：是组成Java程序的基本要素。它封装了一类对象的状态和方法, 是这一类对象的原型
         1. 类声明
            1. class className { …… }
            2. 类所实现的接口以修饰符public, abstract, final
         2. 类体
            1. class className { memberVariableDeclarations methodDeclarations }
            2. 对类的成员（变量和方法）可以限定其它对象对它的访问权限，有以下几种: private, protected, public, friendly
            3. 实例成员
            4. 类成员
            5. 成员变量
            6. static限定成员变量为类变量
            7. final用来声明一个常量，在程序中不能改变它，一般都用大写字母
            8. class FinalVar{ final int CONSTANT = 50; …… }
      3. 消息：实现对象之间的交互, 同时, 处于不同处理过程甚至不同主机的对象间都可以通过消息实现交互
         1. 消息的接收者
         2. 接收对象应采用的方法
         3. 方法所需要的参数
   5. 多态
      1. 对象的转型
         1. 对象向上转型
            1. 将子类的对象赋值给父类的引用
            2. Student是Person的子类； Student s = new Student(); Person p = s;
            3. 向上转型是不会失败的
         2. 对象向下转型
            1. 将父类的对象赋值给子类的引用
            2. Student是Person的子类； Student s1 = new Student(); Person p = s1; Student s2 = (Student)p;
            3. Student是Person的子类； Person p = new Person(); Student s = (Student)p;
            4. 向下转型的前提：必须先向上转型
            5. 必须用强制类型转换
      2. 函数的重载(overload)
         1. 在同一个类中，成员函数名相同，参数列表不同，与返回值无关
      3. 函数的复写(override)
         1. 在具有父子关系的两个类中，父类和子类各有一个函数， 这两个函数的定义（返回值类型，函数名和参数列表）完全相同
   6. 抽象类
      1. 抽象函数的语法特征
         1. 只有函数定义，没有函数体的函数
            1. abstract void fun();
         2. 抽象函数必须存在于抽象类中
      2. 抽象类的语法特征
         1. 使用abstract类定义的类
            1. 抽象类不能够生成对象
            2. 如果一个类中包含有抽象函数，那么这个类必须被声明为抽象类
            3. 如果一个类中没有抽象函数，那么这个类也可以声明为抽象类
            4. 抽象类中可以有构造函数，在生成子类的时候被调用
      3. 抽象类的作用
         1. 抽象类就是用来被继承的
         2. 子类继承抽象类后，需要override抽象类中的抽象方法
            1. 这个特性可以避免漏掉有些必要的override，可以在语意与 语法上达到一致，不至于出现，编译可过，但逻辑不对的情况
         3. 可以用在设计模式的"模板"中
   7. 目的：减少重复代码
4. 异常
   1. 什么是异常
      1. 异常是中断了正常指令流的事件
      2. 异常有JVM产生
      3. 异常是一个对象
   2. 异常的分类
      1. Throwable
         1. Exception
            1. RuntimeException
            2. ........
            3. 运行时异常，Uncheck exception
            4. 编译时异常，Check exception
         2. Error
            1. JVM在运行时产生的错误，一旦产生错误，JVM就会立即关闭
   3. try..catch...finally结构的使用方法
      1. try{ int i = 1 / 0; } catch (Exception e) { e.printStackTrace(); } finally{ System.out.println("finally"); }
      2. 将可能出现异常的代码放在try{}中，如果出现异常，则程序将会跳 到catch里面去执行异常处理，无论出不出异常都会执行finally， 一般称finally为异常的出口，执行收尾工作
   4. throw抛出异常
      1. 抛出自定义异常
         1. //RuntimeException e = new RuntimeException("年龄不能为负数"); Exception e = new Exception("年龄不能为负数"); throw e;
   5. throws用于声明这个函数可能会出现异常
      1. 谁调用谁处理Exception
         1. public void setAge(int age) throws Exception{ if (age < 0) { Exception e = new Exception("年龄不能为负数"); throw e; } this.age = age; }
5. 设计模式
   1. 工厂方法模式
      1. 将new这样用于生成对象的操作封装在Factroy中， 好处是对于使用者来讲，他不用去关心Factory内部操作
         1. PinterFactory.rar
   2. 装饰者模式
      1. 被装饰者
         1. 被装饰者实现最基本的功能
      2. 装饰者
         1. 在基本功能由被装饰者实现后，对其再进行装饰。 并将被装饰者作为装饰者的一个参数传递过去
   3. 代码
      1. Decorator.rar
6. 接口
   1. 什么是接口
      1. 接口就是标准，调用对象的标准
   2. 接口的基本语法
      1. 使用interface定义
         1. 比较纯粹的抽象类，也就是说所有成员都是抽象的
      2. 接口当中的方法都是抽象方法
      3. 接口当中的方法都是public权限
      4. 实现接口使用implements关键字
         1. 实现是特殊的继承
      5. 一个类可以实现多个接口
         1. class Phone implements USB,WIFI{ xxx; }
      6. 一个接口可以继承多个接口
         1. interface C extends A,B{ xxx; }
      7. 接口支持向上转型
   3. 为什么要使用接口
      1. 用在规则一致，但实现不同的需求中
7. 零散知识点
   1. java引用与C语言指针的区别
   2. 一个引用能够调用哪些成员（变量和函数），取决于这个引用的类型
   3. 一个引用调用的是哪一个方法，取决于这个引用所指向的对象
   4. 匿名对象
      1. new Dog().jump();
      2. 因为没有对象名，所以只能用一次
   5. 现代编程思想
      1. 如果一段代码在语意上有错误的话，那么在语法上也应该有错误
   6. 一个类，一个成员变量，一个成员函数，尽量将权限限制到最小
   7. 用"=="比较两个对象的作用是：查看被比较的两个对象的引用是不是相同
8. 内部类
   1. 什么是内部类
      1. 一个类定义在另一个类的里面
   2. 内部类的使用方法
      1. _外部类的名字_&_内部类的名字_
      2. 内部类可以任意使用外部类的成员变量和成员函数
         1. 内部类仅仅可以使用外部类的资源，但不是拥有内部类的资源，这是它与继承之间的区别
   3. 匿名内部类的使用方法
      1. 在一个类中定义一个内部类（包括实现一个接口），用这个类生成一个对象，然后直接使用这个对象，这样做省去了为这个内部类起一个名字 在编译这样一个含有匿名内部类的类时，会生成类似Test$1.class这样的一个class文件
   4. 例子
      1. TestInternalClass.rar
   5. 例子
      1. TestNamelessInternalClass.rar
9. 多线程
   1. 进程和线程
      1. 多进程
         1. 在操作系统中能同时运行多个任务（程序）
      2. 多线程
         1. 在同一个应用程序中有多个顺序流同时执行
   2. 多线程程序运行模式
   3. 定义线程的方法
      1. 创建线程
         1. 定义一个线程类，它继承类Thread并重写run()方法，run()称为线程体
            1. TestThreadStart.rar
         2. 实现Runnable这个接口，在初始化一个Thread类或者子类的对象时， 把目标对象传递给这个线程实例，由该目标对象提供线程体
            1. TestThreadRunable.rar
      2. 控制线程的常用函数
         1. 中断线程
            1. Thread.sleep()
            2. Thread.yield()
         2. 设置线程的优先级
            1. getPriority()
            2. setPriority()
            3. 最大优先级 10: Thread.MAX_PRIORITY
            4. 最小优先级 1: Thread.MIN_PRIORITY
      3. 多线程数据安全
         1. 数据完整性
      4. 同步线程的方法
         1. 同步代码块
            1. TestThreadSynchronized.rar
      5. 例子
         1. TestThreadFunc.rar
10. 包和访问权限
    1. java包
       1. 什么是java中的软件包
          1. 把类放在不同的文件夹下
       2. 为什么要用软件包
          1. 避免重名文件
       3. 如何给一个类打包
          1. 将类放置到一个包当中，需要使用package "包名"，编译时 javac -d [dir]，该参数用来依照包名生成相应的文件夹
       4. 命名空间
          1. 包名的命令规范
             1. 要求包名所有的字母都小写
             2. 包名一般情况下，是你的域名倒过来写
             3. 域名：marsdroid.org 包名：org.marsdroid
             4. 一个类的全名应该是["包名"+"."+"类名"]
             5. 包名中不能有"-"
       5. 导入包
    2. 访问权限
       1. public(共用权限)
          1. 如果一个类是public的，那么它的文件名就必须和类名是相同的
          2. 在不同的几个包中，如果一个类/变量/方法是public的，那么它可以被外部包调用
       2. private(私有权限)
          1. 修饰变量和方法
             1. 只能在当前的类中使用，不能用在生成的对象中
          2. 修饰类
             1. 内部类
       3. default (包级别访问权限)
          1. 在同一个包中，不同的default class可以访问
          2. 不在同一个包中，不同的default class不可以访问
       4. protected权限与继承有关
          1. protected拥有和default一样的功能，但是该权限只能修饰成员变量和成员函数
          2. 用protected声明的成员函数和成变量所在的类作为父类，可以被不同包中的子类所继承
          3. 与public的不同：protected被限制只能在子类中使用，而public是可以被任何类使用
       5. public > protected > default > private
       6. 没有任何限制，自由访问
       7. 只能在本类中使用
       8. 在同一个包中，可以自由访问
11. 开发工具
    1. Notepad++
       1. 官网
    2. SubLime
       1. 官网
    3. Eclipse
       1. 什么是Eclipse
          1. 官网
       2. Eclipse的基本概念
          1. workspace
          2. project
       3. Eclipse界面简介
12. Object中的重要方法
    1. equals()
       1. equals函数在什么地方
          1. 在Object类中，Object在JDK中，所有类都继承了equals函数
       2. equals函数的作用
          1. 用来比较两个对象的内容是不是相同
             1. 对象的类型相同(可以使用instanceof操作符进行比较)
             2. 两个对象的成员变量的值完全相同
       3. 复写equals函数的方法
          1. TestEquals.rar
    2. hashCode()
       1. hashCode的作用
          1. 如果两个对象用equals相比是一样的，那么他们各自的hashCode也应该是一样的， hashCode与类集框架有关，用于做一些数据的索引
       2. hashCode的实现方法
    3. toString()
       1. toString的作用
          1. 用于打印对象的信息，方便调试
       2. toString的实现方法
    4. 例子
       1. TestHashCodeToString.rar
    5. 这三个函数，可以用eclipse自动生成
13. 类集框架
    1. 什么是类集框架
       1. 一组类和接口
       2. 位于java.util包当中
       3. 主要用于用于存储和管理对象
    2. 类集的种类
       1. 三大类集合、列表和映射
          1. 集合(Set)
             1. 集合中的对象不按特定的方式排序，并且没有重复对象，如果有重复元素，那么Set会忽略重复元素
          2. 列表(List)
             1. 集合中对象按照索引位置排序，可以有重复对象
          3. 映射(Map)
             1. 集合中的每一个元素包含一个键值对，键不可以重复，值可以重复
    3. 类集框架的基础结构
       1. 3个层次
          1. INTERFACE: Literator, Collection
             1. Collection接口
             2. boolean add(Object o)
             3. void clear()
             4. boolean isEmpty()
             5. remove(Object o)
             6. int size()
             7. Literator
             8. hasNext()
             9. next()
          2. INTERFACE: List, Set, Map
          3. 各种实现类
             1. HashSet
             2. TestHashSet.rar
             3. ArrayList
             4. TestList.rar
             5. HashMap
             6. TestHashMap.rar
14. 程序入口
    1. public main(String[] args)
    2. 作为applet的子类
15. 运算符和表达式
    1. 运算符
       1. 算术运算符 (+,-,*,/,%,++,--)
          1. 与C/C++不同, 对取模运算符%来说, 其操作数可以为浮点数
             1. 37.2%10=7.2
       2. 关系运算符 (＞,＜,＞=,＜=,==,!= )
          1. 返回布尔类型的值 true 或 false?
       3. 布尔逻辑运算符 ( !,&&,|| )
          1. 表达式1&&表达式2，如果表达式是false，那么表达式2不会运算，同理'||'
       4. 位运算符 (＞＞,＜＜,＞＞＞,&,|,^,～ )
       5. 赋值运算符 (=,及其扩展赋值运算符如+=)
       6. 条件运算符 ( ?:)
       7. 其它 (包括分量运算符 · ,下标运算符[],实例运算符 instance of,内存分配运算符 new,强制类型转换运算符(类型),方法调用运算符()等 )
16. 流控制
    1. 分支语句: if-else, break, switch, return
    2. 循环语句: while, do-while, for, continue
    3. 例外处理语句: try-catch-finally, throw
    4. 三种注释方式
       1. // 单行注释
       2. /* … */ 用于多行注释
       3. /** … */ 是Java所特有的doc注释
17. 数组
    1. 一维数组
       1. 定义
          1. type arrayName[]
          2. arrayName = new type[arraySize]
          3. type arrayName = new type[arraySize]
       2. 引用
          1. arrayName[index]
       3. 初始化
          1. int a[] = {1,2,3,4,5}
    2. 多维数组
       1. 定义
          1. type arrayName[][]
          2. int a[][] = new int[2][3]
          3. int a[][] = new int[2][]; a[0] = new int[3]; a[1] = new int[3];
       2. 引用
          1. arrayName[index1][index2]
       3. 初始化
          1. int a[][]={{2,3},{1,5},{3,4}}
    3. 数组的类型
18. 例子
    1. Fibonacci.tgz.gz
    2. HelloWorld.tgz.gz
    3. HelloWorld_applet.tgz.gz
    4. HelloWorld_jni.tgz.gz
    5. LeapYear.tgz.gz
    6. MatrixMultiply.tgz.gz
    7. RelationAndConditionOp.tgz.gz
    8. SimpleTypes.tgz.gz
19. I/O流
    1. I/O操作的目标
    2. I/O的分类方法
       1. 第一种分法
          1. 输入流
          2. 输出流
          3. 输入和输出是针对Java的程序而言
       2. 第二种分法
          1. 字节流
             1. 核心类
             2. InputStream
             3. FileInputStream
             4. fis = new FileInputStream("./from.txt");
             5. int read(byte[] b, int off, int len)
             6. OutputStream
             7. FileOutputStream
             8. fos = new FileOutputStream("./to.txt");
             9. void write(byte[] b, int off, int len)
             10. 无缓冲
             11. 字节流是最基本的
             12. 所有的文件在硬盘或在传输时都是以字节的方式进行的
             13. 主要用在处理二进制数据
          2. 字符流
             1. 核心类
             2. Reader
             3. FileReader
             4. fr = new FileReader("./from.txt");
             5. int read(char[] c, int off, int len)
             6. Writer
             7. FileWrite
             8. fw = new FileWriter("./to.txt");
             9. int write(char[] c, int off, int len)
             10. 有缓冲
             11. 当执行写入操作时，需要用flush()或者close()操作， 将缓冲中的数据放入到文件中
             12. 字符是只有在内存中才会形成
             13. 主要用在处理文本
             14. 这其中涉及到了Java的编码格式问题
             15. 实际开发中出现的汉字问题实际上都是 在字符流和字节流之间转化不统一而造成的
          3. 字节流和字符流之间的相互转化
             1. 字节流转化为字符流
             2. 实际上就是byte[]转化为String
             3. public String(byte bytes[], String charsetName) charsetName是用来设置字符编码的，当指定时， 会采用操作系统的lang来设定
             4. 字符流转化为字节流
             5. 实际上是String转化为byte[]
             6. byte[] String.getBytes(String charsetName) charsetName是用来设置字符编码的，当指定时， 会采用操作系统的lang来设定
       3. 第三种分法
          1. 节点流
             1. 核心类
             2. FileReader
             3. fileReader = new FileReader("./user.txt");
          2. 处理流
             1. 核心类
             2. BufferedReader
             3. BufferedReader in = new BufferedReader(FileReader实例对象);
             4. public String readLine() throws IOException
          3. 节点流与处理流的关系
             1. 节点流是被装饰者，它实现了最基本的读写文件操作； 处理流是装饰者，它在节点流的基础上添加了新的功能
             2. 处理流不仅仅只装饰节点流，还可以装饰 别的Reader，接受来自键盘或者网络的输入
    3. 读取文件和写入文件的方法
       1. 字节流
          1. 基本读写方法
             1. TestByteIO.rar
          2. 大文件的读写方法
             1. BigFileFileIO.rar
       2. 字符流
          1. 基本读写方法
             1. TestCharIO.rar
       3. 处理流
          1. 基本使用方法
             1. TestBufferedReaderIO.rar