在乎的是，自己以及他所在乎的人，能不能够秉持着自己的心意与信念，在人生中大部分时间里都能自在、快乐

本文参考https://blog.csdn.net/baidu_33714003/article/details/52290627

面向对象和面向过程的区别

出发点不同。面向对象强调把问题直接映射到对象以及对象之间的接口上；而面向过程强调的则是过程的抽象化和模块化，它是以过程为中心构造或者处理客观世界问题的。
层次逻辑关系不同。面向对象尽量会用计算机逻辑来模拟客观世界的物理存在，用类的层次结构展现类之间的继承和发展；而面向过程的处理问题的基本单位是能够清晰准确表达过程的模块，而且用模块之间的关系和内容表述计算机处理问题的过程。
数据处理方式与控制程序方式不同。面向对象方法是”事件驱动”的，通过事件来激活和运行程序，而且它会把对应的代码封装成一个整体，原则上其他类不能直接修改其数据；面向过程则通过直接调用程序来处理数据，处理完后显示结果，在控制的方式上是按照涉及调用或者返回程序，不能导航，各模块之间存在控制与被控制，调用与被调用的关系。
分析设计与编码转换方式不同。面向对象是无缝连接，从分析到设计再到编码是采用一致性的模型表示的；面向对象是有缝链接，它强调分析、设计以及编码之间按照规则的转换，过程中使用的模型是不一样的。

面向对象有哪些特征

应当记住这段话：封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

主要包括：抽象、继承、封装和多态

抽象。抽象包括两个方面，一是过程抽象，二是数据抽象；忽略一个主体中与当前目标无关的方面和细节，以便更充分地注意与当前目标有关的方面。
封装。可以说是最好理解的了，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
继承。通过继承，子类可以使用父类中的一些成员变量和方法，从而能够提高代码的复用性，提高开发效率。
多态。多态也是实现代码重用的重要机制，简单来说，就是实现接口的重用。它能够实现父类和一个或者多个它的子对象相等，但是有不同的表现形式。专业点说，就是允许将子类类型的指针赋值给父类类型的指针。

详解继承

继承可以让子类使用父类中的一些成员变量和方法，从而能够提高代码复用性，提高开发效率。

继承的特点：在继承关系中，父类更通用，子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

Java语言中，有关继承的术语主要是，被继承类叫做的父类或者基类(superclass)，继承父类的类叫做派生类或子类(subclass)。

在继承关系中，父类和子类需要满足”is-a”的关系，”子类是父类”。

继承的特性

Java语言不支持多重继承，也就是说一个子类至多只能有一个父类，但是可以通过实现多个接口来达到多重继承的目的，这一点上可以理解继承和多态有了overlap
子类只能继承父类的非私有(public 和 protected)成员变量和方法。注意这一点经常容易出题，注意是”子类能继承父类的非私有方法和状态”
当子类中的成员变量与父类中的成员变量同名时，子类中的成员变量会覆盖父类的成员变量，而不会继承。可以理解为”就近原则”
当子类中的方法与父类中的方法有相同的函数签名(相同的方法名，相同的参数个数与类型)时，子类将会覆盖父类的方法，而不会继承。

为什么要继承？什么时候应该避免继承？

继承可以有效实现代码复用，避免重复代码的出现。

当两个类具有相同的特征(属性)和行为(方法)时，可以将相同的部分抽取出来放到一个类中作为父类，其他两个类继承这个父类。

继承实现了面向对象的原则：write once, only once(编写一次，且只编写一次)

实际上，能用组合(下面继承与组合的区别部分有介绍什么是组合)的话就尽量别用继承，除非两个类之间确定是”is-a”的关系。具体使用，应当遵循以下两点原则：

除非两个类之间是”is-a”的关系，否则不要轻易使用继承。不要单纯为了实现代码重用而使用继承，因为过多的继承会破坏代码的可维护性，因为当父类被修改时，会影响所有继承了它的子类，从而增加程序的维护难度与成本。
不要仅仅为了实现多态而使用继承，如果类之间没有”is-a”的关系，可以通过实现接口与组合的方式来达到相同的目的。设计模式中的策略模式可以很好地说明这一点，采用接口与组合的方式比采用继承的方式具有更好的可扩展性。

小总结

由于Java只支持单继承，如果想要同时继承两个类或多个类，无法用继承实现，只能选择实现多个接口。

同时，Java语言中，如果继承使用太多，也会让一个class里面的内容变得臃肿不堪。所以，在Java语言中，能使用组合就尽量不要用继承。

如何实现继承

在Java中，用extends(扩展)关键字实现，使用格式为：

