likes
comments
collection

面向对象编程的三大特征

作者站长头像
站长
· 阅读数 12

封装、继承和多态是面向对象编程的三大特征。

1.封装

1.1.封装概念

封装就是把抽象出的数据(属性)和对数据的操作(方法)封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的操作(方法)才能对数据进行操作。

如:我们通过遥控器对电视机的操作就属于典型的封装。

1.2.封装的好处

  1. 隐藏实现的细节

一个操作具体的实现过程往往很复杂,通过封装用户和调用者可以直接使用提供的方法进行操作,不用关心其实现细节。

  1. 可以对数据进行验证,保证其安全合理

进行封装后,私有化类的成员变量,类中的实例变量不能直接进行查看和修改,用户需要通过提供的getter和setter方法才能操作,在方法中可以对用户输入的数据进行验证,从而控制数据的范围。

1.3.封装的实现步骤

  1. 将属性进行私有化private (不能直接修改属性)

  2. 提供公共的setter方法,用于对属性判断并赋值

  3. 提供公共的getter方法,用于获取属性的值

class person{

    private String name;//私有化,不能直接操作

    private int age;

    

    //通过getter方法得到数据信息

    public String getName(){

        return name;

    }

    

    public int getAge(){

        return age;

    }

    

    //通过setter方法设置属性

    public void setName(String name){

        this.name = name;

    }

    

    public void setAge(int age){

        if (age < 1 || age > 150){//对数据进行验证,保证其在合理的范围内

            System.out.println("年龄需要在1~150之内~");

        }

        this.age = age;

    }

}

2.继承

2.1.继承概念

继承可以提高代码的复用性,让编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过extends关键字来声明继承父类即可。

面向对象编程的三大特征

在子类中也可以重写父类的方法,这样子类在调用该方法时执行的是重写后的方法

public class test {

    public static void main(String[] args) {

        cat cat = new cat();

        cat.speak();

    }

}



class Animal {//父类

    public void speak(){

        System.out.println("动物会叫~");

    }

}



class cat extends Animal{//子类

    @Override

    public void speak() {//重写父类的speak()方法

        System.out.println("喵喵~");

    }

}

面向对象编程的三大特征

2.2.继承的好处

  1. 代码的复用性提高了
  2. 代码的扩展性和维护性提高了

2.3.子类对象实例化过程

1.从结果上来看: 继承性,子类继承父类以后就获取了父类中声明的属性或方法,创建子类对象后,在堆空间中就会加载所有父类中声明的属性。

2.从过程上来看: 当通过子类的构造器创建子类对象时,一定会直接或间接的调用其父类的构造器,进而调用父类的父类的构造器,直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构,所以才可以看到内存中有父类的结构,子类对象才可以考虑进行调用。

3.多态

3.1.多态基本介绍

一个方法或者对象具有多种形态(多态是建立在封装和继承的基础之上的);父类的引用指向子类的对象;允许不同类的对象对同一消息作出响应。不同对象调用相同方法即使参数也相同,最终表现行为是不一样的。

3.2.多态的具体体现

1.方法的多态

重写和重载

  • 重载在方法调用之前,编译器就确定了要调用的具体的方法,称为静态绑定
  • 对于多态而言,只有等到方法调用的那一刻解释运行器才会确定要调用的具体方法,称为动态绑定
public class test {

    public static void main(String[] args) {

        A a = new A();

        //通过不同的参数来调用a的sum()方法,就是调用的不同方法,体现方法的多态

        System.out.println(a.sum(1,2));

        System.out.println(a.sum(1,2,3));

        B b = new B();

        //根据不同的对象调用say()方法,会调用不同的方法

        a.say();

        b.say();

    }

}



class A {

    public int sum(int num1,int num2){

        return num1 + num2;

    }



    public int sum(int num1,int num2,int num3){//sum()方法的重载

        return num1 + num2 + num3;

    }

    

    public void say(){

        System.out.println("这是A的say()方法~");

    }

}



class B extends A{//子类

    @Override

    public void say(){//重写父类的say()方法

        System.out.println("这是B的say()方法~");

    }

}

面向对象编程的三大特征

3.3.对象的多态(多态的核心)

  1. 一个对象的编译类型运行类型可以不一致

  2. 在编译期只能调用父类中声明的方法,运行期实际执行的是子类中重写的方法

  3. 编译类型是定义对象时就确定的,不能改变

  4. 运行类型是可以变化的

Animal animal = new Dog();

//编译类型是Animal,而运行类型是Dog(向上转型)

animal = new Cat();

//编译类型还是Animal,运行类型变成了Cat

对象的多态在使用时需注意:

  • 前提:两个对象存在继承关系

  • 本质:父类的引用指向了子类的对象

  • 虚拟方法调用:向上转型后调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法,此时父类的方法叫做虚拟方法

  • 向上转型后内存中实际是加载了子类特有的属性和方法的,但是由于变量声明为父类类型,导致编译时只能调用父类中声明的属性和方法,不能使用子类的特有成员(可以使用强制转换进行向下转型)

  • 动态绑定机制

    • 当调用对象方法的时候,该方法会和该对象的运行类型绑定
    • 当调用对象属性的时候,没有绑定,哪里声明,哪里使用(看编译类型)

3.4.对象的多态的应用

1.多态数组

数组的定义类型为父类类型,里面保存的实际类型为子类类型

class Person{}

class student extends{}

class teacher extends{}

class text{

    public static void main(String[] args){

        Person[] persons = new Person[3];

        person[1] = new Person();

        //编译类型为父类Person,运行类型为子类

        person[2] = new studet();

        person[3] = new teacher(); 

    } 

}

2.多态参数

方法定义的形参类型为父类1类型,实参类型允许为子类类型

class Employee{}

class Worker extends Employee{}

class Manager extends Employee{}

class master{

    public static void salary(Employee e){}

}

class text{

    public static void main(String[] args){

        Worker worker = new Worker();

        Manager manager = new Manager();

        //形参为父类,可传入子类的对象

        master.salary(worker);

        master.salary(manager);

    }

}