OOP（面向对象编程）的三大特征（重点）

封装/隐藏（encapsulation）

在程序的设计过程中，为了提高系统安全性及便捷性，我们追求的是 “高内聚、低耦合”
高内聚：类内部的数据操作细节自己完成，不允许暴露给用户
低耦合：仅暴露少量方法给用户使用

在开发过程中，我们一般通过访问修饰符来实现封装，各种访问修饰符的访问权限，如图所示：

封装要点：
1：除非确定该属性会被子类继承，否则全部使用private修饰；
2：要求提供相应的get/set来访问属性（这些方法要求用public修饰，从而提供对属性的读写操作）；
3：仅用于本类的辅助性方法用private，希望被其他类调用的用public；

继承（inherit）

我们知道类是对对象的抽象（抽出“象”的部分）；而继承则是对某一批类的抽象，从而实现对现实世界更好的建模；

继承的优点

1：提高代码复用；（从复用性角度来考虑，组合和继承一样；后面会详细对比）
2：从OOA（面向对象分析）和OOD（面向对象设计）方面考虑，更加方便我们建模（建立整个系统的模型、结构）；

关键字

extends（扩展）；子类是父类的扩展

继承的主要特性

1：如果类未通过extends来继承父类，系统默认父类为java.lang.Object(根基类)；
2：Java为单继承（C++为多继承）；在程序较为复杂时，多继承会引起混乱，使得程序过于复杂，系统难以维护（但是Java中可通过接口来实现多继承）
3：子类继承父类，可以获得父类的所有属性和方法（记住一点：构造方法除外）；

重写

重写特点：
1：方法名相同；
2：返回值相同；
3：参数列表相同；
4：不能缩小访问权限（多态的关系）；

重写运用较多的地方在于子类重写父类方法；但普通方法也可重写；
重写和重载二者没有任何关系，不要搞混淆了！

Object类

Object是所有Java类的根基类；如果在类的声明中未通过extends关键字指明父类；则默认父类为Object；
Object中的toString方法经常会被我们重写；但我们需要知道在Object类中toString方法返回的是类名+包名+@+哈希码（哈希码根据对象内存位置生成，唯一不重复）

super关键字

super指代的是父类对象的直接引用，可通过super来调用父类中被子类覆盖（重写）的属性和方法；
super作用在普通方法中没有顺序，随意调用；但是在构造方法中调用必须放在第一句；并且在构造方法中，如果第一句没有加super();系统会默认调用super()作为父类的初始化函数；（在初始化一个对象时，系统会默认调用该对象的无参构造方法，无参构造方法里会默认调用父类无参构造方法，如果未指定父类，调用Object的无参构造方法；最后返回的对象呈“包裹结构”）

继承内存图分析

首先我们先定义三个类：

父类—Animal

package com.project.inherit;

public class Animal {
	String eye;
	
	public Animal(){
		super();
		System.out.println("创建一个动物");
	}
	
	public void eat(){
		System.out.println("动物吃饭");
	}
	
	public void run(){
		System.out.println("动物奔跑");
	}
}

子类----Brid

package com.project.inherit;

public class Brid extends Animal {
	
	String wing;
	
	public Brid(){
		//在无参构造方法中调用被子类覆盖的父类run方法
		super.run();
		System.out.println("创建一只鸟");
	}
	
	//重写Animal run方法
	public void run(){
		System.out.println("小鸟飞");
	}
	
	//子类特有方法sleep
	public void sleep(){
		System.out.println("小鸟睡觉");
	}
}

测试类—Test

package com.project.inherit;

public class Test {
	public static void main(String[] args) {
		Brid brid = new Brid();
		brid.wing = "翅膀";	//子类特有属性
		brid.eye = "双眼";	//父类属性
		brid.sleep();		//子类特有方法
		brid.run();			//重写了父类方法
		brid.toString();    //根基类方法
	}
}

内存分析图：

继承vs组合

组合是什么：
去除继承概念，我们将父类作为一个对象new出来直接放到子类中，子类通过这个“组合”对象获取到该对象的方法和属性；比如：

package com.project.inherit;

public class Brid {
	
	String wing;
	
	public Brid(){
		Animal animal = new Animal();   //去除了Brid和Animal的继承关系，将Animal作为对象
										//直接放进来；作用同继承一样。
		animal.run();
	}
}

因此，我们可以得出如果仅从代码复用的角度来考虑，组合完全可以替代继承；
但是从程序建模角度来考虑，继承比组合更加适用；继承会使程序的结构层次更加清晰，扩展性更强；
我们可以表示为：
is a的关系用继承；（比如小鸟是动物，这种关系用继承较好）
has a的关系用组合；（小鸟有一对翅膀，这种关系用组合更加合适）

final

从final这个单词的意思“最终”我们就可以看出，它对程序会有什么样的影响了；
1：修饰变量：常量，不可修改；
2：修饰方法：不可重写（可重载）；
3：修饰类：不能继承其他类，也不能有子类；（比如：Math类，String类）

多态

多态主要是用来实现动态联编的，换句话说，就是程序的最终形态是由运行时决定的，而非编译时决定，即声明的引用变量最终会指向哪个实例对象；

必要条件

1：必须要有继承；
2：子类必须重写父类方法；
3：父类引用指向子类对象；

底层实现原理分析

首先，先声明三个类：
父类—Animal

package com.project.polymorphism;

public class Animal {
	String eye;
	
	public void voice(){
		System.out.println("动物叫声");
		testThis();
	}
	
	public void testThis(){
		System.out.println("this is animal");
	}
}

子类—Dog

package com.project.polymorphism;

public class Dog extends Animal{

	public void voice(){
		System.out.println("汪汪");
	}
	
	public void lookDoor(){
		System.out.println("看门");
	}
	
	public void testThis(){
		System.out.println("this is dog");
	}
}

测试类—Test

package com.project.polymorphism;

public class Test {
	
	public static void testAnimalVoice(Animal a){
		//这里的a在编译时会被统一成Animal对象，而运行时，被解释成Dog对象
		a.voice();
		
		//从包裹结构来看，可以知道，Dog对象中包含Animal对象
		//因此，a对象属于Dog类在编译上不会出错，但是在运行时必须强制转换成Dog对象
		if(a instanceof Dog){
			((Dog) a).lookDoor();
		}
	}
	
	public static void main(String[] args) {
		Animal d = new Dog();
		testAnimalVoice(d);
		
		//测试this在继承关系中所代表的对象
		d.testThis();
	}
}

以上代码在运行时在内存中的表现形式为，如图所示：

说明：
1：在Test测试类中我们可以发现，一共有两个引用变量（d和a），因此，将这两个引用变量放入栈中；

2：通过继承关系我们可以知道，new出的新对象是包裹结构，如上图所示；

3：super对象中的隐式参数super指代的是直接父类的引用，而通过Test测试类中的d.testThis()方法（最后打印结果为，this is dog）我们可以得出，this指代的是最终成型的对象，也就是最外层对象Dog，因此在父类Animal的voice方法中调用testThis（）方法（等同于this.testThis()）,其实调用的是子类Dog的testThis()方法；