一丶封装
 1 权限修饰符
      可以用来修饰成员变量和成员方法，对于类的权限修饰只可以用public和缺省default。
           被public修饰的类可以在任意地方被访问；default类只可以被同一个包内部的类访问。
      权限由大到小：public protected default(不写) private
           被private修饰的成员只能在本类中访问，外界不能访问

2 set()/get()方法
  （1）this关键字
    a.可以用来调用变量，方法，构造方法；
    b.this.xx 理解为调用当前类的xx。
  （2）成员变量和局部变量
    1）在类中的位置不同
     a:成员变量:在类中,方法外
       b:局部变量:在方法声明上（形式参数）,或者是在方法定义中
    2）在内存中的位置不同
     a:成员变量:在堆内存
     b:局部变量:在栈内存
    3）生命周期不同
     a:成员变量:随着对象的创建而存在,随着对象的消失而消失
     b:局部变量:随着方法调用而存在,随着方法的调用结束而消失
    4）初始化值不同
     a:成员变量:有默认值
     b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化)
  （3）set()/get()方法
    当成员变量被private修饰时，不在本类中无法直接访问，便需要set()/get()方法来解决这个问题

3 封装性
  封装：是面向对象的第一大特性，所谓封装，就是值对外部不可见（一般而言被private修饰），外部只能通过对象提供的接口（如set()/get()方法）来访问。
  封装的好处：a.良好的封装能够减少耦合；
     b.类内部的结构可以自己修改，对外部影响不大；
     c.可以对成员进行更精准的控制（防止出现与事实不符的情况）；
     d.影藏实现细节。
  注意：在开发中，类的成员变量全部要进行封装，封装之后通过set()/get()方法访问。
二丶继承extends
 1 实现：通过 class Zi extends Fu{} 实现类的继承
  （1）子类继承父类，父类中声明的属性，方法，子类都可以获取到；
   当父类中有私有的属性方法时，子类同样可以获取到，由于封装性的设计，使得子类不能直接调用访问。
  （2）子类除了可以继承父类的结构外，还可以定义直接特有的成员变量，成员方法；
  （3）Java中类的继承只支持单继承，一个类只能继承一个父类，父类可以有多个子类，但是可以多层继承；
  （4）子类不能继承父类的构造方法，可以间接的通过super关键字去访问父类的构造方法（super();）；
   在子类的构造方法中如果没有显示的调用父类的构造方法，会默认调用父类的无参构造（所以最好父类都写有无参构造方法）。
   子类继承父类的访问特点:首先父类进行初始化,然后子类进行初始化;多层访问!
 2 方法的重写（区别重载）
  子类继承父类以后，若父类的方法对子类不适用，那么子类可以对父类方法重写（override）
  规则：1）要求子类方法的 返回值类型 方法名（参数列表） 与父类方法一致；
     2）子类方法的权限修饰符不能小于父类方法的修饰权限；
     3）若父类方法抛异常，那么子类方法抛的异常类型不能大于父类；
  注意： a.当子类重写了父类的方法以后，可以用 super.方法 调用父类被重写的内容;
    b.子父类的方法必须同为static或同为非static。

class Fu{
 private int i;
 public Fu(){ //无参构造 super()；可以省略
  super();
 }
 public Fu(int i){ //有参构造
  super();
  this.i = i;
 }
 public void seti(int i){
  this.i = i;
 }
 public int geti(){
  return i;
 }
 public void show(){
  System.out.println("这是父类");
 }
}
class Zi extends Fu{ 
 public Zi(){ //无参构造
  super();
 }
 public Zi(int i){ //有参构造，这块的super就不能省略
  super(i);
 }
 @Override //重写了父类中的show()方法
 public void show(){
  System.out.println("这是子类");
 }
}
public class Test{
 public static void main(String[]ages){
  Zi z = new Zi(); 
  z.seti(10);   //Zi z = new zi（10）;
  System.out.println(z.geti()); //10
  z.show(); //这是子类
 }
}

3 super关键字
   this与super区别： this:代表的是当前类的对象
        super:代表的是父类的引用
   应用场景: 
      成员变量
       this.成员变量:  访问当前类中的成员变量
       super.成员变量:  访问的是父类中的成员变量
     构造方法
     在构造器内部， super（）；/this()必须声明在首行，且只能出现一个。
      this();  访问的是本类中构造方法
      super(); 访问的是父类中的无参构造
     成员方法
      this.成员方法; 访问的是本类的成员方法
      super.成员方法; 访问的就是父类中的成员方法
 4 继承性
  优点： a:提高代码复用性
    b:提高代码维护性
    c:让类与类产生了一种关系,它是多态的前提!（产生的这种关系也是一种弊端，java中开发原则:低耦合,高内聚）
三丶多态（主要子类对象的多态性）
 1 多态的前提条件:
  1)必须有继承关系；
  2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)；
  3)父类的引用指向子类对象。（向上转型）
   向上转型：父类引用指向堆内存的子类的对象； Fu f = new Zi();
   向下转型：将父类的引用强制转换为子类对象； Zi z = (Zi)f; 
 2 多态中的成员访问特点: （左指的父类，右指的子类） 
  成员变量:
     编译看左,运行看左
   非静态成员方法:
     编译看左,运行看右(子类中的方法会覆盖掉父类中的方法)
   静态的成员方法:
      编译看左边,运行看左边(静态和类有关系,随着类的加载而加载)

3 多态性
  优点：a.提高了代码的维护性(由继承保证);b.提高了代码的扩展性(由多态的保证)。
  弊端：父类对象不能访问子类特有功能!
   解决办法：向下转型（注意ClassCastException异常）

面向对象的三大特性（封装 继承 多态）