1.面向对象的三大特点：
（1）封装；a.将属性和方法放在独立的类中，使之成为独立的代码单元；
b.通过权限修饰符（private、public、protected等）实现对类内部信息的隐藏或公开，提供尽量少的方法访问或修改类内部的信息；
（2）继承；子类extends父类，将拥有父类的除private修饰方法和属性（同一包中）；java只支持单继承，即一个子类只有一个父类；
（3）多态；包括继承、接口、重载等等‘
2.方法重载overloaded和覆盖overriden；
overloaded：（1）重载时只能通过不同的参数完成，如不同的参数类型，不同的参数个数，不同的参数顺序；
（2）不能通过访问权限、返回类型、抛出的异常进行重载；
（3）方法的异常类型和数目不会对重载造成影响；
（4）不能在子类对父类中的private方法重载。
overridden:(1) 子类的方法名、参数个数、参数类型必须和父类中所覆盖的方法完全相同；
(2) 子类的方法返回类型必须和所覆盖的方法相同；
(3) 子类方法不能缩小所覆盖方法的访问权限；
(4) 子类方法不能抛出比所覆盖方法更多的异常；
3.this和super；
this：是指当前对象， 用法： （1）调用本类中的属性，也可以作为参数传递，eg.：this.xxx。
（2）调用本类中的其他方法，如this(a,b)；
（3）调用本类中的其他构造方法，调用时要放在构造方法的首行。
super:是指父类对象；用法:（1）调用父类的属性和方法，super.xxx/super.ff();
（2）调用父类的构造方法，只能放在当前构造方法的首行；
4.final和static：
final：（1）修饰变量则改变量为常量。final MAC=100；
（2）修饰方法则该方法不能被重写，修饰类则该类不能被继承；
static：（1）修饰变量则改变量为静态变量，即此类的实例共享此变量，它不为任何实例所有，只分配一次内存地址，调用“类名.变量”；
（2）修饰方法则该方法不需要实例对象就可调用，调用“类名.方法”。
（3）一般普通类不允许声明为静态的，只有内部类才可以，此时这个内部类作为一个普通类来使用，而不需实例一个外部类。
（4）static block：形式static｛...｝，静态代码块在类被加载时就执行，且只被执行一次，可用来类属性的初始化；
5.finalize（）方法和Ststem.gc（）方法：
finalize（）：在从堆中永久删除对象之前，垃圾回收器调用该对象的Finalize方法。注意，无法确切地保证垃圾回收器何时调用该方法，
也无法保证调用不同对象的方法的顺序。
System.gc（）：垃圾回收机制。
6.单态设计模式：保证在整个系统中只存在某个类的一个实例对象。类的构造方法必须声明为private，即防止外部new新的实例对象；提供一个返回唯一实例对象的方法getInstance（）；
e.g.：public class Singleton{
private static final Singleton s = new Singleton()；
private Singleton(){}
public Singleton getIntance(){
return s;
}
}
7.内部类InnerClass：成员内部类、局部内部类、静态内部类和匿名内部类。
（1）成员内部类；作为外部类的一个成员存在，与外部类的属性、方法并列，成员内部类中不能定义静态变量,但可以访问外部类的所有成员。访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。
（2）局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。
局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。
（3）静态内部类： 静态内部类定义在类中，任何方法外，用static定义，成为了普通类。
（4）匿名内部类 ：一种特殊的局部内部类，只是为了获得一个对象实例，不需要知道其实际类型。
8.抽象类和接口
（1）抽象类：由关键字abstract修饰的类，包含abstract修饰的方法，即含有方法定义没有具体实现方法的类，也可以包含实现的方法；
继承抽象类的子类必须实现父类的抽象方法；
public abstract class Ex{
abstract void ff();
void ff1();
}
（2）接口interface:一系列方法定义的集合，它不提供实现接口的具体代码，只提供一系列方法的定义，它所包含的方法都是public
abstract修饰的方法（可省略不写）；接口中定义的变量是final static修饰的；接口没有构造方法；类与接口之间的代码复用关系叫实现，
一个类可以实现多个接口。
interface Runnable｛
void run();
｝
class Fish implements Runnable{
public void run()
{ System.out.println("The fish is swimming!");}
}
class Bird{
public void run implements Runnable()
{ System.out.println("The bird is flying!");}
}
接口回调技术：
Runnable r1=new Fish();
ri.run();//接口回调
接口编程的好处：尽量降低系统的耦合度；将标准的制定者和实现者分离；接口尽量简单、单一；
9.线程：进程在执行过程中的一条执行线索；
创建线程的两种方法：(1)继承Thread类；class T extends Thread{} new T().start();
(2)实现Rnnable，调用Thread类的构造方法；
class T implements Runn｛public void run（）｛...｝｝ new Thread(new T()).start();
实现线程同步的两种方法：
（1）Synchronized代码块；
class A{}
class Adder(){ A a；synchronied(a)｛...｝}
class Getter(){A a；synchronied(a)｛...｝}
（2）Synchronized类；
class A { public synchronized void add(){} public synchronized void get(){}}
class Adder implements Runnable{ private A a; public Adder(A a){this.a=a;}public void run(){q.add()}}//添加数据
class Getter implements Runnable{ private A a; public Getter(A a){this.a=a;}public void run(){q.get()}}//读取数据
public class Test{public static void main(){A a=new A();}new Thread(new Adder(a)).start() ;
new Thread(new Getter(a)).start() ;
}
10.异常Exception"程序在运行的时候肯能出现的非致命性错误，程序提供了处理这些错误的方法；
try{}cath(Exception e){}finally{}；try部分放置可能出现异常的语句，cath负责捕获异常并作出相应的处理，finally部分是否抛出异
常都会执行；
throw：手动地抛出异常对象；throws声明方法可能回避的异常，即抛出异常后，必须处理，如果不想处理，就通过throws把异常往上传
递给上层处理；
