面向对象

浅谈面向对象三大特征

编程语言中的面向对象思想是非常重要的。不管是在实际开发当中还是在面试笔试时都会遇到。这里根据本人的理解，用通俗的语言解释一下。（不喜勿喷，谢谢）

说到面向对象，第一印象就是三个重要特征：封装、继承、多态

封装

首先，封装是将客观事物包装在了一个类中，类中包括事物本身的属性、行为等，我们可以根据自己的意愿，通过应用访问修饰符来改变调用他们（属性、行为等）的权限。
举个简单的例子，学校发给大家一张个人信息调查表填写。其中姓名、性别、民族、电话、兴趣爱好等等。这时，我们填写上的姓名、性别、联系方式是属性，而兴趣爱好便是行为（程序当中的方法）。以上的都属于公有（大家都可见）。而关于我们的隐私（私有），我们就不能随便填写了，当然可以通过一些方法让别人获取。

接下来我们注重说一下访问修饰符（以java语言为主）

访问修饰符分为四种根据权限大小依次为public、protected、default（friendly、缺省、一般不写）、private
public：公有的，在当前项目当中的所有非抽象类都可以获取。
protected：受保护的，在当前包的所有类中都可以获取，在其他包中只有子类（继承了当前被protected修饰类的类，也称派生类）可以获取。
default：只在当前包当中
private：只在当前类当中

如果不符合以上情况，但是需求某个类中的属性，一般可以通过getters和setters方法获得并赋值。

继承

说到继承我们想到了父类和子类（基类和派生类），可以说子类继承了父类除了私有以外的所有并为己所用。
子类会拥有父类的一般特性，但他们也会有独立的特性。以下举个例子。

public class Persion1 {
	private String name;
	private int age;
	
	public Persion1(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void eat(){
		System.out.println("我会吃饭");
	}
	public void learn(){
		System.out.println("我会学习");
	}
}

public class Persion2 {
	private String name;
	private int age;
	
	public Persion2(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void eat(){
		System.out.println("我会吃饭");
	}
	public void learn(){
		System.out.println("我会学习");
	}
}

通过代码我们可以看到Persion1和Persion2都有相同的特性，这时我们可以把相同的属性和方法写在同一个类中，通过继承来为己所用。可以降低代码的复杂度、提高代码的复用性，不必相同的代码写很多次。接下来就会变成：

public class Persion {
	private String name;
	private int age;
	
	public Persion(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void eat(){
		System.out.println("我会吃饭");
	}
	
	public void learn(){
		System.out.println("我会学习");
	}
}

public class Persion1 extends Persion{
	public Persion1(String name,int age){
		super(name, age);
	}
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		super.eat();
	}
	@Override
	public void learn() {
		// TODO Auto-generated method stub
		super.learn();
	}
}

public class Persion2 extends Persion{
	public Persion2(String name,int age){
		super(name, age);
	}
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		super.eat();
	}
	@Override
	public void learn() {
		// TODO Auto-generated method stub
		super.learn();
	}
}

关于继承，有几个关键字需要记一下
extends：继承类，只可以单继承
implement： 实现接口（相当于继承接口的用法），可以多实现在后面加逗号即可
super：代表父类，只写在当前类构造函数的第一行
this：代表当前类，只写在当前构造函数中，但位置随意

多态

所谓多态，就是一种行为在不同的类中有着多个不同的表现形式。
多态出现在继承中，子类对象对父类的引用，重写父类的方法。
我们主要看例子说明：

public class Father {
	public Father(){
		System.out.println("this is Father()");
	}
	public Father(int i){
		System.out.println("this is Father(int i)");
	}
	public void A(){
		System.out.println("this is A()");
	}
	void B(){
		System.out.println("this is B()");
	}
}
class Son extends Father{

	@Override
	public void A() {
		// TODO Auto-generated method stub
		System.out.println("this is Son's A()");
	}
	
}
class test{
	public static void main(String[] args) {
		Son son = new Son();
		son.A();
		son.B();
	}
}
运行结果：
this is Father()
this is Son's A()
this is B()

最后我再插一嘴，
初始化对象（new Son()）时，会先走父类的构造函数然后走当前类的构造函数。
如果想要结果出现this is Father(int i)只需将Son类改为：

class Son extends Father{
	public Son(){
		super(1);
	}

	@Override
	public void A() {
		// TODO Auto-generated method stub
		System.out.println("this is Son's A()");
	}

}
结果为：
this is Father(int i)
this is Son's A()
this is B()