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

系列文章目录

• 面向对象
• 封装
• 继承
• 多态
• 总结

---

前言

Java 是面向对象的高级编程语言，类和对象是 Java 程序的构成核心。围绕着 Java 类和 Java 对象，有三大基本特性：封装是 Java 类的编写规范、继承是类与类之间联系的一种形式、而多态为系统组件或模块之间解耦提供了解决方案。

 

一、面向对象

java是电脑编程语言，对象就是面对对象程序设计的核心，对象就是真实世界的实体，在生活中，每一个实体就是一个对象，所以一切皆为对象（例如一块手表，一个手机，人，动物）如下图所示。

每个对象都有自己的行为和属性

面向对象的开发更利于人们开拓思维，方便了程序员的划分，提高开发效率，有下面三个优点

1.可重复性：减少代码量，提高开发效率.

2.可扩展性：便于加入代码中，便于修改

3.可管理性：能把功能和数据结合，方便管理。.

 当然和对象相关的就有它的三大特征（封装，继承，多态）下面我就来讲讲它的三大特征

 

二、封装

封装可以视为是对数据和代码的一种保护屏障，防止被数据访问。

如果想访问该类的代码和数据，就必须通过封装所设置的调用方法。

封装也让程序代码更容易维护，方便理解，最重要的就是安全，提高了代码的复用性。

如何封装？

需要先修改属性的可见性，需要用private来修饰，这是为了保护一些内部的信息，不让外界直接访问。

被private修饰后，需要怎么访问呢，接下来就要用到我们的get和set的方法，set用于属性的写，get用于属性的读，

外界如果要想要访问被封装的类，就得用到类的get和set的方法

封装就是吧代码和程序当货如下用对应的东西打包起来

 

代码如下（一个学生类）：

public class Student {
    //学号
    private String sid;
    //姓名
    private String name;
    //年龄
    private String age;
    //居住地
    private String address;

    public Student(){}
    public Student(String sid,String name,String age,String address){
        this.address=address;
        this.age=age;
        this.name=name;
        this.sid=sid;
    }
    public void setSid(String sid){
        this.sid=sid;
    }
    public String getSid(){
        return sid;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(String age){
        this.age=age;
    }
    public String getAge(){
        return age;
    }
    public void setAddress(String address){
        this.address=address;
    }
    public String getAddress(){
        return address;
    }
}

 三、继承

 什么是继承呢？

继承如同生活中的子女拥有父母的特点特征一样，在java中就是儿子拥有父亲的一切属性和行为。这是类之前的一种关系，类支持单继承，但是接口支持多继承。

把一个类（类1）的所有属性和行给另外一个类（类2），那么类1就是类2的父类

如下图所示

汽车是一个大的类别，奔驰和法拉利是汽车的两个子类，而奔驰又可以分为梅赛德斯和奔驰S级两个子类，法拉利也可以分为599GTB和F430两个子类

 怎么继承？

语法需要用到extends，extands的意思是“扩展”的意思，所有就是让子类扩展下父类的内容，Object类是所有类的超类（父类）

继承了怎么使用呢？

需要用到父类的属性时，要用到super参数，用到成员变量的时候需要用到this参数，用来区分成员边浪和局部变量。

访问变量的时候，现在子类局部范围找，没有再到子类成员范围找，没有再到父类成员范围找，如果在没有就会报错。

代码如下（这个一个动物类（父类））：

public class Animal {
    private String name;
    private int month;
    private String species;

    public Animal() {

    }

    public String getName() {
        return name;
    }

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

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    //吃东西
    public void eat(){
        System.out.println(this.getName()+"在吃东西");
    }

}

代码如下（这个一个猫类（子类））：

public class Cat extends Animal {
    private double weight;

    public Cat() {

    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    //跑动的方法
    public void run(){
        System.out.println(this.getName()+"是一只"+getSpecies()+"的猫，他在跑。");
    }

}

代码如下（这个一个测试类）：

public class Test {
    public static void main(String[] args) {
        Cat one=new Cat();
        one.setName("十二");
        one.setSpecies("中华田园猫");
        one.eat();
        one.run();
        System.out.println("=================");
        Dog two=new Dog();
        two.setName("负十二");
        two.setMonth(2);
        two.eat();
        two.sleep();

    }
}

四、多态

多态就相对前面两个就比较麻烦，多态就是表示一种类有不同的形态举个例子

 这里的猫既有猫的形态又有动物的形态

多态的前提是什么？

• 有继承/实现的关系
• 有方法的重写
• 有父类引用指向子类对象

方法的重写就是在子类中把父类的方法重写写下。

有父类指向子类的对象就是让子类表现出父类的形态。

多态的访问特点

成员变量：编译看左边，执行看左边

成员方法：编译看左边，执行看右边

多态的好处和弊端

好处：提高了程序的扩展性。

弊端：不能使用子类的特有功能

一般用于使用父类作为参数，使用子类进行操作。

向上转型

父类 定义名=new 子类（）；

Animal a=new Cat();

向下转型

子类 子类对象=（子类）父类对象；

Cat c=(Cat)a;

代码如下(A为父类B,C为两个子类)：

class A{
    public void Out()
    {
        System.out.println("This is A");
    }
}

class B extends A{
    public void Out()
    {
        System.out.println("This is B");
    }
}

class C extends A{
    public void Out()
    {
        System.out.println("This is C");
    }
}

代码如下(测试类)：

public static void main(String[] args)
    {
//向上转型
        A isA=new A();
        isA.Out();//输出A
        A isB=new B();
        isB.Out();//输出B
        A isC=new C();
        isC.Out();//输出C
//向下转型
        B b=（B）siA;
        siA.Out();//输出B
    }

谢谢大家的观看，今天就介绍在这里！