java面向对象的三大基本特征之封装，继承，多态

java它是OOP语言（ObjectOrientedProgramming）面向对象编程语言，那么什么是对象？对象是什么？毫无疑问这个问题有很多个答案，每个人对对象的理解是不一样。
java面向对象的三大基本特征之封装：我们为什么要对我们的代码进行封装？当我们定义一个人类的体重，要求用户输入，如果用户输入1000kg,这个对我们人来说是不现实的，那我们要怎样使用户输入不合理时我们能及时的输出异常？这就要用到java里面的封装了。封装的优点：隐藏类实现细节；我们通过属性的get和set方法执行，这样我们后期修代码也比较方便。那么我们是怎样对属性进行封装？例

public class Dog {
    private String name;
    private int love;
    private int health;
    private String strain;
    /***
     * 获取name的值
     * @return name的值
     */
    public String getName() {
        return name;
    }
    /***
     * 对那么进行赋值
     * @param name 传回来的狗的名字
     */
    public void setName(String name) {
        this.name = name;
    }
    /***
     * 获取狗狗的亲密度
     * @return 狗狗的亲密度
     */
    public int getLove() {
        return love;
    }
    /***
     * 对狗狗的亲密度进行赋值
     * @param love 返回狗狗的亲密度
     */
    public void setLove(int love) {
        if (love>=0 && love<= 100){
        this.love = love;
        }else {
            this.love = 40;
            System.err.println("亲密度输入有误！！！默认为40");
        }
    }
    /***
     * 获取狗狗的健康值
     * @return 狗狗的健康值
     */
    public int getHealth() {
        return health;
    }
    /***
     * 对狗狗的健康值进行赋值
     * @param health 返回来的狗狗的健康的值
     */
    public void setHealth(int health) {
        if (health>=0 && health<= 100){
            this.health = health;
        }else {
            this.health = 40;
            System.err.println("健康值输入有误！！！默认为40");        }
    }
    /***
     * 获取狗品种
     * @return 狗品种
     */
    public String getStrain() {
        return strain;
    }
    /*** 
    * 给狗的品种进行赋值
     * @param strain 用户输入的狗的品种
     */
    public void setStrain(String strain) {
        if ("聪明的拉布拉多犬".equals(strain)||"酷酷的雪纳瑞".equals(strain)) {
            this.strain = strain;
        }else {
            this.strain = "聪明的拉布拉多犬";
            System.err.println("输入有误！！！！默认为聪明的拉布拉多犬");
        }
    }
    public String toString(){
        return "宠物自白：\n我的名字加"+name+"我的健康值为"+health+"我和主人的亲密度为"+love+"我的类型为"+strain;
    }
}

上述代码我们就是对我们定义的狗狗的名称，健康值，亲密度，以及狗的品种属性并进行了封装。我们通过set方法对属性进行赋值，通过get方法来对属性进行取值最后我们定义一个toString()方法输出我们要输出的内容。这要我们在测试类里面我们只需要提示用户输入名称，健康值，亲密度，以及狗的品种，同时我们向Dog类里面传值就可以了。这样我们要修改代码我们就只需要去修改Dog类就可以了。
在jsp中像上面的代码叫做JavaBean，其实就是封装。
java面向对象的三大特性之继承：继承就像太子继承皇位一样，他可以继承他父亲的皇位，得到他父亲的江山，当时他需要自己的国家更加的强大，那么他就需要有自己的改革。在java里面的继承也是这样，我们子类可以继承父类的东西，也可以有自己的东西。子类是通过关键字extends来继承父类。子类继承父类有几点注意事项：
1、当父类是一个抽象类时，子类如果继承他，那么子类必须实现父类的抽象方法。如果子类没有重写父类的抽象方法，那么这个子类也要定义为抽象类。
2、子类是不可以重写父类的构造方法的。
例：

/**
 * Created by Zippo on 2016/7/4.
 * 创建一个抽象的宠物类
 */
public abstract class Pet {
    private String name;
    private int love;
    private int health;
    public String getName() {
        return name;
    }
    /***
     * 对宠物名字进行赋值
     * @param name 传回来的宠物的名字
     */
    public void setName(String name) {
        this.name = name;
    }
    /***
     * 获取宠物的亲密度
     * @return 宠物的亲密度
     */
    public int getLove() {
        return love;
    }
    /***
     * 对宠物的亲密度进行赋值
     * @param love 返回宠物的亲密度
     */
    public void setLove(int love) {
        if (love>=0 && love<= 100){
            this.love = love;
        }else {
            this.love = 40;
            System.err.println("亲密度输入有误！！！默认为40");
        }
    }
    /***
     * 获取宠物的健康值
     * @return 宠物的健康值
     */
    public int getHealth() {
        return health;
    }
    /***
     * 对宠物的健康值进行赋值
     * @param health 返回来的宠物的健康的值
     */
    public void setHealth(int health) {
        if (health>=0 && health<= 100){
            this.health = health;
        }else {
            this.health = 40;
            System.err.println("健康值输入有误！！！默认为40");
        }
    }
    public abstract void print();
}

