面向对象

一、认识对象和类认识对象和类
类
理解:可以看做是一个模版，或者图纸，系统根据类的定义来造出对象。我们要造一个汽车，怎么样造？类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。
什么是类：我们叫做class。
对象：我们叫做Object,instance(实例)。我们说某个类的对象，某个类的实例。是一样的意思。
一个类中包含了{属性、方法、构造方法}
属性（field 成员变量）
属性：用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量的默认值
数据类型 默认值
整型 0
浮点型 0.0
字符型 ‘\u0000’
布尔型 false
所有引用类型 null
属性的格式：[修饰符] 属性类型 属性名 = [默认值] ;
方法（method）
方法：用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法的格式：[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}
构造器（constructor）
构造器：也叫构造方法。用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，且目的是对象的初始化。构造器的名称应与类的名称一致。（Java通过nwe关键字来调用构造器，从而返回该类的实例。）
构造器的格式：[修饰符] 类名(形参列表){
//n条语句
}
构造器4个要点：
1.构造器通过new关键字调用！！
2.构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
3.如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加！
4.构造器的方法名必须和类名一致！
二、深入解析了解类和对象的运行
JAVA虚拟机内存模型概念
JVM的内存划分中，有部分区域是线程私有的，有部分是属于整个JVM进程；我们将这部分归为一类。
1.程序计数器（Program Counter Register)，在JVM规范中，每个线程都有自己的程序计数器。这是一块比较小的内存空间，存储当前线程正在执行的Java方法的JVM指令地址，即字节码的行号。如果正在执行Native方法，则这个计数器为空。

2.Java虚拟机栈(Java Virtal Machine Stack)，同样也是属于线程私有区域，每个线程在创建的时候都会创建一个虚拟机栈，生命周期与线程一致，线程退出时，线程的虚拟机栈也回收。虚拟机栈内部保持一个个的栈帧，每次方法调用都会进行压栈，JVM对栈帧的操作只有出栈和压栈两种，方法调用结束时会进行出栈操作。该区域存储着局部变量表，编译时期可知的各种基本类型数据、对象引用、方法出口等信息。

3.本地方法栈（Native Method Stack）与虚拟机栈类似，本地方法栈是在调用本地方法时使用的栈，每个线程都有一个本地方法栈。
堆（heap）
堆（Heap）,几乎所有创建的Java对象实例，都是被直接分配到堆上的。堆被所有的线程所共享，在堆上的区域，会被垃圾回收器做进一步划分，例如新生代、老年代的划分。Java虚拟机在启动的时候，可以使用“Xmx”之类的参数指定堆区域的大小。

方法区（Method Area)
方法区与堆一样，也是所有的线程所共享，存储被虚拟机加载的元（Meta）数据，包括类信息、常量、静态变量、即时编译器编译后的代码等数据。
方法区是一种java虚拟机的规范。由于方法区存储的数据和堆中存储的数据一致，实质上也是堆，因此，在不同的JDK版本中方法区的实现方式不一样。
运行时常量池（Run-Time Constant Pool)(方法区中)
这是方法区的一部分。常量池主要存放两大类常量：
1.字面量（Literal），如文本字符串、final常量值。
2.符号引用，存放了与编译相关的一些常量，因为Java不像C++那样有连接的过程，因此字段方法这些符号引用在运行期就需要进行转换，以便得到真正的内存入口地址。

直接内存（Direct Memory）
直接内存并不属于Java规范规定的属于Java虚拟机运行时数据区的一部分。Java的NIO可以使用Native方法直接在java堆外分配内存，使用DirectByteBuffer对象作为这个堆外内存的引用。
程序执行的内存分析过程
为了让初学者顺利的分析内存，更加容易的体会程序执行过程中内存的变化，加深理解。我们将JAVA虚拟机内存模型进行简化。主要包括（虚拟机栈、堆、方法区又叫静态区）。
虚拟机栈（简称：栈）的特点如下：
1.栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）
2.JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）
3.栈属于线程私有，不能实现线程间的共享！
4.栈的存储特性是“先进后出，后进先出”
5.栈是由系统自动分配，速度快！栈是一个连续的内存空间！
堆的特点如下：
1.堆用于存储创建好的对象和数组(数组也是对象)
2.JVM只有一个堆，被所有线程共享
3.堆是一个不连续的内存空间，分配灵活，速度慢！
方法区（又叫静态区）特点如下：
1.方法区是JAVA虚拟机规范，可以有不同的实现。
i.JD7以前是“永久代”
ii.JDK7部分去除“永久代”，静态变量、字符串常量池都挪到了堆内存中
iii.JDK8是“元数据空间”和堆结合起来。
2.JVM只有一个方法区，被所有线程共享！
3.方法区实际也是堆，只是用于存储类、常量相关的信息！
4.用来存放程序中永远是不变或唯一的内容。（类信息【Class对象，反射机制中会重点讲授】、静态变量、字符串常量等）
结论：同一类的每个对象有不同的成员变量存储空间。
同一类的每个对象共享该类的方法。内存分析图例子：

