Java面向对象的三大特征详解

一、封装（Encapsulation）

      封装也称信息隐藏，是指利用抽象数据类型把数据和基于数据的操作封装起来，使其成为一个不可分割的整体，数据隐藏在抽象数据内部，尽可能的隐藏数据细节，只保留一些接口使其与外界发生联系

     封装性的思想：

• 将类的属性私有化
• 提供公共的方法（setter & getter）来实现调用

package com.yyx.pratice;

/**
 * JavaBean
 */
public class Person {
    private String name;
    private Integer age;

    public Person() {
        super();
    }

    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }

    /*
     * 封装属性
     */
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

二、继承（Inheritance）

      继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力   

      继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。

若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类A为基类、父类或超类，而称继承类B为A的派生类或子类

 注意：java中类的继承性只支持单继承：一个类只能继承一个父类。反之，一个父类可以有多个子类；一个接口可以有多个父类，也就是接口可以是多继承

           子类实例化对象会先创建父类的对象

package com.yyx.pratice;

public class Person {
    private String name;
    private Integer age;

    public Person() {
        super();
        System.out.println("我是父类的空参构造器");
    }

    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
        System.out.println("我是父类的有参构造器");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("吃饭!");
    }

    public void walk() {
        System.out.println("走路!");
    }
}

package com.yyx.pratice;

public class Student extends Person {
    private String stuNo;

    public Student() {
        super();
    }

    public Student(String name, Integer age, String stuNo) {
        super(name, age);
        this.stuNo = stuNo;
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    @Override
    public void eat() {
        super.eat();// 显示调用父类的eat()方法
        System.out.println("我重写了父类的eat()方法");
    }

    public void study() {
        System.out.println("子类自己的study()方法");
    }
}

package com.yyx.pratice;

public class JavaPratice {
    public static void main(String[] args) {
        Student student=new Student();
        student.eat();
        student.walk();
        student.study();

        Student stu=new Student("李四", 23, "1232");
        stu.eat();
        stu.walk();
        stu.study();
    }
}

运行结果：

我是父类的空参构造器
吃饭!
我重写了父类的eat()方法
走路!
子类自己的study()方法
我是父类的有参构造器
吃饭!
我重写了父类的eat()方法
走路!
子类自己的study()方法

三、多态（Polymorphism）

     多态性，可以理解为一个事物的多种表型形态。 两种表现形式：1）方法的重载与重写    2）子类对象的多态性

子类对象的多态性即父类的引用指向子类对象，父类引用只能调用父类中存在的方法和属性，不能调用子类的扩展部分，因为父类引用指向的是堆中子类对象继承的父类；

但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了；同时，父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接

 子类对象的多态性使用的前提：①要有类的继承或实现②要有子类对父类方法的重写

程序运行分为编译状态和运行状态。对于多态性来说，编译时，"看左边"，将此引用变量理解为父类的类型；运行时，"看右边",关注于真正对象的实体：子类的对象。那么执行的方法就是子类重写的

package com.yyx.pratice;

public class JavaPratice {
    public static void main(String[] args) {
        Person person = new Student();
        person.eat();// 只能调用子类已经重写的父类Person的eat()方法
        if (person instanceof Student) {
            Student stu1 = (Student) person;
            /*
             * 调用子类才有的方法
             */
            stu1.study();
            stu1.walk();
        }

        Behavior behavior = new Student();
        behavior.walk();// 只能调用子类已经重写的接口Behavior的walk()方法
        if (behavior instanceof Student) {
            Student stu2 = (Student) behavior;
            /*
             * 调用子类才有的方法
             */
            stu2.study();
            stu2.eat();
        }
    }
}

class Student extends Person implements Behavior {

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void walk() {
        System.out.println("人都要走路");
    }

    public void study() {
        System.out.println("学生要学习");
    }

}

class Person {
    public void eat() {
        System.out.println("人都要吃饭");
    }
}

interface Behavior {
    void walk();
}

原文地址：https://www.cnblogs.com/guhun/p/8522493.html