java 面向对象思想 封装多态继承

面向过程与面向对象

编程分为面向对象编程和面向对象编程，汇编，C语言是面向过程写代码，C++/Java是面向对象

其实面向过程和面向对象在本质都是一样写代码，然后将代码翻译成机器码让中央处理器去执行，但是在实现功能和整体设计上，相对于人来说，特别是Java，面向对象在设计上更抽象，是写代码在设计上的升华。

Java里说，万物皆对象，如果说java的面向对象设计思想是java火起来的原因，那么Spring设计思想让Java的光彩放大。

Java面向对象特性

万物皆对象

在Java中，除了基础数据类型，char int float 与数学计算相关的基本类型，其他所有的任何都是对象，他们会有对应的类名，字节码

封装

java实际编写功能时，所写代码皆对象，因此封装无处不在，你可以隐藏对象的属性（private）， 通过封装方法对类里面的内容操作。

封装的好处

• 对成员变量实行更准确的控制。
• 封装可以隐藏内部程序实现的细节。
• 良好的封装能够减少代码之间的耦合度。
• 外部成员无法修改已封装好的程序代码。
• 方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
• 便于修改，体高代码的可维护性。

简单一句话，高内聚，低耦合

继承

继承就是父子之间一种关系特性，如A类继承B类，那么A是子类，B是父类，通俗的理解，A（子类）继承了B（父类）的一些公共属性和方法。

简单来说，继承用在一些共性上，是设计上的抽象一种表现。

四肢动物是抽象的，但是你知道他有四肢，那么你可以定义一个属性，说明他是四肢动物，猫和狗可以继承它，鸡是两条腿不能继承它，这是从面向对象设计角度去描述继承的使用

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态的特点

1，消除类型之间的耦合关系，实现低耦合。

2，灵活性。

3，可扩充性。

4，可替换性。

你可以定义一种抽象类，并且创建抽象类的具体实现，之后所有子类对象创建可以用父类去接收，在执行方法时，父类引用指向子类对象，方法也是子类的方法，都是父类，指向不通子类，执行方法结果不一样，就是多态。

封装多态继承 代码体现

/** -定义抽象类，动物
* Animal-定义一个动物
* @author Narule
*
*/
public abstract class Animal {

// 动物腿的数量
protected int legNum;

// 动物吃的食物
protected String food;

// 动物名字
protected String name;

// 是否是四肢动物 方法定义
boolean isFourLegAnimal() {
return legNum == 4;
}

// 吃食物，抽象方法定义，具体动物需要实现次方法
public String eatFood() {
System.out.println(this.name);
System.out.println("----------");
System.out.println(this.name + " eat food is "  +  this.food);
System.out.println("----------");
return this.food;
}

}

// 继承动物
/*
* Animal-鸡
*/
class Chicken extends Animal{

/* - 一种封装手法，你可以创建一只鸡对象
* - 但是因为封装了，你没办法修改鸡的腿的条数，这一封装好处的一个具体表现
*/

public Chicken() {
this.legNum = 2;
this.food = "insect 虫子";
this.name = "Chicken";
}

}

/*
* Animal-狗
*/
class Dog extends Animal{

public Dog() {
this.legNum = 4;
this.food = "bone 骨头";
this.name = "Dog";
}

}

/*
* Animal-猫
*/
class Cat extends Animal{

public Cat() {
this.legNum = 4;
this.food = "fish 鱼";
this.name = "Cat";
}

@Override
public String eatFood() {
System.out.println("override method define cat how to eat food");
return super.eatFood();
}

}

测试 封装多态继承特性

public class JavaFeatureTest {

// java 封装 继承 多态  简单理解表达
public static void main(String[] args) {

// 创建三个动物对象 鸡 狗 猫
// 封装体现，创建对象不能去修改他的属性
Animal animal1 = new Chicken();
Animal animal2 = new Dog();
Animal animal3 = new Cat();

// 判断是否是四条腿的动物 继承体现
System.out.println(animal1.isFourLegAnimal());
System.out.println(animal2.isFourLegAnimal());
System.out.println(animal3.isFourLegAnimal());

// 吃东西  多态体现，同一个行为j具有多个不通表现形式
animal1.eatFood();
animal2.eatFood();
animal3.eatFood();

// 多态 父类引用指向子类对象
animal3 = new Chicken();
animal3.eatFood();

}
}

控制台输出

false
true
true
Chicken
----------
Chicken eat food is insect 虫子
----------
Dog
----------
Dog eat food is bone 骨头
----------
override method define cat how to eat food
Cat
----------
Cat eat food is fish 鱼
----------
Chicken
----------
Chicken eat food is insect 虫子
----------

Spring的淋漓精致

很多时候，如果只是功能需求，我们甚至可以只写一个接口，定义接口抽象方法的输入和输出，没有具体实现，然后在开发的时候对应具体不同场景不同开发人员，可以容许不同的设计和实现。这样软件设计开发中很好的提高开发效率，并且以维护，易扩展，低耦合，安全。

多态，继承，封装高级使用，设计模式，Spring框架很多具体体现，（依赖抽象不依赖具体，控制反转，代理），Spring是很值得学习的框架