面向对象；

1、什么是面向对象？

面向对象就是当有需求时找到这个需求的（类）东西进行操作。

什么是对象？

对象就是实在在在存在new的个体（现实生活中存在的个体），

并且这个对象是由这个某个派系【类种】所产生的，所有这个派系的的行为，属性！

什么是面向对象编程？

①.面向对象编程就是找所要实现功能的类。

找到了这个类之后创建出一个对象，通过对象来调用其所需的功能（行为 / 方法）

②.如果没有这个类，则自己创建出一个类，

在通过创建这个类的对象调用所定义好的方法（函数）

③.如何一个项目都是由一个一个的类组成的，如同人的世界。

       面对对象就是：

把数据及对数据的操作方法放在一起，

作为一个相互依存的整体——对象。

对同类对象抽象出其共性，形成类。

类中的大多数数据，只能用本类的方法进行处理。

类通过一个简单的外部接口与外界发生关系，

   对象与对象之间通过消息进行通信。

  程序流程由用户在使用中决定。

      面向过程就是：

自顶向下顺序执行，

逐步求精；

其程序结构是按功能划分为若干个基本模块，

这些模块形成一个树状结构；

各模块之间的关系尽可能简单，

在功能上相对独立；每一模块内部均是由顺序、

选择和循环三种基本结构组成；

其模块化实现的具体方法是使用子程序。程序流程在写程序时就已决定。

面向对象的作用？

1、更加符合了人类的思想，需要什么就去特定的地方去找，而到了这个地方，对象需要什么

则由对象的调用者（人的大脑 / 人的需求）来决定

    如果没有能够实现需求的这个地方则自己创造一个，当以后还需要只是需要再次回来

    这个地方使用！

● 类的成员；属性，方法函数，构造函数，内部类（局部内部类），代码块

A、属性；代表着这个类的信息，而这个信息的表现可以通过方法（行为），表现出来的形态

 取决于对象。 属性的类型取决于这个类的用途！

 也称为 | 实例变量 |。

B、方法（函数）；方法就是一个类的表现形态（行为），方法经常和属性共同使用

 方法也是一个功能是实现。

 而这个方法的具体产生结果则由，对象的调用者来决定。

C、构造函数（构造器）；是用来初始化属性的，因为有一些属性在类一开始就需要进行赋

值，如同人的一出生就有确定了的血型。

D、内部类；如同人是一个类，里面还有一个心脏类

  ①、内部类

     i；创建内部类的对象。

          外部类.内部类 对象名 = new 外部类.new内部类()

          外部类.内部类 对象名 = 外部类.new 内部类();

     ii；调用内部类的方法。

          new 外部类.内部类().方法

          对象名.方法

     iii；调用 与 区分外部类的属性；

      外部类.this.属性名 / 方法名

      使用this来区分

   ②、局部内部类；

      i；局部内部类调用方法的局部变量要使用final修饰（是在JDK8.0之前的）

         8.0之后的新特性自动添加了。

      ii；局部内部类创建对象只能通过外部类的方法返回或者

        在外部类方法中使用开始调用内部类的方法。

      iii；通过 外部类.this.属性名 / 方法名 来调用或者区分

★ 注；

内部类可以被4种修饰符修饰，也可以被final

abstract static 修饰

内部类中可以有属性有方法，也可以调用外部类的属性方法。

内部类在运行时会class文件的名是使用 【外部类名$内部类名】命名的

内部类可以继承别的类实现接口，但是不能被别的类继承

另； 内部类可以和其他外部类同名，但不可以和本外部同名。

内部类可以继承其他外部类，其他外部类无法继承，内部类。

E；代码块；

 是随着类的加载而加载的；

 用于属性的初始化，代码块内部的变量初始化，某些要求。。。

 可以有输出语句

      小结；当以上的 类的 五大成员被不同的关键字修饰是会有不同的效果

      如同不同的衣服穿上并且不同的颜色也会产生不同的效果！

关键字的用途用法；

1.static；静态

