面向对象程序设计概述
面向对象的程序设计（简称OOP）时当今主流的程序设计范型，已经取代了“结构化”过程化程序设计开发技术，Java是完全面向对象的。
类
类设计构造对象的模板或蓝图，由类构造对象的过程称为创建类的实例。
封装（有时称为数据隐藏）是与对象有关的一个重要概念，从形式上看，封装不过是将数据行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式，封装给对象赋予了“黑盒”特征，这是提高重用性和可靠性的关键。
对象
对象的三个主要特征：
1.对象的行为：可以对对象施加哪些操作，或者可以对对象施加哪些方法？
2.对象的状态：当施加那些方法时，对象如何响应？
3.对象的标识：如何辨别具有相同行为与状态的不同对象？
同一个类的所有对象实例，由于支持相同的行为而具有家族式的相似性，对象的行为是用可调用的方法定义的。
方法：在Java中，方法就是用来完成解决某件事情或实现某个功能的办法。
类之间的关系
在类之间，最常见的关系如下：
1.依赖：即“uses-a”关系，是一种最明显的/最常见的关系。如果类B的方法操纵类A的对象，则说类B依赖于类A。
2.聚合（也叫关联）：即“has-a”关系，是一种易于理解的关系。如果类B的对象包含类A的对象，则意味着聚合关系。
3.继承：即“is-a”关系，是一种用于表示特殊与一般的关系的。 如果类B扩展类A，类B不但包含从类A继承的方法，还可以拥有很多自定义的额外功能。
预定义类
预定义类，就是指JDK中或者其他的jar包中已经定义好可以直接使用的类（如：String类，Math类，Date类，Arrays类等）。
在Java中，没有类就无法做任何事情。
对象与对象变量
要想使用对象，就必须先构造对象，并指定其初始状态，然后对对象应用方法。
在Java程序设计语言中，使用构造器构造新实例，构造器是一种特殊的方法，用来构造并初始化对象。
构造器具有以下特征：
1.构造器与类同名。
2.每个类可以有一个以上的构造器。
3.构造器可以有0个、1个或多个参数。
4.构造器没有返回值。
5.构造器总是伴随着new操作一起调用。
以Date类为例，其构造器名为Date，想要构造一个Date对象，需要在构造器前面加上new操作符：
new Date();
这个对象被初始化为当前的日期和时间。
如果需要的化，这个对象也可以作为一个参数传递给一个方法：
System.out.println(new Date());
也可以将一个方法应用与这个对象，Date类中有一个toString方法：
String s = new Date().toString();
当希望构造的对象可以多次使用时，可以将对象存放在一个变量中：
Date date = new Date();
注意：
一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。
在Java中，任何对象变量的值都是对存储在另一个地方的一个对象的引用。new操作符的返回值也是一个引用。
Date date;
声明了一个Date类型的date变量，现在date作为一个对象变量，可以引用Date类型的对象，但其本身不是一个对象，也没有引用对象。此时不能将任何Date方法应用于这个变量上。
Date date;
String str = a.toString();
将会产生编译错误。
必须首先从初始化变量date，才能使用toString方法：
Date date = new Date();
String str = a.toString();
用户自定义类
用户自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供用户使用。
Java代码映射成现实事物的过程就是定义类的过程。
类的定义格式：
创建java文件，与类名相同：
public class 类名{
数据类型 属性名称1；
数据类型 属性名称2；
…
5 }
例如：创建一个名为Employee的类：
1 public class Employee {
2 private String name;
3 private double salary;
4
5 public Employee(String n, double s){
6 name = n;
7 salary = s;
8 }
9
10 public String getName(){
11 return name;
12 }
13 public void setName(String name) {
14 this.name = name;
15 }
16
17 public double getSalary(){
18 return salary;
19 }
20 public void setSalary(double salary) {
21 this.salary = salary;
22 }
23
24 public void raiseSalary(double byPercent){
25 double raise = salary * byPercent / 100;
26 salary += raise;
27 }
28 }
这里自定义创建了的Employee类，包含name和salary两个域（属性），Employee()和raiseSalary()两个方法，其中Employee()方法为构造方法。
注意：
raiseSalary()方法有两个参数。
第一个参数称为隐式参数，是出现在方法名前的Employee类对象。
如下程序所示，关键字this表示隐式参数。
1 public void raiseSalary(double byPercent){
2 double raise = this.salary * byPercent / 100;
3 this.salary += raise;
4 }
第二个参数位于方法名后面括号中的数值（double byPercent），这是一个显式参数。
程序中getName()和getSalary()方法为访问器方法，setName()和setSalary()方法为更改器方法。
通过private私有化域name，在通过访问器方法和更改其方法进行访问和更改域值的方式，就是简单的封装了。
final实例域
可以将实例域定义为final，构建对象时必须初始化这样的域。
必须确保在每一个构造器执行后，这个域的值被设置，并且在后面的操作中，不能再对它进行修改。
final修饰符大都应用于基本类型域，或不可变类的域。（如果类中的每个方法都不会改变其对象，这种类就是不可变类，例如：String类。）
1 class Employee {
2 private final String name;
3
4 public String getName(){
5 return name;
6 }
7 }
将Employee类中的name域声明为final，这样在对象构建之后，这个值不会再被修改，即没有setName()方法。
静态域与静态方法（static）
静态域
1 class Employee {
2 private static int stacId = 1
3 private int id;
4 }
类中将stacId定义为static，那么这个类的所有的实例将共享一个static域stacId，即使一个实例对象都没有，这个静态域仍然存在。
但是如果这个类有2个实例对象，则有2个实例域id。
静态方法
静态方法是一种不能向对象实施操作的方法，可以认为静态方法是没有this参数的方法。
1 class Employee {
2 private static int stacId = 1
3 private int id;
4
5 public static int getStacId(){
6 return stacId;
7 }
8 }
静态方法getStacId 不能访问id实例域，因为它不能操作对象，但是可以访问自身类中的静态域。
对象构造
重载
Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。
程序有可能针对各种（例如同类运算：加法）不同种情况（2个数相加、3个数相加）都各自定义一个方法，如果每个方法的名称都不相同，在调用时就很难分清哪种情况该调用哪个方法，重载存在的意义就是解决这个问题，使用相同的方法名对各种不同情况做处理。
默认域的初始化
如果再构造器中没有显式的给域赋予初值，那么就会被自动的赋予为默认值（数值型为0，布尔型为false，对象引用为null）。
无参数的构造器
很多类都包含一个无参数的构造器，对象由无参数构造器创建时，其状态会设置为适当的默认值（即构造器中初始化的值）。
若编写一个类时，没有编写构造器，那么系统就会提供一个无参数构造器。这个构造器将所有的实例域设置为默认值（数值型数据设置为0，布尔型数据设置为false，所有对象变量设置为null）。
若类中提供了至少一个构造器，但是没有提供无参数的构造器，则在构造对象时如果没有提供参数就会被视为不合法，将会产生错误。
参数名
首先是参数的命名问题。
1 public Employee(String n, double s){
2 name = n;
3 salary = s;
4 }
这样做有一个缺陷，只有阅读代码才能了解参数n和s的含义。
有两种方式避免这个问题：
1.在每个参数前面加一个“a”：
1 public Employee(String aName, double aSalary){
2 name = aName;
3 salary = aSalary;
4 }
2.基于这样的事实：参数变量用同样的名字将实例域屏蔽起来，但是可以采用this.xxx的形式：
1 public Employee(String name, double salary){
2 this.name = name;
3 this.salary = salary;
4 }
调用另一个构造器
关键字“this”引用方法的隐式参数，但是它还有另一个含义。
若构造器的第一个语句形如this(…)，这个构造器将调用同一个类的另一个构造器。
1 public class Employee {
2 private String name;
3 private double salary;
4 private static int stacId = 1;
5
6 public Employee(String name, double salary){
7 this.name = name;
8 this.salary = salary;
9 }
10
11 public Employee(double salary){
12 this("Employee #" + stacId, salary);
13 stacId++;
14 }
15
16 public String getName(){
17 return name;
18 }
19 public void setName(String name) {
20 this.name = name;
21 }
22
23 public double getSalary(){
24 return salary;
25 }
26 public void setSalary(double salary) {
27 this.salary = salary;
28 }
29
30 public void raiseSalary(double byPercent){
31 double raise = this.salary * byPercent / 100;
32 this.salary += raise;
33 }
34 }
创建一个测试；Employee类的测试类：
1 public class EmployeeTest {
2 public static void main(String[] args){
3 Employee employee = new Employee(100);
4 }
5 }
通过debug可以看到Employee(double)构造器将调用Employee(String,double)构造器，这样使用this关键字非常有用，对公共的构造器代码部分只需要编写一次即可。
包
使用包的主要原因时确保类名的唯一性。
类的导入
一个类可以使用所属包中的所有类，以及其他包中的公有类（public class）。
访问另一个包中的共有类有2中方式：
1.在每个类名之前添加完整的包名。
1 java.time.LocalDate today = java.time.LocalDate.now();
这显然很繁琐。
2.使用import语句。
可以使用import语句导入一个特定的类或者整个包。import语句应该位于源文件的顶部（但是位于package语句的而后面）。
注释位置
类注释必须放在import语句之后，类定义之前。
方法注释必须放在所描述的方法之前。
域注释通常只需对公有域（静态常量）进行注释。
类设计技巧
可以使得设计出来的类更具有OOP专业水准的几点技巧：
- 1.一定要保证数据私有。这是最重要的，绝对不要破坏封装性。
- 2.一定要对数据初始化。Java不对局部变量进行初始化，但是会对对象的实例域进行初始化。最好不要依赖于系统的默认值，而是应该显式的初始化所有的数据，具体的初始化方式可以是提供默认值，也可以是在所有构造器中设置默认值。
- 3.不要在类中使用过多的基本类型。可以根据基本类型特点自定义类进行使用。
- 4.不是所有的域都需要独立的域访问器和域更改器。
- 5.将职责过多的类进行分解。
- 6.类名和方法名要能够体现它们的职责。
- 7.优先使用不可变的类。
文末彩蛋
针对于上面所涉及到的知识点我总结出了有1到5年开发经验的程序员在面试中涉及到的绝大部分架构面试题及答案做成了文档和架构视频资料免费分享给大家（包括Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术资料），希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习，也可以关注我一下以后会有更多干货分享。
资料获取方式 QQ群搜索“708-701-457” 备注“csdn” 即可免费领取
