1) 封装(成员、方法定义、构造方法、访问控制、内部类、static、final)

 a.成员和方法的定义，内存结构
   JVM内存可以分为：方法区、堆、栈
   方法区：持久类的信息（类的定义、方法代码、 静态的成员） 
           持久（类在第一次被使用时，装入方法区，JDK的核心类是在JVM启动的时候自动装入的）、唯一（只会装入一次）
   堆：通过new关键字创建的对象
       持有（被引用指向、在集合中）、
       回收（当对象不再被持有时）
   栈：在方法中声明的局部变量
       方法调用完之后即会清空
  b.构造方法
    初始化成员变量
    子类的构造方法必须调用父类的构造方法，为了保证子类中从父类继承的成员被妥善的初始化
    一般情况下Java类都要提供一个无参的构造方法
  c.访问控制
    类（为内部） public defualt     
    成员 public protected default private
    public 封装对外提供的功能
    尽量要保证其稳定性
    要对参数进行合法性验证，保证其健壮性
    //IllegalArgumentException
    必须妥善的处理异常
    private 一个类中，多个方法中的公共部分
    protected 多个类中的冗余部分，在父类中封装
    
    成员变量和属性的区别!!!
    
    设置emp对象的xxx属性为“goodman”
    等价于调用emp的setXxx("goodman")
    
    获取emp对象的xxx属性
    等价于String name = emp.getXxx();

  d.内部类
  公有类  public
  包内类  default
  内部类  定义在一个类内部（多线程）
  匿名类  定义在一个方法中

  e.static
  static方法
  定义在类中的一个方法，
  该方法不对该类的对象进行操作
  其操作仅仅和输入相关（参数）
  定义在该类中完全是出于逻辑上的考虑
  static成员
  static final 常量在编译的时候会被替换为常量值
  定义该常量的类甚至都不会被加载

  f.final
  类前很少写final，动态代理
  方法前写final，防止方法被无意中重写
  

 2) 类和类之间的关系（关联、依赖、继承）
     关联
     public class A {
       private B b;
       public A() {
           b...
       }
     }
     public class B {
     
     }
     依赖
     public class A {
       public void f(B b) {}
       public B g() {}
     }
     public class B {
     
     }

   
    关联优于继承（如果仅仅是重用，不需要继承）
    依赖优于关联（如果仅仅是一个方法要用到，不需要关联）

 3) 多态(抽象类、接口)

    Pet P  = new Cat();
    Growsable g = new Cat();


*4) 常见的设计模式

 1) String、StringBuilder、（Commons）
    String类
    String str1 = "abc";
    String str2 = "abc";
    int length()
    String name = ....; 
    boolean b = "whatisjava".equals(name)
                            .equalsIgnoreCase
    int indexOf(String str)
    int indexOf(String str, int fromIndex)
    
    String substring(int start, int end)
    String[] split(String regx)
    String trim()

    StringBuilder 
    StringBuilder append(...)
    StringBuilder delete(int start, int end)
    StringBuilder insert(..., int fromIndex  

 2) Date、Calendar、SimpleDateFormat
    java.util.Date
    Date d = new Date();
    long getTime();
    void setTime(long m);

    java.util.Calendar
    
    Calendar c = Calendar.getInstance();

    c.set(Calendar.YEAR, 2013);
    c.set(Calendar.MONTH, 9)
    c.set(Calendar.DAY, 1)
    System.out.println(c.get(Calendar.DAY_OF_WEEK));


 SimpleDateFormat
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String str = sdf.format(new Date());
Date date = sdf.parse(str);


 3) 集合框架、ArrayList、HashMap

 如何选取List和Map：

 List 线性表 排序，按下标索引
 Map  查找表 查找
Map<String,Student> map = ...
map.put(stu.getName(),stu);
map.get("zhangsan");

 class Student {
   private String name;
   private String score;
   ... ... ...
 }

常见的实现类：
 ArrayList, LinkedList
 HashMap, TreeMap