a、static可以修饰属性，方法，代码块，内部类。

b、只要被static修饰都是存放于内存中的静态域，并且是〓随着类的加载而加载，随着类

  的消失而消失 〓 而且▲只有一个，无论创建了多少个对象。

c、因为被static修饰的都是被所有类所共享的。

d、可以通过 类名.X （被static修饰）

e、static修饰的方法，代码块，内部类（调用父类也一样），只能调用静态的属性，方法。

      反之e     f、非static 修饰的方法，代码块，内部类可以调用static的修饰的。

2.final；最终

a、final可以修饰类，属性，方法，内部类。

   被final修饰的类，属性，方法，内部类都代表的是

        最终类，    最终属性(要显示的赋值)  ，    最终方法 ，最终内部类。

      不可以被继承 & 并且变量名要大写（全部）& 不可以重写 & 不能被其他内部类继承

b、final常常和static 一起使用    static final 表示全局变量

c、可以用于局部变量，成员变量。

3.abstract；抽象

a、abstract可以修饰方法和类。

b、abstract修饰的方法那么该类一定是抽象类。

c、abstract修饰的类是不可以创建对象的。

d、abstract修饰的类可以有构造器（是类都有构造器）

e、abstract不能和static final一起使用。

f、abstract修饰符只有3个public procteted default

g、abstract类被继承了，如果父类有抽象方法子类要重写，不重写则子类要声明为abstract

注； h、abstract修饰的方法是没有方法代码体的！

abstract常作为中层设计模块，接口则作为顶层设计模块

柜子类          木头

◆ 注；接口是一个特殊的抽象类（没有构造器）

4权限修饰符；

1.public； 公共的

 无视包环境。

2.protected； 受保护

  在不同的包，但是有继承关系的。

3.default；缺省，默认

  在本包下调用。

4.private；私有

  只能在本类下调用

5.package；包

包名写法规则；全小写无论有多少个单词。

      如果是由域名组成的，则对域名进行一个反写

      避免包名重复

用处；常作为一个小模块的分类（个人理解）

     利于编程，使得重名的类名在编译时不会产生覆盖

   解决类的重名问题。

6.import；导入

 通常作为类库的类调用时导入

 也作为调用自定义类，在不同的包下（模块）进行一个调用，使得代码的复用性更强。

7.main；主要

作为程序的入口。

可以有修饰符

可以有返回值（void / 引用类型/ 基本数据类型）

可以有形参列表

■ 注；方法名尽量做到见面思意。

8.this；这个

可以修饰属性，方法，构造器

 用处；a、用于区分成员变量和局部变量

       b、调用本类的其他方法（区分重载）

       c、调用本类的构造器（区分重载）

 ◆ 注；当声明类中的方法，变量，构造器，是代表this这个类的属性，这个类的这个方法，这个类

         的这个构造器

          常用于本类。

9.super；超级

可以用于修饰方法，属性，构造器

（常）用于与继承关系的子父类中的。

  用处；a、用于显示声明调用父类的方法，成员变量，构造器。

        b、一般用于区分子父类之间的方法（属性不是private），属性（可以区分父类重载的方法）

c、用于显示的调用父类的构造器（也可以区分父类重载的构造器）

    注；

（常）用于子父类之间，子类显示的声明调用父类的，属性，方法，构造器。

一、封装

1.权限修饰符；一般是通过权限修饰符来实现封装

四种权限修饰符都可以，视环境而定。

  一般使用private修饰【属性】向外部隐藏。另外提供get,set方法来使用属性。

2.作用以及好处；

1.提高重用性

|-----> 2.提高安全性（使得调用者无法直接的修改类的属性）

| 3.向外部隐藏细节（调用者不需要知道底层是怎么运行的，只需要结果）

|-----> 4.提供get、set方法可以过滤非法数据（如；青蛙的手脚都是成双成对的出现）

3.用途；

用于属性，方法，构造器

不可以用于代码块，代码块是随着类的加载而加载，以及初始化（分静态，非静态）。

