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;
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. 一个类，一个成员变量，一个成员函数，尽量将权限限制到最小
8. 包和访问权限
   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. 在同一个包中，可以自由访问
9. 程序入口
   1. public main(String[] args)
   2. 作为applet的子类
10. 运算符和表达式
    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,强制类型转换运算符(类型),方法调用运算符()等 )
11. 流控制
    1. 分支语句: if-else, break, switch, return
    2. 循环语句: while, do-while, for, continue
    3. 例外处理语句: try-catch-finally, throw
    4. 三种注释方式
       1. // 单行注释
       2. /* … */ 用于多行注释
       3. /** … */ 是Java所特有的doc注释
12. 数组
    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}}
13. 例子
    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
14. 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)
          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)
       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