面向对象（OOP）

1、类和对象。

类：

　　主要由两个部分组成：特性（属性），功能（方法）

　　属性：描述该类型的特征。

　　　　属性，也就是在类内部的变量。

　　　　　　变量：

　　　　　　　　可分为成员变量和局部变量。（主要依据其作用域来分辨）

　　　　　　成员变量：也可以叫做全局变量。在类的内部任何地方都能调用。

　　　　　　局部变量：仅限于在你定义的那个方法块中调用。

　&&  如果一个局部变量的变量名与成员变量相同，采用“就近原则”，优先调用局部变量。而想要调用成员变量，则需要使用“this.变量名”来进行访问。

　　方法：描述该类型具有的功能。

　　　　方法可分为有参方法和无参方法。

　　　　　　有参方法：有参数的方法。他的参数叫形式参数（形参）。  什么是形式参数？ 就是这个方法中你需要使用到的参数，或者说东西。他只存在于形式上，或者说是想象中的东西。并没有实际去给他赋值。（最后由实参 赋值，这个参数才有实际意义。）

　　　　　　无参方法：没有参数的方法。

　　　　　　一个方法的创建：（包含有参，无参）

　　　　　　　　方法修饰符 返回值类型 方法名（参数类型 参数名，…） {

　　　　　　　　　　　　方法语句块（你需要执行的逻辑）

　　　　　　　　　　}

　　对象：

　　　　类的实体。需要用new关键字创建。（一个类是抽象的，而对象是实际存在的。）  所以，对象就是类的实例化。

　　　　而类的属性方法，实际上也就是对象的属性方法。一个类中会有多个对象。两者是不可分割的。但是你想要调用类的属性方法，就必须先创建对象。

　　&& 面向对象：你面向的对象，去调用他所属的类中的属性方法。当你new出一个对象的时候，实际上他所有的操作都已经在类中完成好了，展现出来的就是我们所看到的对象。

　　构造方法：

　　　　定义：方法名与类名相同，并且无返回值类型。

　　　　　　构造方法只能在new 的时候调用，用来初始化对象。

　　this关键字:

　　　　代表当前类的实例。用于区分成员变量和局部变量，调用构造方法时必须放在第一行。不允许相互调用。

　　final关键字:

　　　　表示“最终的”，“不可修改的”。用于修饰非抽象类，非抽象类成员方法和变量。final修饰的变量就是常量，必须赋值。命名规范所有字母需要大写。

　　static关键字：

　　　　static是Java中的静态修饰符，可以用来修饰成员变量（静态变量---->“类变量”--> 直接使用类名调用），成员方法（静态方法----> “类方法”--> 不可包含this关键字）和代码块（静态代码块）。

　　　　静态方法只能调用静态方法，不能调用非静态方法。

　　super关键字：

　　　　super用来指向父类的引用，可以使用super关键字来调用父类的非私有的属性和方法。必须放在第一行。

　　Object

　　　　所有类的祖先类，只要是Java中的类，就是他的子类。

Object用来 回收所有的对象。

　　方法重载：

　　　　方法名相同，方法参数不同。和方法权限，返回值无关。

　　方法重写：（方法覆盖）

　　　　方法名，返回值，参数列表 完全相同。子类权限必须大于父类。

　　　&& 区别：

　　　　概念不同，重载在本类中，重写在子类与父类中。

2、面向对象的思想。

　　面向对象的三大核心思想为：封装、继承、多态。（针对于类实现，与对象无关）

　　封装：---->  Get、Set 方法。

　　　　隐藏实现。-->（隐藏属性方法，实现细节）

　　　　权限： public > protected > default > private

　　　　好处： 1、代码安全，修改方便。

   　　　　　　 2、降低软件开发的复杂度

　　　　　　　3、避免命名冲突

　　继承：  ---->  extends

　　　　从一个类中派生出另一个类，该类继承父类的所有非私有属性和方法。