一般是使用权限修饰符来体现封装新

★可以使用this关键字来区分成员变量与局部变量重名的。

常用在构造函数，set方法以及其他

和显示的调用本类重载的构造器

以及显示的调用本类的重载方法

◆另； 重载；

    构造器和函数（方法）都可以构成重载

前提；

    1、方法名同名，构造函数名同名，

    2、形参类型不同，个数不同，顺序不同

    ■  无视返回值类型。

作用；

利于程序员编写程序。

代码利于阅读，调用。

使得程序在同一个属性下可以实现多个功能，便于调用者调用。(只需要一个名字)

二、继承

什么是继承？

现实生活中的继承，其2个类本有类型关系的（木头）！

至于继承的属性，方法都是取决于个人！

继承；子类可以继承父类的方法，属性（受限权限修饰符）<-----------

    当父类无法满足子类时，子类可以重写父类的方法。|

|

   另；重写；|

     ①、要有继承关系|

|

     ②、父类方法权限修饰符要是符合子类环境。<-----------

      如果不符合则无法重写，子类依然可以继承，

      但是限于权限修饰符子类无法获取（无法使用）。

       a、子类重写父类的方法的返回值类型，方法名，必须要和父类一样

       b、子类重写父类方法，子类重写的方法权限修饰符必须是要大于

        或者等于父类方法的权限修饰符。

◆注；private修饰的是无法重写。

c、如果父类的方法返回值类型时一个 类 而子类重写这个方法的返回值类型

只能是这个返回值 类 的子类或者是  与父类一样

子类返回值类型必须是要小于或者是等于父类

1.作用及好处；

1、提高代码的复用性

2、使得类与类之间产生关系（便于程序的编写，符合人类思想）

3、子类对父类的内容的扩展，使得子类的功能更加富有弹性。

缺点；耦合性密切。

3.用途；

用于两个类之间，而这两个类之间是属于同一个类型的。

不要求子类一定要和父类的方法（行为）是一样的，

因为父类的方法可能不适合子类

          ∴ 注；如果父类的方法是抽象的，子类要进行重写，否则子类也要显示的声明为abstract

4.用法；

◆ 注；继承不可以乱继承，继承时需要符合人类思想（现实生活）

1.条件,有继承关系，

2. 子类重写父类一定返回值，形参，权限修饰符要符合

三、多态

什么是多态？

一种事物的多种表现形态，根据代码的继承关系，使得代码的表现形式更加有弹性。

弹性指，向上转型和向下转型。

为什么要有多态？

使得程序更有弹性，当一个父类被多个子类继承时，

接收的类型只需要指名是父类类型就可以，不需要直接

使用单一的类型来接收。

★ 也叫做 向上转型★

◆注；一个类就是一个类型

而且可以使得父类可以调用子类的特有的方法，可以使得程序代码更富有

健壮性和弹性，以及代码的效率。

条件；

必须要有继承关系。

而且子类要重写父类的方法（视环境，返回值，形参类型）。

  因为；如果没有重写父类的方法会导致没有意义，最终调用的还是父类的方法。

1.作用以及好处；

      使得程序更加富有健壮性，和弹性，以及代码的效率。

2.用途；

子父类关系，而且子类重写了父类的方法。

用于当返回值，形参类型使用父类作为类型。

使得程序更加富有弹性。而不必创建大量的构造方法

3.用法

向下转型和向下转型。

多态可以应用如下3个；还有一个 正常修饰的类

1.接口

什么是接口？

接口是一个特殊的抽象类，接口没有构造函数，而且接口的形参修饰符

是固定的public static final 修饰的

方法是 abstract void修饰的

接口之间直接可以互相继承，并且接口的继承是 唯一的 多继承

接口不会继承任何一个类的，用于顶层设计void 修饰的

2.抽象类

抽象类用在多态也是可以的

3.条件

继承和重写

注；多态在调用静态方法时，是默认调用父类的，

因为静态不可以被继承。