java 封装多态继承

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

面向过程与面向对象

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

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

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

Java面向对象特性

万物皆对象

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

封装

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

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

1将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。

2通过该类提供的方法来实现对隐藏信息的操作和访问。

3隐藏对象的信息。

4留出访问的对外接口。

封装的好处

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

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

继承

继承就是父子之间一种关系特性，如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("----------");
	}

	// 测试 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();

	}
}

// 鸡猫狗都属于动物，都有名字，这里可以用到继承，并且他们都吃东西，吃东西的方法也能继承

/* -定义鸡
 * 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";
	}

    // 因为java继承父类的方法，你也可以重写父类方法
	@Override
	public String eatFood() {
		System.out.println("override method define cat how to eat food");
		return super.eatFood();
	}

}

测试 封装多态继承特性

public class JavaFeature {

	// 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();

	}
}

控制台输出

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 鱼
----------

Spring的淋漓精致

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

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