OOP的三大特征：封装、继承、多态

最新推荐文章于 2024-07-28 16:03:25 发布
最新推荐文章于 2024-07-28 16:03:25 发布
阅读量888 收藏 2
点赞数 1
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45283185/article/details/124653535
版权

文章目录

前言

主要对封装、继承、多态这三大特性进行分析以及总结，再举一些实际的案例，便于理解。

一、封装

关于类和对象的知识可以看上一篇文章。
封装：将类的细节进行隐藏，隐藏对象的属性和实现细节，仅对外公开接口与对象进行交互。
例如：一个手机它内部的组成部分是用手机壳盖起来看不见的，它仅提供USB接口、耳机插孔一些接口。
封装增加了安全性。

代码实例（示例）：

public class Dog {
    //成员变量
    private String name;
    private String color;
    private int age;

	//无参构造方法
    public Dog() {
    }

	//有参构造方法
    public Dog(String name, String color, int age) {
        this.name = name;
        this.color = color;
        this.age = age;
    }
    //成员方法
    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getAge() {
        return age;
    }

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

二、继承

1.概念：抽取代码中的共性，提高代码的复用性。
关键字：extends
2.super：子类从父类继承过来的内存
3.super的三个用法：
（1）super.属性：调用父类属性
（2）super.方法名：调用父类方法
（3）super()：调用父类构造方法
注意：子类再构造时需要先使用super将父类构造完整。
4.super和this的区别：

1.引入案例1

无参构造方法
代码如下（示例）：

/**
 * 父类（基类）
 */
class Base {
    String name;
    int age;