　　　　Java只能单一继承。一个子类只能有一个父类。

　　　　继承关系： IS - A  ,一个对象是另外一个对象的分类。

　　　　好处： 1、简化对事物的认识，清晰体现相关类间的 结构关系。

　　　　　　    2、提供了软件的复用性，减少代码和数据的 冗余度，增加程序的重用性。

　　　　　　　3、通过增强一致性来减少模块间的接口和界 面，大大增加了程序的易维护性。

　　多态： （编译期看左边，运行期看右边）

　　　　指允许不同类的对象对同一消息做出响应。即同一消息可以根据调用对象的不同而采用多种不同的行为方式。

　　如何实现：

　　　　1、要有继承。
　　　　2、要有重写。
　　　　3、父类引用指向子类对象。向上转型。

　　好处：

　　　　1、可替换性。

　　　　2、可扩充性。

　　　　3、接口性。

　　　　4、灵活性。

　　　　5、简化性。

　　instanceof关键字：

　　　　用来判断，instanceof左边的对象是否属于右边类或者子类的实例。

　　抽象类：  ----> abstract

　　　　一个类没有足够的信息来描述一个具体的对象，而需要其他类来支撑它，这种类称为抽象类。

　　&&注意事项：

　　　　1、抽象方法必须在抽象类中。

　　　　2、抽象类不能new实例化对象。

　　　　3、抽象方法必须由子类来进行重写。

　　　　4、有抽象方法的类必须定义为抽象类。可以有其他方法。

　　　　5、子类中的抽象方法不能有父类抽象方法同名。

　　　　6、abstract不能与final并列修饰同一个方法。

　　　　7、abstract不能与private、static、final或native并列修饰同一个方法。

　　　　接口：  ---->  interface   ---->  implements 实现接口

　　　　　　一组方法的集合，接口中只能包括 抽象方法 和 常量。

　　　　　　Java只能单一继承，但是可以多实现。

　　命名规则：  I 开头 或者 able 结尾。

　　接口特点：

　　　　1、接口不能实例化。

　　　　2、成员变量只能是常量，强制加修饰符：public static final ，不能与private和protected关键字共存。

　　　　3、没有构造方法。

　　　　4、成员方法只能是抽象方法

　　　　5、一个类可以实现多个接口、一个接口可以继承多个接口。“,”分隔。

　　　　好处：

　　　　　　1、Java不能多继承，但是可以多实现。

　　　　　　2、因为接口中都为抽象方法，代码耦合性更低。

　　　　　　接口的必要性：

　　　　　　　　　　可扩展性与可维护性。

　　　　&& 抽象类和接口的区别：

　　　　成员区别：

　　　　　　抽象类：有构造方法、抽象方法、以及其他的方法和属性。

　　　　　　接口：没有构造方法、只有抽象方法和常量

　　　　关系区别：

　　　　　　类与类：

　　　　　　　　继承关系，只能单继承，可以多层继承。

　　　　　　类与接口：

　　　　　　　　实现关系，可以单实现，也可以多实现。

　　　　　　接口与接口：

　　　　　　　　继承关系，可以单继承，也可以多继承。

　　　　设计理念不同：

　　　　　　　　抽象类： IS - A ，抽象类中定义的是共性功能。

　　　　　　　　接口：  Has - A ，接口中定义的是扩展功能。

　　设计模式 6大原则：

　　　　 1. 里氏替换： 子类不要去重写父类的实现方法，去重写父类的抽象方法。
　　　　 2. 单一原则： 一个类只做一件功能，一个方法只做一件事。
　　　　 3. 开闭原则： 不要去修改一个类，而是去继承他，在去扩展。
　　　　 4. 迪米特法则： 最少知道原则，只和朋友类交流（不要在局部中创建对象）。
　　　　 5. 接口隔离： 不要实现的时候出现无用的接口中的抽象方法
　　　　 6. 依赖倒置： 不要去依赖具体类，而是依赖接口

Java面向对象基础