class 子类名 extends 父类名

在父类中只定义一些通用的属性和方法，之后子类继承父类之后自动获取父类的属性和方法。当然子类可以定义特定的属性和方法，或子类重新定义父亲的属性、重写父亲的方法，这样可以获得与父类不同的功能。

如果想在子类中使用父类的构造方法，可以通过super()关键字调用父类方法，但是要注意调用父类的构造方法语句(super语句)必须是构造方法中的第一条语句，因为创建对象时西安仓就爱你父类对象，再创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。

一切类的老大(祖先)Object

所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。

一个类如果没有使用extends关键字，那么这个类直接继承自Object类。

继承与组合的区别

继承和组合是面向对象的两种代码复用的方式。组合是指在新类里面创建原有类的对象，从而重复利用已有类的功能，而继承则允许设计人员根据其他类的实现来定义一个新类的实现。

继承和组合都允许在新的类中定义子对象，但是组合是显示的，继承是隐式的。

组合与继承存在着对应关系：组合中的整体类和继承中的子类对应，组合中的局部类和继承中的父类对应。

正如之前所说了，在继承中父类和子类需要满足”is-a”的关系，即要满足”子类是父类”；而组合则是两个类之间有”
has-a”的关系，即”组合类有父类”

比如现在有三个类：Car(汽车)、Vehicle(交通工具)、Tire(轮胎)，那么正确的关系应该是：Car继承Vehicle(汽车是交通工具)、Car组合Tire(汽车拥有多个轮胎)，具体实现方法如下代码：

继承：

class Vehicle {

}

class Car extends Vehicle{

}

组合：

class Vehicle {

}

class Tire {

}

class Car extends Vehicle{
	Tire tire = new Tire();
}

继承和组合在实际使用中的选择，可以参考上面什么时候应该避免使用继承？模块。

详解多态

多态是实现代码重用的重要机制，主要表现在同一个操作在作用在不同对象的时候，有不同的语义(或者说操作内容不同)，从而会产生不同的结果。

使用多态的好处

可以增强程序的可扩展性以及可维护性，也可以使得代码更加简洁。

实现多态机制的方法

实现多态机制主要有两种方法：方法重载(overload)和方法覆盖(override)(也叫作方法重写)

方法重载(overload)

具体实现：

方法的重载(overload)：重载是发生在类内部，实质是不同的方法，也可以用不同的方法名进行替换，但是采用同一方法名能间接体现方法之间的内在相似性。

使用方法重载的目的：

节省方法名
体现这些方法之间的内在联系

举例：

public class KeyValue {
    private final HashMap<String , Object> kvs = new HashMap<>();
    public KeyValue put(String key , int value) {
        kvs.put(key , value);
        return this;
    }
    public KeyValue put(String key , long value) {
        kvs.put(key , value);
        return this;
    }
    public KeyValue put(String key , String value){
    	kvs.put(key , value);
    	return this;
    }
}

因为这些有着相同方法名的方法参数不同，所以在编译时就可以确定到底用哪个方法，它是一种编译时多态。

方法覆盖/重写(override)

方法覆盖发生在继承里，子类根据需要，重写继承的方法。

目的：用父类的方法名重写了一个新的方法。

需要覆盖的方法要和父类方法具有完全相同的方法名，返回值，参数列表（个数、类型、顺序）

举例：

public class Base{
	private String name;
	private String class;
	Base(){
	}
	public int printFuc(int data,char cr,String strings){
		System.out.println("父类");
		return 0;
	}
}

实现多态的子类为SubBase

public class SubBase extends Base{
	public int printFuc(int data,char cr,String strings){
		int a=3;
		int b=3;
		class inner{
			public int add(int a, int b){
				return a + b;
			}
		}
		inner nomean = new inner();
		System.out.println("重写父类");
		return nomean.add(a , b);		
	}
}

只有在运行时才能确定调用哪个方法，因此通过方法覆盖实现的多态也被称为运行时多态。

继承与多态的区别

继承，子类继承父类中所以的属性和方法，但是对于private的属相和方法，由于这个是父类的隐私，所以子类虽然是继承了，但是没有可以访问这些属性和方法的引用，所以相当于没有继承到。很多时候，可以理解为，没有继承。

多态：就是父类引用可以持有子类对象。这时候只能调用父类中的方法，而子类中特有方法是无法访问的，因为这个时候（编译时）你把他看作父类对象的原因，但是到了运行的时候，编译器就会发现这个父类引用中原来是一个子类的对像，所以如果父类和子类中有相同的方法时，调用的会是子类中的方法，而不是父类的。

可以这么说：编译时看父类，运行时看子类。