Java中面向对象三大特征（封装、继承、多态）

Smiling Mr. Rui

已于 2024-05-07 14:23:01 修改

阅读量827

点赞数 18

分类专栏：网络安全文章标签： java 开发语言

于 2024-05-05 18:06:05 首次发布

本文链接：https://blog.csdn.net/AXDRXS/article/details/138451183

版权

网络安全专栏收录该内容

30 篇文章 0 订阅

订阅专栏

本文详细介绍了面向对象编程中的封装、继承和多态概念，包括封装的原理和实现、继承的优势与局限，以及多态的定义、使用要求和实例。

摘要由CSDN通过智能技术生成

一、封装

所谓封装就是将对象的属性隐藏起来，不让外界直接访问，而是通过指定的方法来访问对象的属性，就叫封装。Java 中封装是面向对象三大特征之一，它的作用就是让程序的安全性得以提高。

1.1 封装的意义

我们通过下面的示例来说明这个问题。

我们创建一个 Human 类，在这个类中定义两个属性，一个姓名，一个年龄。

class Human {
    String name;
    private int age;

    public void setAge(int newAge) {
        age = newAge;
    }
    public int getAge() {
        return age;
    }
}
public class HumanTest {
    public static void main(String[] args) {
        Human human = new Human();
        human.name = "张三";
        //human.age = -18;
        human.setAge(18);

        System.out.println(human.name + " " + human.getAge());
    }
}

通过上面的示例演示，如果我们不把 age 属性隐藏起来，那么在外部（HumanTest类中的 main 方法中）就可以直接对这个属性进行赋值。这就会产生不确定的因素，如给年龄一个负数或都一个很大的数。这些情况都是不对的。为了避免这种情况的发生，我们需要把这个属性进行隐藏，从而提高程序的健康性。

1.2 如何进行封装

在 Java 中需要使用 private 关键字来修饰要被隐藏的属性。然后提供这个属性对应的两个公共方法：一个用于对这个属性进行赋值，另一个用于对这个属性进行获取值。

class Human {
    String name;
    private int age;

    public void setAge(int newAge) {
        age = newAge;
    }
    public int getAge() {
        return age;
    }
}

例如上面代码中的 setAge(int newAge) 和 getAge() 这两个方法都是封装方法。一般来说，给属性赋值的方法取名为 setXXX，而获取属性值的方法取名为 getXXX。其中XXX 表示属性的名称，该名称的首字母大写。

注意：为了安全性，在写实体类中，只要有属性存在都需要进行封装。

二、继承

继承是面向对象程序设计的第二个特征，为了提高代码的复用率，继承应运而生。

2.1 继承的意义

我们通过如下的案例来说明这个问题。

class Woman {
    public String name;
    public int age;
    public void show() {
        System.out.println(name + " " + age);
    }
}

class Man {
    public String name;
    public int age;
    public void show() {
        System.out.println(name + " " + age);
    }
}

public class PersonDemo {
    public static void main(String[] args) {
        Man man = new Man();
        man.name="张三";
        man.age=18;
        man.show();

        Woman woman = new Woman();
        woman.name = "李四";
        woman.age=19;
        woman.show();
    }
}

从上面的代码中可以发现，现个类中除了类名不同以外，其余的代码都是相同的。这样的话代码复用率就不高。为了让代码的复用率更高。我们可以把两个类中相同的代码提取出来形成一个单独的类，然后让这两个类去继承它即可。

2.2 如何继承

首先我们需要定义一个父类，在这个父类中定义公共的属性或方法。例如上面的示例中我们可以定义一个父类如：Person，然后在这个父类中定义公共的属性和方法。

class Person {
    public String name;
    public int age;
    public void show() {
        System.out.println(name + " " + age);
    }
}

class Woman extends Person {

}

class Man extends Person {
    
}

public class PersonDemo {
    public static void main(String[] args) {
        Man man = new Man();
        man.name="张三";
        man.age=18;
        man.show();

        Woman woman = new Woman();
        woman.name = "李四";
        woman.age=19;
        woman.show();
    }
}

子类需要使用 extends 关键字来继承父类。通过这样的操作后，Person类中父类或者叫基类，而Man和 Woman 叫子类或者派生类。

2.3 继承的优点

提高了代码的复用率
它是多态前提条件