常用的方法：
 List<E>
   追加：add(E e); 
   插入：add(int index, E e);
   删除：remove(E e);   （和equals）
         remove(int index);
   获取：E get(int index);
   更改：E set(int index, E e)
   set(i, list.set(j, list.get(i)));
   是否包含：contains(Object o) （和equals）
   
   清空：clear();
   大小：size();
   
   addAll,removeAll 
   
 Map<K,V>
    put(K k, V v);
    V get(K k)
    boolean containsKey(K k)

    遍历：
    Map<String, Object> map = 
             new HashMap<String, Object>();
    Set<String> keys = map.keySet();
    for (String key : keys) {
   System.out.println(key+":"+map.get(key));
    }
  

 4) FIS/FOS、BIS/BOS、ISR/OSW、BR/PW、OIS/OOS
    
    文件流（节点）连接文件
    FileInputStream
    FileOutputStream
   
    缓存流（处理）
    通过内部的缓冲区提高读写效率
    BufferedInputStream
    BufferedOutputStream
   
    字符转化流（处理）
    把字节数据根据特定的编码转化成字符
    InputStreamReader
    OutputStreamWriter

    字符缓存流（处理）
    readLine可以一次读取一行字符
    BufferedReader

    字符打印流（处理）
    print,println
    可以把各种数据转化为字符串形式输出
    PrintWriter

    对象流（处理）
    writeObject
    readObject
    对象的序列化和反序列化
    ObjectInputStream
    ObjectOutputStream


    拷贝文件
    FIS fis = new FIS("src");
    FOS fos = new FOS("dest");
    BIS bis = new BIS(fis);
    BOS bos = new BOS(fos);
   
    int b = -1;
    while((b=bis.read())!=-1) {
       bos.writer(b);
    }

    bis.close();
    // bos.flush();
    bos.close();

    读写文本文件

    FOS fos = new FOS("src.txt");
    OSW osw = new OSW(fos, "utf-8");
    osw.write("你好");
    osw.close();


    FIS fis = new FIS("dest.txt");
    ISR isr = new ISR(fis,"utf-8");
    char c = (char)isr.read();
    isr.close();

    读文本文件，一次读一行
    FIS fis = new FIS("dest.txt");
    ISR isr = new ISR(fis,"utf-8");
    BR br = new BR(isr);
    String line = br.readLine();
    br.close();

    将各种数据信息的字符串表示输出到文件中
    FOS fos = new FOS("log.txt");
    OSW osw = new OSW(fos);
    PW pw = new PW(osw);
    pw.println(emp);
    pw.println(250);
    pw.println("hello");
    ... ... ... 

    从控制台输入一行数据
    BR br = new BR(new ISR(System.in));
    String line = br.readLine();


    从Socket中输入数据（文本）
    InputStream is = socket.getInputStream();
    ISR isr = new ISR(is);
    BR br = new BR(isr);
    
    
    向Socket中输出数据（文本）
    OutputStream os = socket.getOutputStream();
    OSW osw = new OSW(os);
    PW pw = new PW(osw);
    

 5) 多线程和网络

 a. 线程和进程的区别
    进程操作系统的多个任务（不同的内存）
    线程是在一个进程中的多个任务 （同一内存）
 b. Java语言中创建线程的方法
    public class MyThread extends Thread {
       public void run() {...}
    }
    MyThread t = new MyThread();
    t.start();

    public class Some implements Runnable {
        public void run() {...}
    }
    Thread t = new Thread(new Some());
    t.start();


    public class BO {
      private class MyThread extends Thread { 
          public void run() {...}
      }
    }
  
  c. 线程的状态和相互转换

  d. 线程同步
     多个线程访问同一个可变的对象
     访问的方法加锁（效率下降）
     synchronized
 
     public void f() {

         ... ... ...

       synchronized(obj) {

         XXX XXX XXX
       }

         ... ... ...

     }

 e.线程安全API
 StringBuffer   --  StringBuilder 
 Vector *       --  ArrayList
 Hashtable *    --  HashMap
 Collections的方法对List和Map的同步