面向对象主要有四大特性：封装、抽象、继承和多态。各自定义：
封装：在面向对象语言中，封装特性是由类来体现的，我们将现实生活中的一类实体定义成类，其中包括属性和行为（在Java中就是方法），就好像人类，可以具有name,sex,age等属性，同时也具有eat(),sleep()等行为，我们在行为中实现一定的功能，也可操作属性，这是面向对象的封装特性；
抽象：抽象就是将一类实体的共同特性抽象出来，封装在一个抽象类中，所以抽象在面向对象语言是由抽象类来体现的。比如鸟就是一个抽象实体，因为抽象实体并不是一个真正的对象，它的属性还不能完全描述一个对象，所以在语言中体现为抽象类不能实例化；
继承：继承就像是我们现实生活中的父子关系，儿子可以遗传父亲的一些特性，在面向对象语言中，就是一个类可以继承另一个类的一些特性，从而可以代码重用，其实继承体现的是is-a关系，父类同子类在本质上还是一类实体；
多态：多态就是通过传递给父类对象引用不同的子类对象从而表现出不同的行为，多态可为程序提供更好的可扩展性，同样也可以代码重用。
1.Date t=new Date(); 有2部分，new Date()构造了一个Date类型的对象(Java对象都存储在堆中)，
而对这个对象的引用存储在对象变量t中。Java对象变量与C++的引用不同，在C++没有空引用,并且
应用不能被赋值。可以将java的对象变量看作C++的对象指针。Java中的null引用对应C++中的NULL指针。
2.静态方法是一种不能向对象实施操作的方法，所以不能在静态方法中访问域。
在两种情况下使用静态方法:
1).一个方法不需要访问对象状态，其所需参数都是通过形参提供
2).一个方法只需要访问类的静态域。
3.不要在getXX方法中返回可变对象的引用。如:
public Date getDate(){
return date;
}
private Date date;
原因：破坏封装性，令一变量如newDate=A.getDate(),则newDate就可以修改Date类的私有域。
若要返回引用，应该首先进行克隆(clone): return (Date)date.clone()。
静态域与静态方法
1.静态域又名类变量，即所有实例共享这一个变量；
2.静态方法是一种不能向对象实施操作的方法，所以不能在静态方法中访问实例域，但它可以访问类中的静态域。
为什么NumberFormat类不利用构造器完成这些操作呢?两个原因:
1).无法命名构造器。构造器的名称必须与类名相同。但这里，希望得到的货币实例和百分比实例采用不同的名字；
2).当使用构造器时，无法改变所构造的对象类型。而Factory方法将返回一个DecimalFormat类对象(NumberFormat的子类).
不管是静态变量，静态方法，还是静态块，都是在类加载的时候执行的；而初始化块等是类实例化时调用的。
一个类的运行，JVM做会以下几件事情 1、类装载 2、链接 3、初始化 4、实例化；而初始化阶段做的事情是初始化静态变量和执行静态方法等的工作。
方法参数(形参)
一个方法不能修改一个基本数据类型的参数；
一个方法可以改变一个对象参数的状态(形参为对象变量);
一个方法不能实现让对象参数引用一个新的对象。
注：Java重载(返回类型不是方法签名的一部分).
多态:一个对象变量可以引用多种实际类型的现象
动态绑定:在运行时能自动选择调用哪个方法的现象。
1.对于变量(不管静态变量还是实例变量)，都是静态绑定，静态绑定对应声明的对象变量类型。(编译时)
2.而对于方法，private、static、final方法是静态绑定，其他的都为动态绑定，动态绑定对应对象类型。(运行时)
即Father f=new Son(); f.field和f.static_method()调用超类即Father的成员，要访问子类变量，可以用getX()和setX()方法。
其他形式则调用子类即Son的成员。
注:超类方法为private时编译无法通过。
3.在覆盖一个方法时，子类方法不能低于超类方法的可见性。
抽象类
1.包含一个或多个抽象方法的类本身必须被声明为抽象的；
2.除了抽象方法之外，抽象类还可以包含具体数据和具体方法；
3.扩展抽象类时，若只定义超类的部分抽象方法，则子类也应为抽象类；若全部定义，则子类不是抽象的。
4.抽象类不能实例化。所以抽象类的对象变量不能引用抽象子类的对象。
注:Abstract[] a=new Abstract[]; //声明抽象对象数组，并非实例化。
Object重要方法
1.equals方法
在Object中equals比较的是引用(即内存地址)，等同于==;所以，在没有覆盖equals方法的类中，比较的是引用；
而覆盖equals方法的类，根据具体实现来判断，一般比较的是内容，如String类的equals方法。==则始终是地址。
更详细的参考下图。
2.hashCode
散列码(hash code)是由对象导出的一个整数值，并且它是没有规律的。不同的对象散列码一般不同。如果重新定义equals
方法，就必须重新定义hashcode方法，以便用户可以将对象插入到散列表中。Equals与hashCode的定义必须一致：如果
x.equals(y)返回true，那么x.hashCode()就必须与y.hashCode()具有相同的值。
接口：
1.接口中的所有方法自动地具有public属性；接口不能含有实例域(final常量除外，且常量属性自动为public static final)，
也不能在接口中实现方法。
2.同继承一样，实现接口时，必须提供不低于上面一层(接口或超类)的访问权限。所以必须把方法声明为public。
3.同抽象类一样，接口也不能实例化，可以声明接口变量但必须引用实现了接口的类对象。
接口与抽象类：每个类只能扩展一个(抽象)类，而可以实现多个接口(多继承)
克隆
Object类中clone是protected方法，对本包和所有的子类(包括包外)可见。但是用自己编写的类调用clone方法测试了一下，
运行时抛出CloneNotSupportedException异常，且说明了clone是本地方法。为什么不能直接调用？？？原因就在下面:
必须实现Cloneable接口，并且可以不提供clone方法。
部分代码示例：
| 代码如下 | 复制代码 |
| public class Son extends Father implements Cloneable{ public static void main(String[] args) throws Exception{ Son s=new Son(); s.A(); //调用Father类的A(),输出串"A" Son s1=(Son)s.clone(); s1.A(); } } |
|
输出结果: A A
浅拷贝：默认的克隆操作，它并没有克隆包含在对象中的内部对象。但是若实例域中的对象是不可变或者是基本类型
(不需要重定义clone方法，但推荐重定义并调用Object的clone：super.clone())；
深拷贝：在浅拷贝的基础上，克隆对象中的内部对象(必须重定义clone方法)。
要想一个类可以被clone，必须满足两点:
第一，它必须实现了Cloneable接口，否则会抛出CloneNotSupportedException异常；
第二，它必须提供一个public的clone方法，也就是重写Object.clone()方法，否则编译不能通过。
另外，对于存在可变域的类，在clone方法中需要对这些可变域进行拷贝(深拷贝)。
注：Object 类本身不实现接口 Cloneable，所以在类为 Object 的对象上调用 clone 方法将会导致在运行时抛出异常。
Cloneable接口并没有定义任何方法，它只是作为一个标记，表面要进行克隆处理。
内部类：
1.成员内部类
简述：作为外部类的一个成员存在，与外部类的属性、方法并列。可以在外部类方法中实例化内部类对象来访问内部类方法。
成员内部类的对象有一个隐式引用，它引用了实例化该内部对象的外部类对象。通过这个指针，可以访问外部类对象的任何域和
方法。 但内部类不能定义静态成员(静态内部类除外)。
特殊语法：
外部类引用表达式OuterClass.this；
内部对象构造器：outerObject.new InnerClass(parameters)；
注： 在外部类的作用域之外，则可以用OuterClass.InnerClass来引用内部类。
2.匿名内部类
语法格式：
| 代码如下 | 复制代码 |
| new SuperType(construction parameters) { inner class methods and data } |
|
SuperType是接口，则内部类就要实现这个接口；SuperType是一个类，则内部类就要扩展它。
3.静态内部类：使用内部类只是为了隐藏，可以将内部类声明为static，取消对外部类的引用。可以将它看作外部类的静态成员。
4.局部内部类：
在一个方法中定义局部类。不能用public或private访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。
并且除了这个方法之外，没有其他的方法知道局部内 部类的存在，但是可以用外部类对象调用该方法来间接访问内部类。在
内部类中可以访问内部类的局部变量(即方法内的变量)，但是变量必须是final的。
下面通过一个具体示例来体会一下多态的魔力。
有一个父类A：
Java代码
| 代码如下 | 复制代码 |
|
public class A { public void methodA() { System.out.println("This is Parent of A."); } } public class A { public void methodA() { System.out.println("This is Parent of A."); } } |
|
父类A有以下三个子类：
| 代码如下 | 复制代码 |
|
Java代码 public class B1 { public void methodA() { System.out.println("This is Children of B1."); } } public class B2 { public void methodA() { System.out.println("This is Children of B2."); } } public class B3 { } public class B1 { public void methodA() { System.out.println("This is Children of B1."); } } public class B2 { public void methodA() { System.out.println("This is Children of B2."); } } public class B3 { } |
|
上面的子类B!和B2都重写了父类A的方法methodA，而B3则没有。下面我们用实际的调用语句看一看。
| 代码如下 | 复制代码 |
|
1. A a1 = new A(); 2. A a2 = new B1(); 3. A a3 = new B2(); 4. A a4 = new B3(); 5. a1.methodA(); 6. a2.methodA(); 7. a3.methodA(); 8. a4.methodA(); 以上语句的运行结果会如下： This is Parent of A. This is Children of B1. This is Children of B2. This is Parent of A. |
|