参数传值机制
Java中，方法中所有参数都是“值传递”，也就是“传递的是值的副本”。 也就是说，我们得到的是“原参数的复印件，而不是原件”。因此，复印件改变不会影响原件。
基本数据类型参数的传值
传递的是值的副本。 副本改变不会影响原件。
引用类型参数的传值
传递的是值的副本。但是引用类型指的是“对象的地址”。因此，副本和原参数都指向了同一个“地址”，改变“副本指向地址对象的值，也意味着原参数指向对象的值也发生了改变”。
public class User {
int id; //id
String name; //账户名
String pwd; //密码

public User(int id, String name) {
	this.id = id;
	this.name = name;
}

public static void main(String[ ] args) {
	User u1 = new User(100, "小");
	User u3 = u1;
	System.out.println(u1.name);
	u3.name="张三";
	System.out.println(u1.name);
}
}
示例：多个变量指向同一个对象
输出结果：小
张三

垃圾回收机制(Garbage Collection)
Java引入了垃圾回收机制，令C++程序员最头疼的内存管理问题迎刃而解。Java程序员可以将更多的精力放到业务逻辑上而不是内存管理工作上，大大的提高了开发效率。
垃圾回收原理和算法
内存管理
Java的内存管理很大程度指的就是：堆中对象的管理，其中包括对象空间的分配和释放。
对象空间的分配：使用new关键字创建对象即可
对象空间的释放：将对象赋值null即可。垃圾回收器将负责回收所有”不可达”对象的内存空间。
垃圾回收过程
任何一种垃圾回收算法一般要做两件基本事情：

1. 发现无用的对象
2. 回收无用对象占用的内存空间。
   垃圾回收机制保证可以将“无用的对象”进行回收。无用的对象指的就是没有任何变量引用该对象。Java的垃圾回收器通过相关算法发现无用对象，并进行清除和整理。
   垃圾回收相关算法
3. 引用计数法
   堆中的每个对象都对应一个引用计数器，当有引用指向这个对象时，引用计数器加1，而当指向该对象的引用失效时（引用变为null），引用计数器减1，最后如果该对象的引用计算器的值为0时，则Java垃圾回收器会认为该对象是无用对象并对其进行回收。优点是算法简单，缺点是“循环引用的无用对象”无法别识别。
   通用的分代垃圾回收机制
   分代垃圾回收机制，是基于这样一个事实：不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的回收算法，以便提高回收效率。我们将对象分为三种状态：年轻代、年老代、持久代。同时，将处于不同状态的对象放到堆中不同的区域。 JVM将堆内存划分为 Eden、Survivor 和 Tenured/Old 空间。
4. 年轻代
   所有新生成的对象首先都是放在Eden区。 年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象，对应的是Minor GC，每次 Minor GC 会清理年轻代的内存，算法采用效率较高的复制算法，频繁的操作，但是会浪费内存空间。当“年轻代”区域存放满对象后，就将对象存放到年老代区域。
5. 年老代
   在年轻代中经历了N(默认15)次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。年老代对象越来越多，我们就需要启动Major GC和Full GC(全量回收)，来一次大扫除，全面清理年轻代区域和年老代区域。
