java中，封装，继承，多态和抽象

封装：

     把对象的属性和方法结合成一个独立的整体（类），隐藏实现细节，并提供对外访问的接口。

     优势在于定义只可以在类内部进行对属性的操作，保护数据不被意外的破坏，要想修改，也只能通过你定义的封装方法。

封装的好处：保护或者防止数据被我们无意中破坏。

（1）：隐藏实现细节。好比你买了台电视机，你只需要怎么使用，并不用了解其实现原理。

（2）：安全性。比如你在程序中私有化了age属性，并提供了对外的get和set方法，当外界 使用set方

              法为属性设值的时候 你可以在set方法里面做个if判断，把值设值在0-80岁，那样他就不能随意

              赋值了。

（3）：增加代码的复用性。

              好比在工具类中封装的各种方法，你可以在任意地方重复调用，而不用再每处都去实现其细节。

（4）：模块化。封装分为属性封装，方法封装，类封装，插件封装，模块封装，系统封装等等。

               有利于程序的协助分工，互不干扰，方便了模块之间的相互组合与分解，也有利于代码的调试

            和维护。比如人体由各个器官所组成，如果有个器官出现问题，你只要去对这个器官进行医治

            就行了。

继承：

    从已知的一个类中派生出新的一个类，叫子类。子类实现了父类所有非私有化属性和方法，

  

    并能根据自己的实际需求扩展出新的行为。

    减少了代码的冗余，省略了很多重复代码。

继承的好处：实现重用代码，节省开发时间。

（1）：继承是传递的，容易在其基础上构造，建立和扩充出新的类。

（2）：简化了人们对事物的认识和描述，能清晰体现相关类之间的层次结构关系。

（3）：能减少数据和代码的冗余度。

（4）：大大增加了代码的维护性。

多态：

    实现了方法的个性化，不同的子类根据具体状况可以实现不同的方法。

    同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态的好处：主要是利于扩展。

    主要是利于扩展。直接上代码自己来体会。

    //比如我在马剑威磨砺营毕业后，找到一份工作，前期买了一辆大众车，实现代码如下：  
    public class test{  
        public static void main(String[] args){  
            DZ dz =new DZ("大众");  
            people p =new people();  
            p.drive(dz);  
        }  
    }  
      
    class people{  
        public String name;  
        public DZ dz;  
        public void drive(DZ dz){  
            this.dz=dz;  
            dz.run();  
        }  
    }  
      
    class DZ{  
        public String name ;  
          
        public DZ(String name){  
            this.name=name;  
        }  
        public void run(){  
            System.out.print("上海大众在已120迈的速度在跑");  
        }  
    }  

//后期如果我有钱以后又买了一辆奔驰，我要换奔驰 ，不用多态的情况下代码如下：  
public class test{  
    public static void main(String[] args){       
        Benz benz=new Benz("奔驰车");  
        people p =new people();  
        p.drive(benz);  
    }  
}  
  
class people{  
    public String name;  
    public DZ dz;  
    public Benz benz;  
      
    public void drive(DZ dz){  
        this.dz=dz;  
        dz.run();  
    }  
      
    public void drive(Benz benz){  
        this.benz=benz;  
        benz.run();  
    }  
}  
  
class DZ{  
    public String name ;  
      
    public DZ(String name){  
        this.name=name;  
    }  
    public void run(){  
        System.out.print(name+"已在路上飞快的奔跑");  
    }  
}  
  
class Benz{  
    public String name;  
    public Benz(String name){  
        this.name=name;  
    }  
    public void run(){  
        System.out.print(name+"已在路上飞快的奔跑");  
    }  
      
}

//这样是不是程序粘连性太强，不利于扩展，
//而且Java特性是对扩展开放，对修改关闭 我每换一辆车就需要改代码。
  
//那样代码修改太多，也不安全，用了多态以后，效果就很不一样了，
//妈妈在也不用担心我换车了，so easy!!  
public class test{  
    public static void main(String[] args){       
        Benz benz=new Benz("奔驰车");  
        DZ dz=new DZ("大众车");  
        BMW bmw=new BMW("宝马车");  
        people p =new people();  
        p.drive(benz);  
        p.drive(dz);  
        p.drive(bmw);  
    }  
}  
  
class people{  
    public String name;  
    public Car car;  
      
    public void drive(Car car){  
        this.car=car;  
        car.run();  
    }  
      
}  
  
class Car{  
    public String name;  
      
    public Car(String name){  
        this.name=name;  
    }  
      
    public void run(){  
        System.out.println(name+"已在路上飞快的奔跑");  
    }  
}  
class DZ extends Car{  
   public DZ(String name){  
        super(name);  //super()：表示调用父类的构造函数。
                      //可以在一个类的非static成员内部使用。
    }  
}  
  
class Benz extends Car{  
    public Benz(String name){  
        super(name);  
    }  
}  
  
class BMW extends Car{  
    public BMW(String name){  
        super(name);  
    }  
      
} 

参考：【Java】Java中的多态_java多态-CSDN博客