1. 如何在“问题空间”（问题实际存
在的地方）的元素与“方案空间”（对实际问题进行建模的地方，如计算机）的元素之间建立理想的“一对
一”对应或映射关系。
假设：
我们将问题空间中的元素以及它们在方案空间的表示物称作“对象”（Object）
(1) 所有东西都是对象。可将对象想象成一种新型变量；它保存着数据，但可要求它对自身进行操作。理论上讲，可从要解决的问题身上提出所有概念性的组件，然后在程序中将其表达为一个对象。
(2) 程序是一大堆对象的组合；通过消息传递，各对象知道自己该做些什么。为了向对象发出请求，需向那个对象“发送一条消息”。更具体地讲，可将消息想象为一个调用请求，它调用的是从属于目标对象的一个子例程或函数。
(3) 每个对象都有自己的存储空间，可容纳其他对象。或者说，通过封装现有对象，可制作出新型对象。所以，尽管对象的概念非常简单，但在程序中却可达到任意高的复杂程度。
(4) 每个对象都有一种类型。根据语法，每个对象都是某个“类”的一个“实例”。其中，“类”（Class）是“类型”（Type）的同义词。一个类最重要的特征就是“能将什么消息发给它？”。
(5) 同一类所有对象都能接收相同的消息。这实际是别有含义的一种说法，大家不久便能理解。由于类型为“圆”（Circle）的一个对象也属于类型为“形状”（Shape）的一个对象，所以一个圆完全能接收形状消息。这意味着可让程序代码统一指挥“形状”，令其自动控制所有符合“形状”描述的对象，其中自然包括“圆”。这一特性称为对象的“可替换性”，是OOP最重要的概念之一。
>>面向对象：
基本思想：把现实生活中的事物，抽象成以对象为单元的形式，用对象的使用来完成程序功能
前提：
我们向对象发出的请求是通过它的“接口”（Interface）定义的，对象的
“类型”或“类”则规定了它的接口形式。“类型”与“接口”的等价或对应关系是面向对象程序设计的基础。
感悟：
1. 面向对象允许我们不考虑程序的细节（机器建模），而面向问题本身进行思考
2. 每个对象都隶属一个特定的“类”，那个类具有自己的通用特征与行为
3. 我们应该让“对象”做一些实际的事情，比如完成一次交易、在屏幕上画一些东西或者打开一个开关等等。每个对象仅能接受做特定的请求。
4. “接口”（Interface）规定了可对一个特定的对象发出哪些请求
基本特征：
封装：保护数据的有效性和安全性
来源：
对于特定的问题用户只需知道操作接口即可，而不必考虑其他的细节
允许库设计人员修改内部结构，不用担心会对用户造成什么影响
现象：
当我们向“对象”发送一条消息的时候，对象的职责就是决定如何对这条消息作出反应（执行相应的代码）
对于任何关系，重要一点是让牵连到的所有成员都遵守相同的规则
类的边界：
作用域这些关键字的使用和含义都是相当直观的，它们决定了谁能使用后续定
义内容。
“public”（公共）意味着后续的定义任何人均可使用
“private”（私有）意味着除您自己、类型的创建者以及那个类型的内部函数成员，其他任何人都不能访问后续的定义信息。private在您与客户程序员之间竖起了一堵墙。若有人试图访问私有
成员，就会得到一个编译期错误
“protected”（受保护的）与“private”相似，只是一个继承的类可访问受保护的成员，但不能访问私有成员
“friendly”（友好的）涉及“包装”或“封装”（Package）的概念即Java 用来构建库的方法。若某样东西是“友好的”，意味着它
只能在这个包装的范围内使用（所以这一访问级别有时也叫作“包装访问”）
案例：
封装解决如何为系统功能建模的问题，在面向对象的世界中，俺们要把系统建模成类，类也要建模为属性和方法，设计类将如何完成这些事情的过程就被称为封装
特征：属性本质上就是变量，只能存数据不能对数据进行操作
一层：对象的属性和方法不可分割.(对象)
二层:保护数据的一种机制.(属性和方法要私有化)
提供get、set方法间接操作属性(以一定的规则约束)
提供公有的方法间接操作方法
继承：提供代码的可重用性
来源：
1.简单的方案：“组织”构建一个类；新类可以由任意数量和类型的其他对象构成或者在现有类的基础上组织一个新类。这种“组织”类似一种包含关系，比如“一辆车包含了一个变速箱”。
新建类的时候，首先应考虑“组织”对象；这样做显得更加简单和利用对
象的组织，我们的设计可保持清爽。一旦需要用到继承，就会明显意识到
这一点；而不是直接考虑继承。
感悟：
这种方案构想使程序变得非常灵活，当继承并不具备这种特质，因为编译
器必须对继承创建的类加以限制
2.继承：重新使用接口
我们费尽心思做出一种数据类型后，假如不得不又新建一种类型，令其实
现大致相同的功能，那会是一件非常令人灰心的事情。但若能利用现成的
数据类型，对其进行“克隆”，再根据情况进行添加和修改，情况就显得
理想多了。“继承”正是针对这个目标而设计的。但继承并不完全等价于
克隆。在继承过程中，若原始类（正式名称叫作基础类、超类或父类）发
生了变化，修改过的“克隆”类（正式名称叫作继承类或者子类）也会反
映出这种变化
感悟：
1） 继承创建的类复制了基类的接口，当向基类对象发送消息的时候，亦可原样发给衍生类的对象。根据可以发送的消息，我们能知道类的类型。这意味着衍生类具有与基础类相同的类型！
--核心：类型的等价关系
2）基础类和衍生类具有相同的接口，所以那个接口必须进行特殊的设计；因而衍生类对象如果只是继承基类对象而不做任何行为这是没有意义的
内涵：
1. 在继承的过程中，如果我们只是试图改变基类的某种行为，这样衍生类是与基础类完全相同的类型—等价关系
2. 在继承的过程中，如果我们只是试图为衍生类添加新的接口元素，新类型与基础类并不完全相同—类似关系
案例：
继承条件是："is-a"的关系：指一个类的对象也是另一个类的对象。
把相同代码放到基类中
继承的原理：
1.继承不是真正的继承。
（1）在构造子类对象的时候，是先构造父类的对象
（2）子类有的属性就不找父类要。
super.属性--------父类的属性
this.属性---------儿子的属性
2、所有类的祖先都是：Object类
3、父类的什么东东不能被子类继承？
（1）私有的属性和方法不能被子类继承
（2）父类构造方法不能被子类继承。
4、java的继承是单继承：一个子类只能有一个父类。
java的继承是单方向的：子类没有的特征可以找父类要
但是反过来不成立。
5、当父类只有一个带参数的构造方法，子类要手动调用
父类的带参数的构造方法。
super(参数);---调用父类的构造带参数的构造方法
this(参数)：---调用子类的构造构造方法
//super.属性;-----调用父类的属性
super.方法名();----调用父类的方法
子类转父类 父类引用不能调用子类的属性和方法
父亲转儿子 父亲儿子的属性方法都可以被调用
instanceof
多态：可维护性和可扩展性
来源：
继承最终会以创建一系列类收场，所有类都建立在统一的接口基础上；对这样的一系列类，我们要进行的一项重要处理就是将衍生类的对象当作基础类的一个对象对待。这一点是非常重要的，因为它意味着我们只需编写单一的代码，令其忽略类型的特定细节，只与基础类打交道。这样一来，那些代码就可与类型信息分开。所以更易编写，也更易理解。此外，若通过继承增添了一种新类型，如“三角形”，那么我们为“几何形状”新类型编写的代码会象在旧类型里一样良好地工作。所以说程序具备了“扩展能力”，具有
“扩展性”
感悟：
1. 我们将这种把衍生类型当作它的基本类型处理的过程叫作“Upcasting”（上溯造型）
2. 对面向对象的程序设计语言来说，它们用以实现多形性的方法叫作“动态
绑定”。编译器和运行期系统会负责对所有细节的控制；我们只需知道会发生什么事情，而且更重要的是，如何利用它帮助自己设计程序
3. 多态性使得能够利用同一类(基类)类型的指针来引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作
前提：继承的内涵
内涵：
1. 多态：将一条消息发给对象时，如果并不知道对方的具体类型是什么，但采取的行动同样是正确的
--同一种行为，由于参数或者执行者不同，执行了不同的代码，得到不同结果
案例：
方法重载的多态：静态的多态
同一种行为，由于参数不同，执行了不同的代码，得到不同结果。
--参数个数不同
--参数类型不同
--参数顺序不同
方法名相同，参数不同，与返回值无关
方法重写的多态：动态多态
同一种行为，由于执行者不同，执行了不同的代码，得到不同结果。
重写： 三相同一放大：
方法名 参数 返回值都相同
子类重写的方法的作用域不能比父类小。
重写的多态的条件：
·继承
·要有方法重写
·父类引用指向子类的对象
重写与重载区别：
--重写：执行者不同 重载:参数不同
--重载：可以写到子类中也可以写到父类中
重写：只能写到子类中
--方法重载多态是：静态多态
方法重写多态是：动态的多态
父类引用指向子类对象，只能能访问被子类重写的方法
>>类：object 对象的集合
属性：静态特征 定义数据
方法：动态特征 定义功能
--无参数无返回的方法
--无参数有返回的方法
--有参数无返回的方法
--有参数有返回的方法
构造方法：初始化（出生行为）
特点：在new的时候被系统自动调用
一个类如果没有写构造方法：系统自动添加一个无参数
无方法体的构造方法，形式上东西。
一个类有构造方法：系统不会自动添加构造方法。
对比：构造方法初始化对象，不能改变，初始化很方便。
set方法初始化对象很麻烦，但是方便修改。
tatic：静态的
static用在属性前面：
作用：
静态的属性是属类所有，与对象个数没有关系。：班费
非静态的属性属对象所有，与对象的个数有关。：个人的钱
静态的方法不能调用非静态的方法:
静态方法在new之前就在内存中，
非静态的方法是在new的时候才被加载到内存中。
静态块与普通块
执行顺序：静态块---普通块----构造方法
静态(属类所有)只会被执行一次，普通块（属性所有）每new一次都会被调用一次。
this:只能指向对象前类对象
自己定义的引用：可以指向不同的类对象
this引用调用构造方法,this(参数)必须在构造方法的第一句。
final关键字的用法:
--用在变量前面：------常量
--用在属性属性: ------常量
--用在方法的前面：方法不能被重写 能被重载
--用在类前面:这个类不能被继承：
抽象类：abstract
--有些类比较的抽象，方法体不好怎么样写。定义成抽象的方法。
--包含抽象方法的类，必须定义成抽象类。抽象类中可以没有抽象方法
--抽象类不能实例化，但是可以定义引用。
--抽象类是一个类，有构造方法 有属性 有普通方法。
--一个类继承一个抽象类，必须重写抽象类中的所有的抽象方法
如果只要有一个抽象方法没有被子类重写，这个子类只能定义成抽象类
接口：一组功能的约定 interface implements
特征：
--接口中的方法默认都是抽象方法：
public abstract : 不能修改
--接口的中的属性都是：常量 定义的同时必须赋值
默认都是：
public final :也不是能改
--接口中不能有构造方法也不能有普通方法
--一个接口可以继承多个接口：多继承
一个类只能继承一个类
--一个类可以实现多个接口：多实现
--一个类继承接口必须重写接口中所有的抽象方法，
只要有一个没有被重写，这个类只能定义成抽象类。
--接口也是不能实例化。但是可以定义引用
接口与抽象类的区别：
1.相同点：
（1）都不能实例化，但是都可以定义引用
（2）一个类去继承一个抽象类或者实现接口都要重写
抽象类或者接口中的抽象方法。
2.不同点:
(1)接口中属性都是常量，但是抽象类的属性不一定、
(2)接口中的之能有抽象方法，抽象类可以没有抽象方法。
（3）接口中没有构造方法，和普通方法，抽象类中可以有
（3）接口是多继承：抽象类是单继承
（4）一个类可以实现多个接口 ，但是只能继承一个类