面向对象的思想，体现的是人所关注的信息聚集在了一个具体的物体上。
人们就是通过对象的属性和行为来了解对象。
类
类是封装 对象的属性和行为 的载体，反过来说具有相同属性和行为的一类实体被称为类。
类的定义：
- 类是相同或相似对象的一种抽象，是对象的一个模板，它描述一类对象的行为和状态。
- 类是具有相同属性和方法（行为）的对象的集合。
- 属性 是对象具有的特征。
每个对象的每个属性都拥有特定值。 - 行为：在计算机中我们通过方法去实现对象的行为，而对象的方法便是对象所具有的操作。
- 属性 是对象具有的特征。
定义一个类：
-
定义类名，用于区分不同的类。
class 是声明类的关键字，类名后面跟上大括号，大括号里面就是类的一些信息。
public 为权限修饰符。 -
编写类的属性。
对象有什么，需要通过属性来表示。
属性的定义是写在类名后面的大括号里，在定义属性时，要明确属性的类型。
在一个类当中可以写一个或多个属性。也可以不定义属性。 -
编写类的方法。
方法写在大括号里面。
可以定义一个方法或多个方法，也可以不定义方法。
一个类可以包含以下类型变量：
- 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。
- 变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
- 成员变量：定义在类中，方法体之外的变量。
- 这种变量在创建对象的时候实例化。
- 成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为static类型。
在使用时注意，成员变量可以被本类的所有方法所使用，同时可以被与本类有关的其他类所使用；而局部变量只能在当前的方法中使用。
作用域可以简单地理解为变量的生存期或者作用范围，也就是变量从定义开始到什么时候消亡。
- 局部变量的作用域仅限于定义它的方法内；
而成员变量的作用域在整个类内部都是可见的。 - 同时在相同的方法中，不能有同名的局部变量；
在不同的方法中，可以有同名的局部变量。 - 成员变量和局部变量同名时，局部变量具有更高的优先级。
对象
(类可以看成是我们自己定义的数据类型)
定义类的时候不会为类开辟存储空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。
创建对象后，我们就要使用对象了，使用对象无非就是对属性和方法进行操作和调用。
构造方法
每个类都有构造方法，在创建该类的对象的时候它们将被调用，如果没有定义构造方法，Java编译器会提供一个默认构造方法。
创建一个对象的时候，至少调用一个构造方法。
比如在新建一个 new object() ，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。
构造方法的名称必须与类名相同。
一个类可以定义多个构造方法。
构造方法的具体内容：
- 构造方法的名称与类名相同，且没有返回值。
上面例子中 通过 new关键字 将类实例化成对象，而 new 后面跟的就是构造方法。
于是可以知道 new+构造方法 可以创建一个新的对象。 - 如果在定义类的时候没有写构造方法，系统会默认生成一个无参构造方法，这个构造方法什么也不会做。
- 当有指定的构造方法时，系统不会再添加无参构造方法了。
- 构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。
引用与对象实例
在新建对象实例时，需要为对象实例设置一个对象名。
那么变量object就真的是Object对象么？
这里其实只是创建了一个object对象的引用。
这里和C语言的指针一样，变量object保存的其实是Object对象的引用，指向了Object对象。
运行得到的结果为true，说明 object1 和 object2 的内存地址相同（==会比较两个对象的内存地址是否相同），它们实际上是引用同一对象，如果改变 object1 对象内部的属性，那么 object2 的属性同样会改变。
static
静态成员
Java中 static 修饰的成员称为静态成员或类成员。
它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。
静态成员可以使用类名直接访问，也可以使用对象名进行访问。
静态方法
被 static 修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用。
由于不实例化也可以调用，所以不能有 this，也不能访问非静态成员变量和非静态方法。
但是非静态成员变量和非静态方法可以访问静态方法。
final
- final 修饰类：该类不允许被继承，为最终类。
- final 修饰方法：该方法不允许被覆盖（重写）。
- final 修饰属性：该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值。（但只能选其一）
- final 修饰变量：该变量的值只能赋一次，即常量。
权限修饰符
权限修饰符可以用来修饰属性和方法的访问范围。
- private：其修饰的属性或者方法，只能在当前类中访问或者使用。
- 默认：什么修饰符都不加，默认在当前类中和同一包下都可以访问和使用。
- protected：其修饰的属性或者方法，对同一包内的类和所有子类可见。
- public：其修饰的属性或者方法，对所有类可见。
举例：
比如 money
private 代表这是私有的，只能我自己使用；
protected 代表我可以使用，和我有关系的人，比如儿子也可以使用；
public 代表所有人都可以使用。
封装
封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。
这样做的好处：
- 只能通过规定的方法访问数据。
- 隐藏类的实例细节，方便修改和实现。
举例：
我们在开汽车的时候，只用去关注如何开车，我们并不在意车是如何实现的，这就是封装。
如何实现类的封装：
- 修改属性的可见性，在属性的前面添加修饰符（private）；
- 对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问；
- 在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定。
如果我们没有在属性前面添加任何修饰符，我们通过对象就可以直接对属性值进行修改，没有体现封装的特性。
这在许多程序设计中都是不安全的，所以我们需要利用封装，来改进我们的代码。
getter 方法命名是get关键字加属性名（属性名首字母大写）。
getter 方法一般是为了得到属性值。
setter 方法命名是set关键字加属性名（属性名首字母大写）。
setter 方法一般是给属性值赋值，所以有一个参数。
this
this 关键字代表当前对象。
使用 this.属性 操作当前对象的属性，this.方法 调用当前对象的方法。
用 private 修饰的属性，必须定义 getter 和 setter 方法才可以访问到。
创建好了 getter 和 setter 方法后，我们发现方法中参数名和属性名一样。
当成员变量和局部变量之间发生冲突时，在属性名前面添加 this 关键字。
此时就代表将一个参数的值赋给当前对象的属性。
同理 this 关键字可以调用当前对象的方法。
继承
继承可以看成时类与类之间的衍生关系。
举例：
狗类是动物类，牧羊犬类是狗类。
狗类继承了动物类，牧羊犬类继承了狗类。
狗类是动物类的子类（或 派生类），动物类是狗类的父类（或 基类）。
继承需要符合的关系是：is-a，父类更通用，子类更具体。
释： “D is a B”，类D是另一个类B的子类，类B是类D的父类。
例如：我们定义了一个Animal类，再创建一个Dog类，我们需要它继承Animal类。
Dog类继承了父类Animal，所以Dog类拥有Animal类的全部方法和属性（除开private方法和属性）。
为什么需要继承？
如果有两个类相似，那么它们会有许多重复的代码，导致后果就是代码量大且臃肿，后期的维护性不高。
通过继承就可以解决这个问题，将两段代码中相同的部分提取出来组成一个父类，实现代码的复用。
继承的特点：
-
子类拥有父类除private以外的所有属性和方法。
-
子类可以拥有自己的属性和方法。
-
子类可以重写实现父类的方法。
-
Java中的继承是单继承，一个类只有一个父类。
注：Java实现多继承的一个办法是 implements（实现）接口，但接口不能有非静态的属性，这一点请注意。
super
super关键字在子类内部使用，代表父类对象。
- 访问父类的属性 super.属性名。
- 访问父类的方法 super.bark()。
- 子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super() 。
方法重载与重写
方法重载
方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或者参数的个数。
方法重载一般用于创建一组任务相似但是参数不同的方法。
方法重载有以下几种规则：
- 方法中的参数列表必须不同（如：参数个数不同 或者 参数类型不同）。
- 重载的方法中允许抛出不同的异常。
- 可以有不同的返回值类型，但是参数列表必须不同。
- 可以有不同的访问修饰符。
方法重写
子类可以继承父类的方法，但如果子类对父类的方法不满意，想在里面加入适合自己的一些操作时，就需要将方法进行重写。
并且 子类在调用方法中，优先调用子类的方法。
在方法重写时要注意，重写的方法一定要与原父类的方法语法保持一致，比如 返回值类型，参数类型及个数，和方法名都必须一致。
多态
多态是指允许不同类的对象对同一消息做出响应。
即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
通俗地讲，只通过父类就能够引用不同的子类，这就是多态，我们只有在运行的时候才会知道引用变量所指向的具体实例对象。
多态的实现条件：继承、重写、向上转型（即父类引用指向子类对象）。
只有满足上述三个条件，才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
多态的实现方式：继承父类进行方法重写、抽象类和抽象方法、接口实现。
向上转型
比如：Dog类是Animal类的子类：
在这里，可以认为由于Dog继承于Animal，所以Dog可以自动向上转型为Animal，所以b是可以指向Dog实例对象的。
注：
不能使用一个子类的引用去指向父类的对象，因为子类对象中可能会含有父类对象中所没有的属性和方法。
如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。
但是对于只存在与子类的方法和属性就不能获取。
向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写（方法名、参数都相同）。
抽象类
在定义类时，前面加上abstract关键字修饰的类叫抽象类。
抽象类中有抽象方法，这种方法是不完整的，仅有声明而没有方法体。
那我们什么时候会用到抽象类呢？
- 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
也就是说，抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。 - 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
由上可知，抽象类是限制规定子类必须实现某些方法，但并不关注实现细节。
抽象类实现规则：
- 用 abstract 修饰符定义抽象类。
- 用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
- 包含抽象方法的类就是抽象类。
- 抽象类中可以包含普通的方法，也可以没有抽象方法。
- 抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。
接口
接口用于描述类所具有的功能，而不提供功能的实现，功能的实现需要写在实现接口的类中，并且该类必须实现接口中所有的未实现方法。
注意：
Java 8 以前：
- 接口不能用于实例化对象。
- 接口中方法只能是抽象方法、default 方法、静态方法。
- 接口成员是 static final 类型。
- 接口支持多继承。
Java 8 以后：
- 接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。
多继承实现方式：
内部类
将一个类的定义放在另一个类的定义内部，这就是内部类。
而包含内部类的类被称为外部类。
内部类的主要作用如下：
- 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
- 内部类的方法可以直接访问外部类的所有数据，包括私有的数据。
- 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。
- 内部类允许继承多个非接口类型。
注：
内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类，编译完成后出现 outer.class 和 outer$inner.class 两类。
所以内部类的成员变量/方法名可以和外部类的相同。
成员内部类
成员内部类的使用方法：
- Student 类相当于 People 类的一个成员变量，所以 Student 类可以是一个任意访问修饰符。
- Student 类在 People 类里，所以 访问范围在类里 的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）。
- 定义成员内部类后，必须使用外部类对象来创建内部类对象，即 内部类 对象名 = 外部类对象.new 内部类(); 。
- 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如 a.this 。
注：
成员内部类不能含有 static 的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。
静态内部类
静态内部类通常称为嵌套类。
静态内部类是 static 修饰的内部类。
这种内部类的特点是：
- 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。
- 如果外部类的静态成员与内部类的成员名称相同，可通过 类名.静态成员 访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过 成员名 直接调用外部类的静态成员。 - 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类(); 。
局部内部类
局部内部类，是指内部类定义在方法和作用域内。
局部内部类也像别的类一样进行编译，但只是作用域不同而已，只是在该方法或条件的作用域内才能使用，退出这些作用域后无法引用。
匿名内部类 （理解的不好）
匿名内部类，顾名思义，就是没有名字的内部类。
正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。
使用匿名内部类有个前提条件：必须继承一个父类或实现一个接口。
匿名内部类是不能加访问修饰符的。
注：new 匿名类，这个类要先定义。如果不先定义，编译时会报错该类找不到。
当所在的方法的形参需要在内部类里面使用时，该形参必须为 final。
这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。
因为匿名内部类没有名字，是用 默认的 构造函数的，无参数的，如果需要该类有带参数的构造函数，示例如下：
这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造函数所使用，所以不必定义为 final。
package
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用：
- 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
- 包采用了树形目录的存储方式。
同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。 - 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
如何在不同包中使用另一个包中的类？
使用 import 关键字。
比如要导入包 com.shiyanlou 下 People 这个类，import com.shiyanlou.People; 。
如果 import com.shiyanlou.*; 这是将包下的所有文件都导入进来，*是通配符。
包的命名规范是全小写字母拼写。
以上内容全部源自网络，为个人学习总结，非商业用途，如有任何版权问题，请联系本人，侵删。
转载：https://blog.csdn.net/weixin_43847458/article/details/104829054