2.4 继承的缺点

父类中私有的属性和方法，子类是无法使用的
在java中只支持单继承，不支持多继承，但是可以支持多重继承
继承后子父类的关系就接合得非常的紧密，不利于程序的扩展，从而减少了程序的灵活性。
父类无法访问子类的属性和方法

三、多态

3.1 多态的定义

一个对象在不同条件下表示的不同形态就叫多态，在程序中，多态是父类引用指定子类对象。

// 多态
class Father {
    String name;
    public void desc() {
        System.out.println("----------");
        System.out.println(name + "小头爸爸");
    }
}
class Son extends Father {
    String name;
    public void desc() {
        System.out.println("+++++++++++++");
        System.out.println(name + "大头儿子");
    }
}

public class PolymorphicDemo1 {
    public static void main(String[] args) {
        Father father = new Son();
        father.name = "大头儿子";
        father.desc();
    }
}

另一种多态的使用方式是在方法的参数上，一般我们在使用工厂设计模式时会使用多态。

//
abstract class Animal {
    abstract void haha();
}
class Cat extends Animal {
    @Override
    void haha() {
        System.out.println("Cat haha()");
    }
}
class Dog extends Animal {
    @Override
    void haha() {
        System.out.println("Dog haha()");
    }
}

class HelloKit {
    public static Animal create(Animal animal) {
        if (animal instanceof Cat) {
            return new Cat();
        }else if (animal instanceof Dog) {
            return new Dog();
        } else {
            return null;
        }
    }
}
public class HelloKitDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();

        Animal animal = HelloKit.create(cat);
        animal.haha();

        Animal animal1 = HelloKit.create(dog);
        animal1.haha();

    }
}

在参数列表上，使用父类去接收，也是一种多态的使用方式。

3.2 多态的使用要求

1，在多态的情况下，不能使用子类特有的方法

class Person {
    public int age = 5;
    public void show() {
        System.out.println("Person age: " + age);
    }
}
class Student extends Person {
    public int age = 10;
    public String name = "小明";
    public void show() {
        System.out.println("Student age: " + age);
    }
    public void speak() {
        System.out.println(name);
    }
}

public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        p.show(); // 可以执行
        p.speak(); // 报错，因为 speak 方法是子类特有的方法
    }
}

2，多态在例子中如果属性是非静态的，它的值是看等号左边

// 多态的注意事项
class Person {
    public int age = 5;
    public void show() {
        System.out.println("Person age: " + age);
    }
}
class Student extends Person {
    public int age = 10;
    public String name = "小明";
    public void show() {
        System.out.println("Student age: " + age);
    }
    public void speak() {
        System.out.println(name);
    }
}

public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        System.out.println(p.age); // 5 ，是不是 10
    }
}

原因：我们使用的是多态，也就是说我们输出的 p.age ，而 p 是父为的引用，它获取到的值就是父类中定义的值。

在多态下，编译是看等号的左边，运行时如果是属性则看等号左边。

3，在多态下的非静态方法

// 多态的注意事项
class Person {
    public int age = 5;
    public void show() {
        System.out.println("Person age: " + age);
    }
}
class Student extends Person {
    public int age = 10;
    public String name = "小明";
    public void show() {
        System.out.println("Student age: " + age);
    }
}

public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        p.show();
    }
}

在多态下，编译是看等号的左边，运行时如果方法是非静态的看等号的右边。

4，在多态下的静态成员

// 多态的注意事项
class Person {
    public static void x() {
        System.out.println("Person static x");
    }
}
class Student extends Person {
    public static void x() {
        System.out.println("Student static x");
    }
}
public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        p.x(); // Person static x
    }
}

在多态下，静态的成员在编译和运行时都看等号的左边。

Smiling Mr. Rui

关注

18
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java中面向对象三大特征（封装、继承、多态）

一个对象在不同条件下表示的不同形态就叫多态，在程序中，多态是父类引用指定子类对象。// 多态System.out.println(name + "小头爸爸");System.out.println(name + "大头儿子");father.name = "大头儿子";另一种多态的使用方式是在方法的参数上，一般我们在使用工厂设计模式时会使用多态。//@Override@Override} else {在参数列表上，使用父类去接收，也是一种多态的使用方式/
复制链接

扫一扫