道阻且长(一) Java核心：5.面向对象(下)

       上一章节大致讲解了，对象的一些基本特征，最好能达到：看见任何一个东西，如果需要用代码实现，我们马上就能够抽象成一个类。本章节将讲解对象的典型特征，在最初接触的时候，我们可能会觉得非常模糊，这点没事，随着逐渐的学习，我们会一直使用到，也就慢慢的能够加深理解。现在不理解，没事，不耽误接下来的学习！

1.封装

（1）什么是封装？

封装：指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系

简而言之：上一章节的奶茶，将含糖量，含奶量这些统一封装在奶茶类里面，谁想使用奶茶的含糖量，只需要通过奶茶这个类获取就行，不用关心内部实现。

（2）怎么封装？

public class MilkTea {  
      
    /* 
     * 对属性的封装 
     * 对奶茶的名称、价格都是其私有属性 
     */  
    private String name ;  
    private double price ;  
      
    /* 
     * setter()、getter()是该对象对外开发的接口 
     */  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getPrice() {  
        return price;  
    }  
  
    public void setPrice(double price) {  
        this.price = price;  
    }    
}  

（3）封装有什么用？

1、良好的封装能够减少耦合【即不用每次实现一个功能，都新建一个POJOjie'ou，Java很多时候都会解耦，就是每个模块只做每个模块的事情，分布式的出现也是这样】。

2、类内部的结构可以自由修改。

3、可以对成员进行更精确的控制。

4、隐藏信息，实现细节。

2.继承

（1）什么是继承？

通过关键词 extends 实现 ，A extends B时候，假如B能够唱，跳，A继承之后，立马就能唱跳，再加上A自身能够Rap，能够：通过一个关键字，减少代码量，同时A能够灵活地拓展自己的功能

（2）怎么继承？

public class Person {  
    public void display(){  
        System.out.println("Play Person...");  
    }  
     static void display(Person person){  
       person.display();  
    }  
 }  


 public class Husband extends Person{  
    public static void main(String[] args) {  
         Husband husband = new Husband();  
         Person.display(husband);      //向上转型  
    }  
 } 

（3）继承有什么用？

1、子类拥有父类非private的属性和方法。

2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式实现父类的方法。

3.多态

（1）什么是多态？

最容易的理解：爸爸+妈妈(可以理解为一个同样的入口)，生了两个孩子，却长得不一样(出口不一样)。

同一棵树，所有的叶子都不一样....这样的例子很多，常见出现在代码的：接口实现，继承重写两个地方。

（2）怎么多态？

   基于接口：

public interface A {  
	// 该接口定义了一个String返回类型的方法，输入字符串str，基于内部不同的实现，最终返回一个String类型的数据
	String returnString(String str);
}  
  
public class B implements A{  

    @Override
    public String returnString(String str){  
        return "我是B，" + str;  
    }   
}  

public class C implements A{  

	@Override
    public String returnString(String str){  
	// B,C返回了不同的数据，内部实现了不同的业务逻辑
	String s = "我是另一条业务逻辑";
        return "我是C，" + s + str;  
    }   
}  

基于继承： 

// A 本身打印：A and A
public class A {  
    public String show(A obj) {  
        return ("A and A");  
    }  
}  
// B 继承 A，执行的show方法，打印输出的是：B and A  
public class B extends A{  
    public String show(B obj){  
        return ("B and A");  
    }  
}  
// C 继承 A，执行的show方法，打印输出的是：C and A  
public class C extends A{  
  public String show(C obj){  
        return ("C and A");  
    } 
}  

（3）多态有什么用？

提高代码可拓展性，复用率