java中封装 ，继承与多态

封装

定义：把对象的属性和（服务）结合为一个整体，尽可能的隐藏对象内部的实现细节。

优点：

1. 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带 来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与 操作内容的负担。

2. 对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

概念：封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。

例子：

public  class Man{
//对象属性的封装，一个人的姓名，年龄，妻子
private String name;
private  int age；
private  Woman  wife;

//男人对外界提供方法的封装,设置年龄，姓名，妻子，对外暴露自己的年龄，姓名，但没有暴露妻子
public void setWife( Woman wife){
this.wife=wife;
}
public void setAge(Int age){
this.age =age;
}
public void setName( String name){
this.name=name;
}
public String getName(){
return name;
}
public Int getAge(){
return age;
}

}
public class Woman{
//对象属性的封装
private String name;
private  int age；
private  Man  husband;

//方法的封装, 女人 只对外暴露自己的姓名，年龄和丈夫都不暴露
public void setHusband( Man husband){
this.husband=husband;
}
public void setAge(Int age){
this.age =age;
}
public void setName( String name){
this.name=name;
}
public String getName(){
return name;
}
}

继承

概念：继承表现的是特殊与一般的关系，常说的is-a的关系，子类继承父类，表明子类是一种特殊的父类，可以具有父类不具有的属性和方法。（子类不能继承父类中用private修饰的变量和方法。）

有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。

例子：

public  class Person{
public void eat(){
system.out.print("吃")
}
public void drink(){
system.out.print("喝")
}
//吃喝拉撒睡，省略掉中间的
public void sleep(){
system.out.print("睡")
}
}

public class XiaoGuo extend Person{
protected void  yellow(){
system.out.printh("找小姐姐")
}
public void gamble(){
system.out.print("小赌一把")
}
public void drink(){
system.out.print("酗酒")
}
}

XiaoGuo 同学继承了Person的eat()和sleep()，重写了 Person的 drink()这个方法，还又学会了person不具有的两个新技能，”找小姐姐”和”小赌一把”。

然后XiaoGuo 觉得找小姐姐这事情让别人都知道了不太好，关系好的小伙伴可以知道，就用protected修饰了这个方法，只有XiaoGuo 的子类可以访问这个方法（不同包的时候）。

多态

概念：直白些就是 相同的事物，调用相同的方法，参数也相同时，但表现的行为却不同。

实现多态有三个必要条件：继承、重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。在上面例子中就是 Person xg =new XiaoGuo(); 父类引用指向子类对象

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

（1）基于继承实现的多态

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

例子：厕所(Toilet)

public class Toilet{
public vodi toilet(){
system.out.print("厕所")
}
}
public class M  extend Toilet{
public void toilet(){
system.out.print("男厕")
}
}
public class W extend Toilet{
public void toilet(){
system.out.print("女厕")
}
}
class A {
public static void main(String[]  args){
Toilet  mToilet = new M();    //父类引用指向子类对象
Toilet  wToilet = new W();    //父类引用指向子类对象

mToilet.toilet();    // 执行M的toilet()方法
wToilet.toilet();    //执行W的toilet()方法
//mToilet和wToilet都是Toilet类型，不会执行Toilet的toilet()方法，但会执行被子类重写的方法
}
}
程序执行结果： 男厕女厕

（2）基于接口实现的多态

在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

例子：

public interface Toilet{
public void toilet() ;
}
//接口实现类
public class M implement Toilet{
public void toilet(){
system.out.print("男厕")
}
}
//接口实现类
public class W implement Toilet{
public void toilet(){
system.out.print("女厕")
}
}
class A{
public void static main(String[]  args){
Toilet mToilet = new M();  //接口引用变量指向接口实现类对象
Toilet wToilet = new  W();  //接口引用变量指向接口实现类对象
mToilet.toilet();
wToilet.toilet();
}
}
程序执行结果： 男厕女厕

多态的弊端：不能使用子类特有的成员属性和子类特有的成员方法。

多态的好处：程序的可扩展性及可维护性增强。