上述代码我们定义一个抽象的宠物类，因为宠物有很多，所以我们定义了一个抽象的方法输出我们要输出的东西。那么如果我们定义一个子类的话，我们必须实现这个宠物类的抽象方法，如果没有实现，那么他的子类也必须是抽象的，那么我们要怎样实现呢？
例：

public class Dog extends Pet {
    private String strain;
    /***
     * 获取狗品种
     * @return 狗品种
     */
    public String getStrain() {
        return strain;
    }
    /***
     * 给狗的品种进行赋值
     * @param strain 用户输入的狗的品种
     */
    public void setStrain(String strain) {
        if ("聪明的拉布拉多犬".equals(strain)||"酷酷的雪纳瑞".equals(strain)) {
            this.strain = strain;
        }else {
            this.strain = "聪明的拉布拉多犬";
            System.err.println("输入有误！！！！默认为聪明的拉布拉多犬");
        }
    }
    @Override
    public void print() {
        System.out.println("name::::"+getName()+"health::::"+getHealth()+"love::::"+getLove()+"strian::::"+strain);
    }
}

现在我们定义了一个Dog类他继承了Pet类，那么他要实现Pet类的抽象的输出方法，Dog类重写了Pet类的输出方法，通过这样的方式来实现Pet类的抽象方法。这就是继承。子类继承父类，不可以访问父类的私有的属性，子类只有通过父类的共有的方法去获取父类属性的值。这样我们在测试类中只需要向子类传值就可以了，同时我们也可以大量的节省重复的代码。
在类中，我们都知道类的加载顺序：
静态属性->静态代码块->实例属性->实例代码块->构造方法。
那么继承状态下的类加载顺序：
父类静态属性 ->父类静态块 ->子类静态属性 ->子类静态块->父类实例属性->父类实例块 ->父类构造方法 ->子类实例属性 ->子类实例块 ->子类构造方法。
java面对象的第三大特性：多态。多态就是我们运用一个消息，可以有多个不同的了对它做出响应。
我们运用多态来编写代码，在我们要更新我们代码的时候，我们再新建一个类，这样我们就可以直接运用，就不要去修改其他的代码，这样代码的可扩展性就比较的强了，同时我们也可以避免在我们修改代码的时候导致出现大量的bug.那我们怎样运用都太呢？例：
我们先创建一个抽象的宠物类，同时他也是一个父类，并对它的属性进行封装，定义一个抽象的方法。

public abstract class Pet {
    private String name;
    private int health;
    private int love;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
   public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public abstract  void  print();}

然后我们创建一个宠物类的子类狗类，对品种这个属性进行封装，实现Pet类的抽象方法。

public class Dog extends Pet{
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    private String strain;
    @Override
    public void print() {
        this.setHealth(getHealth());
        System.out.println(this.getName()+"正在打针，吃药体力恢复中.......");
    }
}

我们在创建主人类来给宠物看病。

public class Master {
    public void cure(Pet pet){
        if (pet.getHealth()<50){
            pet.print();
        }
    }
}

我们在主人这个类里面我们只是定义一个，这个方法的参数我们就是父类，这样我们在测试类中只需要调用这个方法就可以了。

public class petText {
    public static void main(String[] args) {
        Master master = new Master();
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入宠物的品种：");
        String str = scanner.next();
        System.out.print("请输入宠物的姓名：");
        String name = scanner.next();
        System.out.print("请输入"+name+"的健康值：（0--100）");
        int he = scanner.nextInt();
        System.out.print("请输入"+name+"的品种：");
        String strina = scanner.next();
        Dog dog = new Dog();
        master.cure(dog);
    }
}

这样我们就不用再使用dog.方法名了，我们只需要调用主人了里面的哪一个方法就可以了，把我们创建的dog这个对象传进去，这样我们就可以输出了。因为我们在主人类里面的有一个pet.print();方法，而我们的类型是父类。这样写的好处是当我们要更新新的一个动物的时候我们只需要创建一个该动物的类，我们不用去修改其它地方的代码，这样我们就可以避免在我们更新代码的时候出现bug了。
这就是面向对象的三大特性。因为有这些