6. 永久代
   用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响。JDK7以前就是“方法区”的一种实现。JDK8以后已经没有“永久代”了，使用metaspace元数据空间和堆替代。
   ·Minor GC:
   用于清理年轻代区域。Eden区满了就会触发一次Minor GC。清理无用对象，将有用对象复制到“Survivor1”、“Survivor2”区中。
   ·Major GC：
   用于清理老年代区域。
   ·Full GC：
   用于清理年轻代、年老代区域。 成本较高，会对系统性能产生影响。
   JVM调优和Full GC
   在对JVM调优的过程中，很大一部分工作就是对于Full GC的调节。有如下原因可能导致Full GC：
   1.年老代（Tenured）被写满
   2.持久代（Perm）被写满
   3.System.gc()被显示调用
   4.上一次GC之后Heap的各域分配策略动态变化
   this关键字
   对象创建的过程和this的本质
   构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步：
7. 分配对象空间，并将对象成员变量初始化为0或空
8. 执行属性值的显示初始化
9. 执行构造方法
10. 返回对象的地址给相关的变量
    this的本质就是“创建好的对象的地址”！ 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表“当前对象” 。

this最常的用法：
在程序中产生二义性之处，应使用this来指明当前对象；普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
this不能用于static方法中。
static 关键字
在类中，用static声明的成员变量为静态成员变量，也称为类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：
为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享！！
一般用“类名.类属性/方法”来调用。（也可以通过对象引用或类名（不需要实例化）访问静态成员。）
在static方法中不可直接访问非static的成员。
`public class User {
int id; // id
String name; // 账户名
String pwd; // 密码

static String company = "北京"; // 公司名称
public User(int id, String name) {
	this.id = id;
	this.name = name;
}
public void login() {
	System.out.println("登录：" + name);
}
public static void printCompany() {
	// login();//调用非静态成员，编译就会报错
	System.out.println(company);
}
public static void main(String[ ] args) {
	User u = new User(101, "小");
	User.printCompany();
	User.company = "北京阿里爷爷";
	User.printCompany();
}
}
输入：北京
北京阿里爷爷

态初始化块：构造方法用于对象的初始化！静态初始化块，用于类的初始化操作！在静态初始化块中不能直接访问非static成员。
三、面向对象的三大特点的了解
继承
继承是面向对象编程的三大特征之一，它让我们更加容易实现对于已有类的扩展、更加容易实现对于现实世界的建模。
继承有两个主要作用：
1.代码复用，更加容易实现类的扩展
2.方便对事务建模
继承让我们更加容易实现类的扩展。 比如，我们定义了人类，再定义Boy类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子(don’t reinvent wheels)。
从英文字面意思理解，extends的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。
哺乳动物继承了动物。意味着，动物的特性，哺乳动物都有；在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Student类只需要继承Person类即可拥有Person类的属性和方法。
继承使用要点
1.父类也称作超类、基类、派生类等。
2.Java中只有单继承，没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
3.Java中类没有多继承，接口有多继承。
4.子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。
5.如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。
子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

方法的重写需要符合下面的三个要点：
1.“= =”： 方法名、形参列表相同。
2.“≤”：返回值类型和声明异常类型，子类小于等于父类。
3.“≥”： 访问权限，子类大于等于父类。
方法instanceof 运算符
instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。的重写override
final关键字
final关键字的作用：
修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。
final int MAX_SPEED = 120;
修饰方法：该方法不可被子类重写。但是可以被重载！
final void study(){}
修饰类: 修饰的类不能被继承。比如：Math、String等。
final class A {}
继承和组合
我们可以通过继承方便的复用已经定义类的代码。还有一种方式，也可以方便的实现“代码复用”，那就是：“组合”。

“组合”不同于继承，更加灵活。
“组合”的核心就是“将父类对象作为子类的属性”，然后，“子类通过调用这个属性来获得父类的属性和方法”。
组合比较灵活。继承只能有一个父类，但是组合可以有多个属性。所以，有人声称“组合优于继承，开发中可以不用继承”，但是，不建议大家走极端。
继承除了代码复用、也能方便我们对事务建模。所以，对于“is -a”关系建议使用继承，“has-a”关系建议使用组合。
比如Student is a Person这个逻辑没问题，但是：Student has a Person就有问题了。这时候，显然继承关系比较合适。
再比如：笔记本和芯片的关系显然是“has-a”关系，使用组合更好。
Object类基本特性
Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类。
toString方法
Object类中定义有public String toString()方法，其返回值是 String 类型。Object类中toString方法的源码为：
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }
根据如上源码得知，默认会返回“类名+@+16进制的hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的toString()方法。
== 和equals方法
“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。
Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑。比如，我们在公安系统中认为id相同的人就是同一个人、学籍系统中认为学号相同的人就是同一个人。
Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true 否则返回 false。
super关键字
super“可以看做”是直接父类对象的引用？？？。可以通过super来访问父类中被子类覆盖的方法或属性。
使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。
若是构造方法的第一行代码没有显式的调用super(…)或者this(…);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。
封装(encapsulation)
封装是面向对象三大特征之一。对于程序合理的封装让外部调用更加方便，更加利于写作。同时，对于实现者来说也更加容易修正和改版代码。
封装的作用和含义
我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗？有必要碰碰显像管吗？制造厂家为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口，比如：电源开关。具体内部是怎么实现的，我们不需要操心。
需要让用户知道的才暴露出来，不需要让用户知道的全部隐藏起来，这就是封装。说的专业一点，封装就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
我们程序设计要追求“高内聚，低耦合”。 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。

编程中封装的具体优点：
提高代码的安全性。
提高代码的复用性。
“高内聚”：封装细节，便于修改内部代码，提高可维护性。
“低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。
封装的实现—使用访问控制符
Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。 Java中4种“访问控制符”分别为private、default、protected、public，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。
下面详细讲述它们的访问权限问题。其访问权限范围如表5-1所示。

表5-1 访问权限修饰符
修饰符 同一个类 同一个包中 子类 所有类
private √
default √ √
protected √ √ √
public √ √ √ √

1.private 表示私有，只有自己类能访问
2.default表示没有修饰符修饰，只有同一个包的类能访问
3.protected表示可以被同一个包的类以及其他包中的子类访问
public表示可以被该项目的所有包中的所有类访问
封装的使用细节
类的属性的处理:
一般使用private访问权限。
提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作（注意：boolean变量的get方法是is开头!）。
一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。
多态(polymorphism)
多态概念和实现
多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人的“休息”方法，张三是睡觉，李四是旅游，高淇老师是敲代码，数学教授是做数学题； 同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。
多态的要点：

1. 多态是方法的多态，不是属性的多态（多态与属性无关）。
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。
   对象的转型(casting)
   父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。
   向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型！在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型）否则会出现类型转换异常ClassCastException。为了避免出现这种异常，我们可以使用instanceof运算符进行判断。
   四、方法和类的使用
   抽象类和接口
   抽象方法和抽象类
   抽象方法
   使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

抽象类
包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
抽象类的使用要点:
1.有抽象方法的类只能定义成抽象类
2.抽象类不能实例化，即不能用new来实例化抽象类。
3.抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
4.抽象类只能用来被继承。
5.抽象方法必须被子类实现。
接口interface
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须能干掉坏人；如果你是坏人，则必须欺负好人。

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
接口的作用
为什么需要接口?接口和抽象类的区别?
接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。
从接口的实现者角度看，接口定义了可以向外部提供的服务。
从接口的调用者角度看，接口定义了实现者能提供那些服务。
接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。
接口和实现类不是父子关系，是实现规则的关系。比如：我定义一个接口Runnable，Car实现它就能在地上跑，Train实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现Runnable接口。

区别：普通类：具体实现
抽象类：具体实现，规范(抽象方法)
接口：规范！
如何定义和使用接口(JDK8以前)
声明格式：[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {
常量定义；
方法定义；}
定义接口的详细说明：
访问修饰符：只能是public或默认。
接口名：和类名采用相同命名机制。
extends：接口可以多继承。
常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。
要点
子类通过implements来实现接口中的规范。
接口不能创建实例，但是可用于声明引用变量类型。
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。
JDK1.8（不含8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
JDK1.8（含8）后，接口中包含普通的静态方法、默认方法。
接口中定义静态方法和默认方法(JDK8以后)
JAVA8之前，接口里的方法要求全部是抽象方法。
JAVA8（含8）之后，以后允许在接口里定义默认方法和类方法。

1. 默认方法
   Java 8及以上旧版本，允许给接口添加一个非抽象的方法实现，只需要使用 default 关键字即可，这个特征又叫做默认方法（也称为扩展方法）。

默认方法和抽象方法的区别是抽象方法必须要被实现，默认方法不是。作为替代方式，接口可以提供默认方法的实现，所有这个接口的实现类都会通过继承得到这个方法。
2. 静态方法
JAVA8以后，我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口（接口也是类，一种特殊的类），可以通过接口名调用。
如果子类中定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于子类。可以通过子类名直接调用。
3. 静态方法和默认方法

本接口的默认方法中可以调用静态方法。
接口的多继承
接口完全支持多继承。和类的继承类似，子接口扩展某个父接口，将会获得父接口中所定义的一切。
面向接口编程
面向接口编程是面向对象编程的一部分。
为什么需要面向接口编程? 软件设计中最难处理的就是需求的复杂变化，需求的变化更多的体现在具体实现上。我们的编程如果围绕具体实现来展开就会陷入”复杂变化”的汪洋大海中，软件也就不能最终实现。我们必须围绕某种稳定的东西开展，才能以静制动，实现规范的高质量的项目。
接口就是规范，就是项目中最稳定的核心！ 面向接口编程可以让我们把握住真正核心的东西，使实现复杂多变的需求成为可能。
通过面向接口编程，而不是面向实现类编程，可以大大降低程序模块间的耦合性，提高整个系统的可扩展性和和可维护性。
面向接口编程的概念比接口本身的概念要大得多。设计阶段相对比较困难，在你没有写实现时就要想好接口，接口一变就乱套了，所以设计要比实现难！

AOP:(AOP Aspect Oriented programming)面向切面编程。

String类和常量池
在Java的内存分析中，我们会经常听到关于“常量池”的描述，实际上常量池也分了以下三种：
1.全局字符串常量池（String Pool）
全局字符串常量池中存放的内容是在类加载完成后存到String Pool中的，在每个VM中只有一份，存放的是字符串常量的引用值（在堆中生成字符串对象实例）。
2. class文件常量池（Class Constant Pool）
class常量池是在编译的时候每个class都有的，在编译阶段，存放的是常量（文本字符串、final常量等）和符号引用。
3. 运行时常量池（Runtime Constant Pool）
运行时常量池是在类加载完成之后，将每个class常量池中的符号引用值转存到运行时常量池中，也就是说，每个class都有一个运行时常量池，类在解析之后，将符号引用替换成直接引用，与全局常量池中的引用值保持一致。
String类常用的方法
String类是我们最常使用的类。字符串类的方法我们必须非常熟悉！我们列出常用的方法，请大家熟悉。
String类的常用方法列表
方法 解释说明
char charAt(int index) 返回字符串中第index个字符
boolean equals(String other) 如果字符串与other相等，返回true；否则，返回false。
boolean equalsIgnoreCase
(String other) 如果字符串与other相等（忽略大小写），则返回true；否则，返回false。
int indexOf(String str) 返回从头开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串str，则返回-1。
lastIndexOf() 返回从末尾开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串str，则返回-1。
int length() 返回字符串的长度。
String replace(char oldChar,
char newChar) 返回一个新串，它是通过用 newChar 替换此字符串中出现的所有oldChar而生成的。
boolean startsWith(String prefix) 如果字符串以prefix开始，则返回true。
boolean endsWith(String prefix) 如果字符串以prefix结尾，则返回true。
String substring(int beginIndex) 返回一个新字符串，该串包含从原始字符串beginIndex到串尾。
String substring(int beginIndex,
int endIndex) 返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex-1的所有字符。
String toLowerCase()
该串将原始字符串中的所有大写字母改成小写字母。
String toUpperCase() ，该串将原始字符串中的所有小写字母改成大写字母。
String trim()
该串删除了原始字符串头部和尾部的空格。
字符串相等的判断
equals方法用来检测两个字符串内容是否相等。如果字符串s和t内容相等，则s.equals(t)返回true，否则返回false。
要测试两个字符串除了大小写区别外是否是相等的，需要使用equalsIgnoreCase方法。
判断字符串是否相等不要使用"=="。

	public static void main(String[ ] args) {
		String g1 = "北京";
		String g2 = "北京";
		String g3 = new String("北京");
		System.out.println(g1 == g2); 
// true  指向同样的字符串常量对象
		System.out.println(g1 == g3); 
// false  g3是新创建的对象
		System.out.println(g1.equals(g3));
 // true  g1和g3里面的字符串内容是一样的
	}
}
输出结果true
         False
         True