    //默认
    /*Base() {
    }*/
    @Override
    public String toString() {
        return "Base{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * 子类（派生类）
 */
class Derived extends Base{
    double weight;
    //默认
    Derived() {
        super();
    }
    @Override
    public String toString() {
        return "Derived{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", weight=" + weight +
                '}';
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Base base = new Base();
        base.name = "父类";
        base.age = 20;
        System.out.println(base);
        
        Derived derived = new Derived();
        derived.weight = 1.0;
        derived.name = "子类";
        derived.age = 10;
        System.out.println(derived);
    }
}

2.引入案例2

有参构造方法
代码如下（示例）：


/**
 * 父类：动物
 */
class Animal {
    String name;
    int age;

    //有参构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Dog extends Animal{
    private String run;
    //子类有参构造方法
    public Dog(String name, int age, String run) {
        super(name, age);//super调用父类构造方法
        this.run = run;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", run='" + run + '\'' +
                '}';
    }
}
class Cat extends Animal {
    private double weight;

    public Cat(String name, int age, double weight) {
        super(name, age);
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", weight=" + weight +
                '}';
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗",10,"正在跑");
        System.out.println(dog);
        Cat cat = new Cat("小猫",5,4.9);
        System.out.println(cat);
    }
}

3.再谈初始化

执行顺序：
1.父类和子类的静态代码块
2.父类的实例和构造
3.子类的实例和构造

代码如下（示例）：

class Base2 {
    static {
        System.out.println("父类：静态代码块");
    }
    {
        System.out.println("父类：实例代码块");
    }

    public Base2() {
        System.out.println("父类构造方法");
    }
}

class Derived2 extends Base2{
    static {
        System.out.println("子类：静态代码块");
    }
    {
        System.out.println("子类：实例代码块");
    }
    public Derived2() {
        super();
        System.out.println("子类构造方法");
    }
}

public class TestDemo3 {
    public static void main(String[] args) {
        Derived2 derived2 = new Derived2();
    }
}

输出结果：
在这里插入图片描述

三、多态

实现条件

1、必须在继承的体系下（完成向上转型）；
向上转型的三种情况：
（1）直接赋值

class animal {
    String name;
    public void eat() {
        System.out.println("Animal:eat");
    }
}
class cat extends animal{
    @Override
    public void eat() {
        System.out.println("cat:eat");
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        animal animal1 = new cat();//直接赋值
    }
}

（2）方法传参

class animal {
    String name;
    public void eat() {
        System.out.println("Animal:eat");
    }
}
class cat extends animal{
    @Override
    public void eat() {
        System.out.println("cat:eat");
    }
}
public class TestDemo4 {
	//方法传参
    public static void transform(animal animal) {
        System.out.println("trans");
    }
    public static void main(String[] args) {
        cat cat1 = new cat();
        transform(cat1);
    }
}

（3）返回值

class animal {
    String name;
    public void eat() {
        System.out.println("Animal:eat");
    }
}
class cat extends animal{
    @Override
    public void eat() {
        System.out.println("cat:eat");
    }
}
public class TestDemo4 {
    public static animal trans() {
        return new cat();
    }

    public static void main(String[] args) {
        animal animal3 = trans();
    }
}

2、子类必须对父类中的方法重写；
3、通过父类的引用调用重写的方法（发生了动态绑定）。

代码如下（示例）：

class Animals {
    String name;
    int age;

    public Animals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("姓名:"+name+" 年龄:"+age+"正在吃~");
    }
}
class Dogs extends Animals{
    public Dogs(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("姓名:"+name+" 年龄:"+age+"正在吃垃圾");
    }
}
class Cats extends Animals{
    public Cats(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("姓名:"+name+" 年龄:"+age+"正在吃小鱼");
    }
}
public class TestDemo5 {
    public static void function(Animals animals) {
        animals.eat();
    }
    public static void main(String[] args) {
        //实现多态
        function(new Dogs("小白狗",1));
        function(new Cats("小花猫",2));
        //向下转型
        System.out.println("============向下转型=============");
        Animals animals = new Dogs("小黑狗",2);
        if(animals instanceof Cats) {
            Cats cats = (Cats) animals;
            cats.eat();
        }
        if(animals instanceof Dogs) {
            Dogs dogs = (Dogs) animals;
            dogs.eat();
        }
    }
}

重写和重载

重写不能改变参数列表、返回类型并且子类的访问限定权限要大于父类的访问限定权限。（加上final的方法不能被重写）
重载必须改变参数列表（参数的个数、类型、顺序）和返回类型并且访问限定符也可以修改。

总结

过了这么久终于把面向对象的三大特征总结了一下，主要是为了加深印象。。。

深入解析C#: 继承、多态与封装
墨夶的博客
02-04 1551
封装是将数据（属性）和操作数据的方法（行为）绑定在一起，并隐藏对象的内部实现细节，只暴露必要的接口给外部使用。封装的主要目的是提高代码的安全性和模块化程度。继承是面向对象编程的一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用和层次结构。多态是指同一个方法调用可以在不同的对象上表现出不同的行为。多态性通过继承和接口实现，使得代码更加灵活和可扩展。继承、多态和封装是面向对象编程的基石，它们共同构成了强大的工具集，帮助开发者构建高效、可维护和灵活的系统。
面向对象三大特性：封装、继承、多态深度解析
最新发布
KBkongbaiKB的博客
03-15 1261
OOP。
OOP的三大特性：封装、继承、多态
weixin_43811679的博客
06-30 1115
面向对象的三大特性：封装，继承，多态 1.封装 封装就是使用特殊的语法，对成员属性和成员方法进行包装，达到保护和隐藏的目的； 但是一定注意，不能把成员全部封装死，就失去意义了； 被封装的成员主要是供类的内部使用，是限制了访问的权限，并不是完全不让访问； 被特殊语法封装的成员，会有不同的访问的权限。 正常来说在类的外部不能操作受保护的成员：_成员 ，但是python中可以 封装的级别 封装的级别： 成员 ==> 公有的 public _成员 ==> 受保护的 prot
面向对象的三个基本特征(转-收藏)
weixin_33862041的博客
03-01 532
面向对象的三个基本特征（讲解） 面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功...
Java se
jlcheerful的博客
09-22 315
笔记
oop三大特征
qq_47970452的博客
12-29 2050
java初学者的总结
OOP三个基本特征
Holden_Liu的博客
10-10 3706
封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程(OOP)语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 继承现有类 + 扩展 通过继承创建的新类称为“子类”或“派生类”。 被继承的类称为“基类”、“父类”或“超...
C# 面向对象三大特性：封装、继承、多态
09-02
在C#中，面向对象的三大特性——封装、继承和多态，是实现这一目标的关键工具。 1. 封装 封装是面向对象编程的基础，它意味着将数据和操作这些数据的方法捆绑在一起，形成一个独立的单元，即类。在C#中，我们可以...
【小白级理解】面向对象三大特征：封装、继承、多态
生活很苦，但学习还得继续
08-07 1220
文章目录前言一、面向对象的基本概念1、对象2、类二、面向对象的三大特征1、封装（1）概述（2）原则（3）总结2、继承（1）概述（2）继承的好处和弊端3、多态总结 前言 面向对象简称 OO（Object Oriented），20 世纪 80 年代以后，有了面向对象分析（OOA）、 面向对象设计（OOD）、面向对象程序设计（OOP）等新的系统开发方式模型的研究。   对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计
OOP-----封装，继承，多态
小菜鸟正洋洋的博客
06-19 1989
1.封装（ public protected  private）      可以把封装理解成隐藏，我们所定义的类里面的成员有时我们不能让用户或者没有权限的客户去修改他们，我们要想办法让里面的成员得到隐藏，类在定义成员时就可以使用关键字 public（公有），protected（受保护）或 private（私有）来实现的访问控制。    2.继承 (extends)      继承已为大家
OOP的三大特性
09-08 579
面向对象编程: 一切皆对象 OOP: OOP是面向对象编程，三大特征 : 封装、继承、多态。 抽象 : 将一个事物抽象定义成类,对这个事物详细的描述都定义为属性和方法, 事物的性质是属性, 事物的行为是方法, 　　 一 . 封装: 将事物封装为类,隐藏对象属性,方法实现的细节, 仅提供可供调用的接口对对象的成员进行访问限制 python中对访问权限的限制...
对象编程（OOP）三大特性
xycxycooo的博客
07-28 597
面向对象编程（OOP）有三大核心特性，分别是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。下面我将详细解释这三大特性，并通过编程示例来帮助理解。
OOP 三大特性
weixin_55347832的博客
05-05 371
面向对象三大特性 封装性： 定义：封装是面向对象编程的核心思想，将类的某些信息隐藏在类的内部，不允许外部程序调用，而是通过该类提供的方法来对隐藏的信息进行操作和封装 设计思想： 高内聚：类的内部数据操作细节自己完成，不允许外部干涉 低耦合：仅对外暴露少量的方法用于使用 作用： 保证了类内部数据结构的完整性 应用该类的用户不能轻易的操作此数据结构 只能执行类公开的数据 避免外部类对内部数据的影响，提高程序的可维护性 提高代码的安
OOP编程三大特性
qq_41185460的博客
11-21 1311
OOP(面向对象编程)具有三大特性（继承、封装、多态），了解之后总结如下： 封装 继承 向上转型 向下转型 重写 运行时绑定（动态绑定） 多态 封装 封装的本质是让类的调用者不必太多类的实现者是如何实现类的，只知道如何使用类就行了。 public修饰的成员变量或成员方法，可以直接被类的调用者使用。 private修饰的成员变量或成员方法，不可以直接被类的调用者使用。 当要获取或者修...
OOP的三大基本特征
Temptatn的博客
10-07 190
static静态变量：1.成员变量：静态变量，可以直接通过类名访问 2.成员方法：静态方法，可以直接通过类名访问 3.代码块：静态代码块，当java虚拟机加载类时，就会执行代码块 4.在内存中只有一个拷贝 5.类内部，可在任何方法内直接访问静态变量 6.其他类中，可以直接通过类名访问类成员的访问控制 7.能被其他类的所有实例共享，可作为实例之间进行交流的共享数据。super关键字:1.子类调用父类成员的成员，使用super.成员 2.子类构造器中调用父类的构造器，用super（）定义：也叫信息隐藏。
OOP三大特性
qpmglj的专栏
04-12 3444
封装、继承、多态封装性把敏感数据封装在类中，不受外界访问。将某一功能的方方面面封装成一个工具类；例如封装一个数据库工具类，提供数据库的所有常用功能，在类外不能再使用“mysql_*”函数。继承性：如果一个B类有了A类的所有特征信息，那么就认为B类继承A类。继承是为了实现功能的增加和扩展。多态性：在面向对象的理论 中，多态性的一般定义为：同一个操作作用于不同的类的实例，将产生不同的执行结果。方法重载...
面向对象程序设计（OOP）的三大基本特征（定义、特性、优缺点、java中的表现形式及应用）和五大基本原则
幸福的小金火
02-21 4372
一、面向对象程序设计（OOP）的三大基本特征（定义、特性、优缺点、java中的表现形式、应用） 1.封装 封装的定义 ​ 通俗的说：普通人对计算机进行应用操作，只需知道如何在计算机上连网，如何浏览网页，下载东西等。不需要知道网络的具体底层搭建，计算机的基本结构组成（这些可以看作被封装）。 ​ 对于编程来说：将对象的属性（状态）和方法（行为）封装成一个类。而这个类可以有很多对象。举例：人这个类（class），可以有很多不同的人（每个人即为每个对象），而人都有相同的属性描述词（身高，体重），也有相同的行为描述
c#oop继承-封装-多态
xioamages的博客
10-15 362
C# 封装 封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。 抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。 C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。 一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如...
理解OOP三大特征：封装 继承 多态
nefss_的博客
07-18 404
一、OOP三大特征之封装 1.什么是封装？ 使用private修饰类的成员变量和方法，使得只能在本类中使用和修改这些成员变量和方法，类外如果想要访问需要通过接口来实现。 好处是类的实现对类外不可见比较安全，而对类的调用者来说不需要知道类的实现细节，直接调用公有方法，降低了代码管理的复杂度。 2.this关键字 代表当前对象的引用，①可以使用this()调用当前类的构造方法；②this.属性名 调用当前类的属性；③this.方法名() 调用当前类的成员方法。 注意：new一个对象需要先在堆上开辟内存，然后调用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值