面向对象特性

面向对象

面向过程开发,一步一步去完成功能,施工者
面向对象开发,组合不同的对象(类)完成功能,指挥者
面向对象优点：

1. 将来便于维护和扩展
2. 代码易于管理

面向对象特性
默认情况 三大特性：封装、继承、多态。
四大特性：封装、继承、多态、抽象。

封装

通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。

多实现
实现多个接口，使用 英文逗号 分隔,必须实现所有接口的所有方法

实现接口的关键字：implements

只能定义一种类型的属性和方法
属性: 只能定义 public static final 类型的常量
方法: 只能定义 public abstract 类型的方法；通常可以省略 public abstract , 系统会自动补全

接口和抽象类

相同点：

必须有子类,子类必须要重写所有的抽象方法

都只能创建实现了方法的子类对象

不同点

如下表格

	接口	抽象类
修饰的关键词	interface	abstract class
继承或实现的方式	class 子类 impenments 接口1, 接口2…	class 子类 extends 抽象方法
继承限制	没有单继承限制	单继承
方法体中内容	全局常量 、 抽象方法	构造方法 、普通方法 、 抽象方法 、 static 方法 、 常量 、 变量
方法体中权限	只能使用public 权限	可以使用多种权限

继承

继承特性 : 单根性 , 传递性

继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。
构造方法

super调用：如果父类没有无参的构造方法,那么子类的构造方法中, 必须指定调用父类那个有参的构造方法,否则报错；例如：super(name, age, sex)。一旦指定调用父类某个构造方法,就不会再去调用父类的无参构造方法。

继承构造函数执行顺序：先执行父类的构造方法，再构造子类

多态

多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。
多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对 A 系统来说都是透明的。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。
运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2. 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

“多态”(Polymorphic)也叫“动态绑定”(Dynamic Binding)、“迟绑定”(Late Binding)，指“在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际类型调用其相应的方法。”即指子类的引用可以赋给父类，程序在运行时根据实际类型调用对应的方法

方法的重载和重写是实现多态的方式。

重载 和 重写

方法的唯一性 : 方法名+ 参数类型 + 参数个数

重载：同一个类中多个方法,方法名相同,参数类型 或 个数不同
重写：子类和父类方法,方法名相同,参数相同

不同点：

	重写	重载
返回类型、方法名、参数	要完全一致	与返回类型无关，方法名一致，参数列表中参数的顺序、类型、个数不同
存在范围	父类和子类之间	同一个类中
使用情况	构造方法不能被重写，声明为final的方法不能被重写，声明为static的方法不能被重写，但是能够被再次声明
访问权限	不能比父类中被重写的方法的访问权限更低	没有限制
抛出异常限制	重写的方法能够抛出任何非强制性异常（UncheckedException非运行时异常），不管被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以	没有限制
	运行时的多态性	编译时的多态性

注：不同权限修饰符区别

修饰符	当前类	同包	子类	其他包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

重写

方法重写指的是当子类继承父类的时候，从父类继承过来的方法不能满足子类的需要，子类希望有自己的实现，这时需要对父类的方法进行重写，方法重写是实现多态和动态绑定的关键。

如果父类是抽象类，重写的方法是抽象方法则override关键字可以省略，否则必须写override关键字。

重载

抽象

抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

抽象接口 缺省适配模式

所谓“抽象接口”，即在提供接口的同时，提供一个抽象类，用抽象类实现该接口(实际上这是缺省适配模式)。
通过接口和抽象类的结合，避免了在实现接口的子类中出现大量的“无意义”实现，这个“无意义”实现，被缓冲到了抽象类中，完美展现了代码复用（可以把抽象类理解成接口和实现类之间的缓冲）。
需要指出的是，我们既可以选择继承抽象类，也可以选择实现接口，并不是说一定要继承抽象类，看情况而定，这里是两种选择，两个机会。
向接口中新增的方法，可以在实现接口的抽象类中缓冲一下，提供一个默认的实现，这样一来，就不必强制所有的子类(通过继承抽象类间接实现接口的类)都进行修改，可以形象的理解为“没有惊动子类”。而需要使用这个方法的子类，直接重写即可。

/**
 * 假设有一个顶层接口
 */
public interface ITestInterface{
     void method1();
     int method2();
     boolean method3();
}
 
/**
 *   抽象类abstract实现了ITestInterface顶层接口
 */
public abstract class TestAbstract implements ITestInterface{
	//找出接口中必要的方法，也就是子类必须实现的方法，定义成抽象方法，交由子类实现
    public abstract void method1();
    public abstract int method2();
     
    //一些独特的方法可以在抽象类中默认实现
    public boolean method3(){
        return true;
    }
}

/**
 *   普通类TestClass1继承了TestAbstract抽象类
 */
public class TestClass1 extends TestAbstract{
	//TestClass1必须实现抽象的method1方法，该方法最早是接口中定义的
    public void method1(){}
    
    //TestClass1必须实现抽象的method2方法，该方法最早是接口中定义的
    public int method2(){
    	return 1;
    }
    //接口中的method3方法对于TestClass1无关紧要，因此不做重写。
}

/**
 *  普通类TestClass2继承了TestAbstract抽象类
 */
public class TestClass2 extends TestAbstract{

	//TestClass2必须实现抽象的method1方法，该方法最早是接口中定义的
    public void method1(){}
    
    //TestClass2必须实现抽象的method2方法，该方法最早是接口中定义的
    public int method2(){
    	return 2;
    }
    
    //method3方法对于TestClass2来说至关重要，因此必须重写。
    public boolean method3(){
    	return false;
    }  
}

最高层的接口被一个抽象类实现，在抽象类中，我们把关键的method1、method2方法定义成抽象方法，强制子类去实现，而“独特”的method3方法在抽象类中做一个默认实现。
　　　　等到TestClass1、TestClass2继承TestAbstract抽象类时，优势就体现出来了，TestClass1、TestClass2必须实现method1、method2，但如果用不到method3，可以直接无视。
　　　　接口中新增加了方法String method4();抽象类默认实现，TestClass1、TestClass2可以选择要不要重写改方法；