面向对象的三大特征(封装、继承、多态)

前言：本文针对面向对象的三大特征(封装、继承、多态)进行的一个总结，主要从概念、优缺点、例子等几个方面进行。

封装

1.**概念**：所谓的封装就是指把属性和方法封装在一个类里面，使其成为一个不可分割的整体，将数据的信息隐藏起来。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问，也就是说用户不需要知道具体实现，只需要利用外部的接口实现即可。
2.**优缺点**
	优点：
	(1)通过方法来控制成员变量的操作，提供代码的安全性。
	(2)把代码用方法进行包装，提高了代码的复用性。
3.**例子**
	定义一个Student类，里面有name,age和score三个属性，还有study和homework方法。study方法输出了三个变量值，homework方法输出了家庭作业的完成情况。如果属性是私有的，即private，那么就不能直接直接使用，必须通过get变量名():获取成员变量值和set变量名(参数)：设置成员变量值来间接使用，变量名首字母均需大写。还可以通过快捷键快速使用：先按住键盘的Alt+Insert,然后选中Setter and Getter,最后全部选中点击OK即可。如果属性是公开的，即public，那么可以直接通过类名.变量名进行赋值，然后使用即可。

    private String name;
    private int age;
    public double score;

    public void setName(String name) {
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int a){
        if (a<0||a>100){
            System.out.println("输入的年龄有误");
        }else {
            age=a;
        }
    }
    public int getAge(){
        return age;

    }

    public void study(){
        System.out.println(name+","+age+","+score);
    }
    public void homework(){
        System.out.println("每次的家庭作业都完成");
    }
    public Example4(){
    }
    public Example4(String name,int age,double score){
        this.name=name;
        this.age=age;
        this.score=score;
    }

这里对年龄进行了一个判断，如果输入的年龄小于0或者大于100，则提示输入有误，这里进行了一个改进，使得代码更加完善。
通过测试类对Student类进行测试，创建对象，对变量进行赋值，并调用方法。

   Example4 s=new Example4();
   s.setName("李四");
   System.out.println(s.getName());
   s.setAge(20);
   System.out.println(s.getAge());
   s.score=90;
   s.study();
   s.homework();

运行结果为：

二、继承

1.**概念**：继承就是子类继承父类的属性和行为，即子类相应的就有父类的属性和行为，那么就可以直接调用父类的属性和方法。还可以定义子类独有的特性。
2.**优缺点**
	优点：
	(1)提高了代码的复用性(多个类的相同成员可以放在一个类中)
	(2)提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
	缺点：
	继承让类与类之间产生了联系，当父类发生变化时子类也不得不跟着发生变化，削弱了子类的独立性。
3.**构造方法的访问特点**
	子类的所有构造方法默认都会访问父类中的无参构造方法
4.**例子**
	定义一个Person父类，有name和age属性。

	private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

定义一个Student类继承Person父类。

public class Student extends Person{
    public Student(){ }
    public Student(String name,int age){
        super(name,age);
    }
    public void show(){
        System.out.println("天天向上");
    }
}

这里的super就是指调用父类的有参方法，然后再定义一个子类特有的show方法。

三、多态

1.**概念**：不同的对象可以执行相同的动作，但是需要通过自身的代码来实现。例如，猫吃东西和狗吃东西继承动物，都是相同的动作-动物吃，但是他们具体的实现方式不同，猫是吃鱼，狗是吃骨头，那么就得具体写。
2.**前提**：
	(1)有继承或实现关系。
	(2)重写父类的方法。
	(3)有父类引用指向子类对象。
3.**优缺点**
	优点：提高了程序的扩展性。
	缺点：不能使用子类特有功能。
4.**成员访问方法**
	成员变量：编译看左边，执行看左边。意思就是，如果创建对象后调用的成员变量父类没有，则会报错；如果父类和子类都有则会输出父类的成员变量。
	成员方法：编译看左边，执行看右边。意思就是，如果创建对象后调用的成员方法父类没有，则会报错；如果父类和子类都有则会输出子类的成员方法。
5.**例子**
	定义一个Animal父类，有三个属性：name、age和常量b。

public abstract class Animal {
    public final int b=10;
    private String name;
    private int age=40;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println("动物吃东西");
    }
}

然后定义一个子类Cat，里面也有一个常量b。

public class Cat extends Animal{
    public final int b=0;
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void show() {
        System.out.println("猫吃鱼");
    }
}

最后定义一个测试类AnimalDemo。

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a=new Cat();
        a.setName("如花");
        a.setAge(10);
        System.out.println(a.getName()+","+a.getAge());
        a.show();
        System.out.println(a.b);
    }
}

运行结果为：