Java笔记5——面向对象（下）

news2025/4/17 2:58:25

目录

一、抽象类和接口 

1-1、抽象类（包含抽象方法的类）

1-2、接口

​编辑​编辑

二、多态

​编辑

1. 自动类型转换（向上转型）

示例：

注意：

2. 强制类型转换（向下转型）

示例：

注意：

3. 类型转换的注意事项

4、instanceof 关键字：

总结

 三、Object类

 四、内部类

 内部类的作用

4-1、成员内部类 

4-2、局部内部类

 4-3、静态内部类

4-4、匿名内部类 

 

 

一、抽象类和接口 

  • 抽象类：是一个半成品的模具，提供了一个通用的框架，但需要子类来完成具体的实现。

  • 接口：是一个协议，定义了一组行为，但不关心这些行为是如何实现的。

1-1、抽象类（包含抽象方法的类）

        抽象类中的某些方法是抽象的（没有具体实现），这些方法就像是模具上的预留孔，等待子类（具体的物品）来填充。————就相当于自定义功能实现区入口，同一种功能不同的对象实现效果不一样（如：发出声音这个功能，狗发出的声音是汪，而猫发出的声音是喵），实现效果不同则实现方法不同。

 代码示例

//定义抽象类Animal
abstract class Animal {
    //定义抽象方法shout()
    abstract void shout();
}

//定义Dog类继承抽象类Animal
class Dog extends Animal {
    //重写抽象方法shout()
    void shout() {
        System.out.println("汪，汪……");
    }
}
class Cat extends Animal {
    //重写抽象方法shout()
    void shout() {
        System.out.println("喵，喵……");
    }
}

//定义测试类
public class Example10 {
    public static void main(String[] args) {
        Dog dog = new Dog(); //创建Dog类的对象
        Cat cat = new Cat();
        dog.shout(); //通过dog对象调用shout()方法
        cat.shout();//通过cat对象调用shout()方法
    }
}

输出

 注意：使用abstract关键字修饰的抽象方法不能使用private修饰，因为抽象方法必须被子类实现，如果使用了private关键字修饰抽象方法，则子类无法实现该方法。

1-2、接口

 接口（Interface） 接口就像是一个协议。它定义了一组规则或行为，但不关心这些行为是如何实现的。任何实现了这个接口的类都必须遵守这个协议，提供接口中定义的所有方法的实现。

 代码示例

//定义接口Animal
interface Animal {
    int ID = 1; //定义全局常量，编号
    String NAME = "牧羊犬"; //定义全局常量，名称
    void shout(); //定义抽象方法shout()
    public void info(); //定义抽象方法info()
    static int getID() { //定义静态方法getID(),用于返回ID值
        return Animal.ID;
    }
}

interface Action { //定义抽象方法eat()
    public void eat();
}

//定义Dog类实现Animal接口和Action接口
class Dog implements Animal, Action {
    //重写Action接口中的抽象方法eat()
    public void eat() {
        System.out.println("喜欢吃骨头");
    }
    //重写Animal接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪……");
    }
    //重写Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

//定义测试类
class Example11 {
    public static void main(String[] args) {
        System.out.println("编号" + Animal.getID());
        Dog dog = new Dog(); //创建Dog类的实例对象
        dog.info(); //调用Dog类中重写的info()方法
        dog.shout(); //调用Dog类中重写的shout()方法
        dog.eat(); //调用Dog类中重写的eat()方法
    }
}

输出

// 定义接口 Animal
interface Animal {
    public String NAME = "牧羊犬"; // 定义全局常量，名称
    public void shout(); // 定义抽象方法 shout()
    public void info(); // 定义抽象方法 info()
}

// 定义抽象类 Action
abstract class Action {
    public abstract void eat(); // 定义抽象方法 eat()
}

// 定义 Dog 类继承 Action 抽象类，并实现 Animal 接口
class Dog extends Action implements Animal {
    // 重写 Action 抽象类中的抽象方法 eat()
    public void eat() {
        System.out.println("喜欢吃骨头");
    }

    // 重写 Animal 接口中的抽象方法 shout()
    public void shout() {
        System.out.println("汪汪……");
    }

    // 重写 Animal 接口中的抽象方法 info()
    public void info() {
        System.out.println("名称:"+NAME);
    }
}

// 定义测试类
class Example12 {
    public static void main(String[] args) {
        Dog dog = new Dog(); // 创建 Dog 类的实例对象
        dog.info(); // 调用 Dog 类中重写的 info() 方法
        dog.shout(); // 调用 Dog 类中重写的 shout() 方法
        dog.eat(); // 调用 Dog 类中重写的 eat() 方法
    }
}

 输出：

 注意：在JAVA中，接口不允许继承抽象类，但是允许接口继承接口，并且一个接口可以继承多个接口。

示例：

// 定义接口 Animal
interface Animal {
    public String NAME = "牧羊犬"; // 定义常量 NAME
    public void info(); // 定义抽象方法 info()
}

// 定义 Color 接口
interface Color {
    public void black(); // 定义抽象方法 black()
}

// 定义 Action 接口，它同时继承 Animal 接口和 Color 接口
interface Action extends Animal, Color {
    public void shout(); // 定义抽象方法 shout()
}

// 定义 Dog 类实现 Action 接口
class Dog implements Action {
    // 重写 Animal 接口中的抽象方法 info()
    public void info() {
        System.out.println("名称:" + NAME);
    }

    // 重写 Color 接口中的抽象方法 black()
    public void black() {
        System.out.println("黑色");
    }

    // 重写 Action 接口中的抽象方法 shout()
    public void shout() {
        System.out.println("汪汪……");
    }
}

// 定义测试类
class Example13 {
    public static void main(String[] args) {
        Dog dog = new Dog(); // 创建 Dog 类的 dog 对象
        dog.info(); // 调用 Dog 类中重写的 info() 方法
        dog.shout(); // 调用 Dog 类中重写的 shout() 方法
        dog.black(); // 调用 Dog 类中重写的 black() 方法
    }
}

二、多态

// 定义抽象类 Animal
abstract class Animal {
    abstract void shout(); // 定义抽象 shout() 方法
}

// 定义 Cat 类继承 Animal 抽象类
class Cat extends Animal {
    // 重写 shout() 方法
    public void shout() {
        System.out.println("喵喵……");
    }
}

// 定义 Dog 类继承 Animal 抽象类
class Dog extends Animal {
    // 重写 shout() 方法
    public void shout() {
        System.out.println("汪汪……");
    }
}

// 定义测试类
public class Example14 {
    public static void main(String[] args) {
        Animal an1 = new Cat(); // 创建 Cat 类的对象并转型为 Animal 类的对象
        Animal an2 = new Dog(); // 创建 Dog 类的对象并转型为 Animal 类的对象
        an1.shout(); // 调用 Cat 类中重写的 shout() 方法
        an2.shout(); // 调用 Dog 类中重写的 shout() 方法
    }
}

 

Java 中的对象类型转换是面向对象编程中的一个重要概念，它允许我们将一个对象从一种类型转换为另一种类型。

类型转换可以分为 自动类型转换 和 强制类型转换，具体取决于上下文和对象之间的继承关系。

1. 自动类型转换（向上转型）

向上转型是指将子类对象转换为父类类型。这种转换是安全的，因为子类继承了父类的所有属性和方法，因此可以直接赋值给父类引用。

示例：
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog(); // 创建 Dog 对象
        Animal animal = dog; // 自动向上转型为 Animal 类型
        animal.eat(); // 调用父类方法
        // animal.bark(); // 错误：Animal 类型没有 bark() 方法
    }
}
注意：

  • 向上转型后，父类引用只能访问父类的方法和属性，无法访问子类特有的方法。

  • 如果需要访问子类特有的方法，需要进行向下转型。

2. 强制类型转换（向下转型）

向下转型是指将父类对象转换为子类类型。这种转换需要显式地进行，并且只有在对象的实际类型是子类时才安全。如果对象的实际类型不是子类，会抛出 ClassCastException。

示例：
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog; // 向上转型

         //制向下转型
        Dog dog2 = (Dog) animal;
        dog2.bark(); // 可以调用子类特有的方法
    }
}
注意：

  • 强制类型转换前，最好使用 instanceof 关键字检查对象的实际类型，以避免异常。

  • 示例

    if (animal instanceof Dog) {
    Dog dog2 = (Dog) animal;
}

3. 类型转换的注意事项

  1. 类型兼容性：

    • 只有存在继承关系的类之间才能进行类型转换。

    • 例如，Integer 和 String 之间没有继承关系，不能互相转换。

4、instanceof 关键字：

如果对象是指定的类或接口的示例对象，则返回true,否则返回false  

用于检查一个对象是否是某个类的实例。

示例

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
}
    // 定义 Animal 类
class Animal {
    public void shout() {
        System.out.println("动物叫……");
    }
}

// 定义 Dog 类
class Dog extends Animal {
    // 重写 shout() 方法
    public void shout() {
        System.out.println("汪汪……");
    }

    public void eat() {
        System.out.println("吃骨头……");
    }
}

// 定义测试类
public class Example17 {
    public static void main(String[] args) {
        Animal a1 = new Dog(); // 通过向上转型实例化 Animal 对象
        System.out.println("Animal a1 = new Dog() : " + (a1 instanceof Animal));
        System.out.println("Animal a1 = new Dog() : " + (a1 instanceof Dog));
        
        Animal a2 = new Animal(); // 实例化 Animal 对象
        System.out.println("Animal a2 = new Animal() : " + (a2 instanceof Animal));
        System.out.println("Animal a2 = new Animal() : " + (a2 instanceof Dog));
    }
}

    输出 

    总结

    Java 中的对象类型转换主要包括向上转型和向下转型：

    • 向上转型：安全，自动完成，用于多态。

    • 向下转型：需要显式转换，必须确保对象的实际类型是目标类型，否则会抛出异常。

    在实际开发中，合理使用类型转换可以提高代码的灵活性和可维护性，但需要注意类型兼容性和安全性问题。

     三、Object类

    示例代码

    // 定义 Animal 类
class Animal {
    // 定义动物叫的方法
    void shout() {
        System.out.println("动物叫！");
    }
}

// 定义测试类
public class Example18 {
    public static void main(String[] args) {
        Animal animal = new Animal(); // 创建 Animal 类对象
        System.out.println(animal.toString()); // 调用 toString() 方法并打印
    }
}

     一般情况下不会直接调用Object类中的方法，因为Object类中的方法并不适用于所有的子类，这时就需要对Object类中的方法进行重写，以满足实际开发需求。

    例如：重写toString()方法

    // 定义 Animal 类
class Animal {
    // 重写 Object 类的 toString() 方法
    public String toString() {
        return "这是一个动物。";
    }
}

// 定义测试类
public class Example19 {
    public static void main(String[] args) {
        Animal animal = new Animal(); // 创建 animal 对象
        System.out.println(animal.toString()); // 调用 toString() 方法并打印
    }
}

     

     四、内部类

    Java 内部类（Inner Class）是一种特殊的类定义方式，它允许在一个类的内部定义另一个类。

    内部类可以分为以下几种类型：

    • 成员内部类：定义在类的内部，但不在任何方法中。

    • 局部内部类：定义在方法或代码块中。

    • 匿名内部类：没有类名的内部类，通常用于实现接口或继承类。

    • 静态内部类：使用 static 关键字修饰的内部类。

     

     内部类的作用

    (1) 逻辑分组

    内部类可以将相关的类组织在一起，增强代码的逻辑性和可读性。例如，一个类的主要功能可以通过外部类实现，而辅助功能可以通过内部类实现。

    (2) 访问控制

    内部类可以访问外部类的成员变量和方法（包括私有成员）。这使得内部类能够更好地与外部类交互，实现更紧密的耦合。

    (3) 实现回调

    内部类常用于实现回调机制。例如，在 GUI 编程中，内部类可以用来处理事件（如按钮点击事件）。

    (4) 多继承的替代

    Java 不支持多重继承，但通过内部类可以实现类似的效果。内部类可以继承一个类，同时外部类可以继承另一个类。

    (5) 代码复用

    内部类可以被外部类的多个实例共享，从而提高代码的复用性。

    (6) 简化代码

    内部类可以简化某些复杂的代码结构，尤其是在需要实现接口或继承类时。

    4-1、成员内部类 

    代码示例 

    class Outer {
    int m = 0; // 定义类的成员变量

    // 外部类方法 test1()
    void test1() {
        System.out.println("外部类成员方法 test1()");
    }

    // 下面的代码定义了成员内部类 Inner
    class Inner {
        int n = 1;

        void show1() {
            // 在成员内部类的方法中访问外部类的成员变量 m
            System.out.println("外部类成员变量 m = " + m);
            // 在成员内部类的方法中访问外部类的成员方法 test1()
            test1();
        }

        void show2() {
            System.out.println("内部类成员方法 show2()");
        }
    }

    // 外部类方法 test2()
    void test2() {
        Inner inner = new Inner(); // 实例化内部类对象 inner
        System.out.println("内部类成员变量 n = " + inner.n); // 访问内部类变量和方法
        inner.show2();
    }
}

public class Example20 {
    public static void main(String[] args) {
        Outer outer = new Outer(); // 实例化外部类对象 outer
        Outer.Inner inner = outer.new Inner(); // 实例化内部类对象 inner
        inner.show1(); // 在内部类中访问外部类的成员变量 m 和成员方法 test1()
        outer.test2(); // 在内部类中访问内部类的成员变量 n 和成员方法 show2()
    }
}

    输出

    4-2、局部内部类

    class Outer {
    int m = 0; // 定义类的成员变量

    // 定义一个成员方法 test1()
    void test1() {
        System.out.println("外部类成员方法 test1()");
    }

    void test2() {
        // 定义一个局部内部类，在局部内部类中访问外部类变量和方法
        class Inner {
            int n = 1;

            void show() {
                System.out.println("外部类成员变量 m = " + m);
                test1();
            }
        }

        // 访问局部内部类中的变量和方法
        Inner inner = new Inner();
        System.out.println("局部内部类变量 n = " + inner.n);
        inner.show();
    }
}

public class Example21 {
    public static void main(String[] args) {
        Outer outer = new Outer(); // 实例化外部类对象 outer
        outer.test2(); // 通过外部类对象 outer 调用创建了局部内部类的方法 test2()
    }
}

    输出

     4-3、静态内部类

    class Outer {
    static int m = 0; // 定义类的静态变量

    // 下面的代码定义了一个静态内部类
    static class Inner {
        int n = 1;

        void show() {
            // 在静态内部类的方法中访问外部类的静态变量 m
            System.out.println("外部类静态变量 m = " + m);
        }
    }
}

public class Example22 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner(); // 创建静态内部类的对象
        inner.show(); // 调用静态内部类的方法
    }
}

    输出

    4-4、匿名内部类 

    interface Animal { // 定义接口 Animal
    void shout(); // 定义抽象方法 shout()
}

public class Example23 {
    public static void main(String[] args) {
        String name = "小花";
        animalShout(new Animal() { // 调用 animalShout() 方法，参数为匿名内部类
            @Override // 重写接口中的方法
            public void shout() {
                System.out.println(name + "喵喵……");
            }
        });
    }

    public static void animalShout(Animal an) { // 该方法参数为 Animal 接口类型
        an.shout();
    }
}

     

    本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2335434.html

    如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

    相关文章

    NI的LABVIEW工具安装及卸载步骤说明

    NI的LABVIEW工具安装及卸载步骤说明

    一.介绍 最近接到个转交的项目，项目主要作为上位机工具开发，在对接下位机时，有用到NI的labview工具。labview软件是由美国国家仪器（NI）公司研制开发的一种程序开发环境，主要用于汽车测试、数据采集、芯片测…
    阅读更多...
    [reinforcement learning] 是什么 | 应用场景 | Andrew Barto and Richard Sutton

    [reinforcement learning] 是什么 | 应用场景 | Andrew Barto and Richard Sutton

    目录 什么是强化学习？ 强化学习的应用场景 广告和推荐 对话系统 强化学习的主流算法 纽约时报：Turing Award Goes to 2 Pioneers of Artificial Intelligence wiki 资料混合：youtube, wiki, github 今天下午上课刷到了不少&#xff0…
    阅读更多...
    [从零开始学数据库] 基本SQL

    [从零开始学数据库] 基本SQL

    注意我们的主机就是我们的Mysql数据库服务器 这里我们可以用多个库 SQL分类(核心是字段的CRUD)![](https://i-blog.csdnimg.cn/img_convert/0432d8db050082a49258ba8a606056c7.png) ![](https://i-blog.csdnimg.cn/img_convert/bdf5421c2b83e22beca12da8ca89b654.png) 重点是我…
    阅读更多...
    git 提交标签

    git 提交标签

    Git 提交标签 提交消息格式&#xff1a; <type>: <description> &#xff08;示例&#xff1a;git commit -m "feat: add user login API"&#xff09; 标签适用场景feat新增功能&#xff08;Feature&#xff09;。fix修复 Bug&#xff08;Bug fix&…
    阅读更多...
    关于 Spring Batch 的详细解析及其同类框架的对比分析，以及如何自己设计一个java批处理框架（类似spring batch）的步骤

    关于 Spring Batch 的详细解析及其同类框架的对比分析，以及如何自己设计一个java批处理框架（类似spring batch）的步骤

    以下是关于 Spring Batch 的详细解析及其同类框架的对比分析&#xff1a; 一、Spring Batch 核心详解 1. 核心概念 作业&#xff08;Job&#xff09;&#xff1a;批处理任务的顶层容器&#xff0c;由多个步骤&#xff08;Step&#xff09;组成。 步骤&#xff08;Step&#…
    阅读更多...
    【第十三届“泰迪杯”数据挖掘挑战赛】【2025泰迪杯】【论文篇+改进】A题解题全流程（持续更新）

    【第十三届“泰迪杯”数据挖掘挑战赛】【2025泰迪杯】【论文篇+改进】A题解题全流程（持续更新）

    【第十三届“泰迪杯”数据挖掘挑战赛】【2025泰迪杯】【论文篇改进】A题解题全流程&#xff08;持续更新&#xff09; 写在前面&#xff1a; 我是一个人&#xff0c;没有团队&#xff0c;所以出的比较慢&#xff0c;每年只做一次赛题&#xff0c;泰迪杯&#xff0c;我会认真对…
    阅读更多...
    数据结构——哈希详解

    数据结构——哈希详解

    数据结构——哈希详解 目录 一、哈希的定义 二、六种哈希函数的构造方法 2.1 除留取余法 2.2 平方取中法 2.3 随机数法 2.4 折叠法 2.5 数字分析法 2.6 直接定值法 三、四种解决哈希冲突的方法 3.1 开放地址法 3.1.1 线性探测法 3.1.2 二次探测法 3.2 链地址法 3…
    阅读更多...
    Spark-SQL核心编程

    Spark-SQL核心编程

    简介 Hadoop与Spark-SQL的对比 Hadoop在处理结构化数据方面存在局限性&#xff0c;无法有效处理某些类型的数据。 Spark应运而生&#xff0c;特别设计了处理结构化数据的模块&#xff0c;称为Spark SQL&#xff08;原称Shark&#xff09;。 SparkSQL的发展历程&#xff1a; Sp…
    阅读更多...
    Docker 与 Podman常用知识汇总

    Docker 与 Podman常用知识汇总

    一、常用命令的对比汇总 1、基础说明 Docker&#xff1a;传统的容器引擎&#xff0c;使用 dockerd 守护进程。 Podman&#xff1a;无守护进程、无root容器引擎&#xff0c;兼容 Docker CLI。 Podman 命令几乎完全兼容 Docker 命令&#xff0c;只需将 docker 替换为 podman。…
    阅读更多...
    Large Language Model（LLM）的训练和微调

    Large Language Model（LLM）的训练和微调

    之前一个偏工程向的论文中了&#xff0c;但是当时对工程理论其实不算很了解&#xff0c;就来了解一下 工程流程 横轴叫智能追寻 竖轴上下文优化 Prompt不行的情况下加shot(提示)&#xff0c;如果每次都要加提示&#xff0c;就可以试试知识库增强检索来给提示。 如果希望增强…
    阅读更多...
    统计销量前十的订单

    统计销量前十的订单

    传入参数&#xff1a; 传入begin和end两个时间 返回参数 返回nameList和numberList两个String类型的列表 controller层 GetMapping("/top10")public Result<SalesTop10ReportVO> top10(DateTimeFormat(pattern "yyyy-MM-dd") LocalDate begin,Dat…
    阅读更多...
    AI大模型原理可视化工具：深入浅出理解大语言模型的工作原理

    AI大模型原理可视化工具：深入浅出理解大语言模型的工作原理

    AI大模型原理可视化工具&#xff1a;深入浅出理解大语言模型的工作原理 在人工智能快速发展的今天&#xff0c;大语言模型&#xff08;如GPT、BERT等&#xff09;已经成为改变世界的重要技术。但对于很多人来说&#xff0c;理解这些模型的工作原理仍然是一个挑战。为了帮助更多…
    阅读更多...
    qt designer 创建窗体选择哪种屏幕大小

    qt designer 创建窗体选择哪种屏幕大小

    1. 新建窗体时选择QVGA还是VGA 下面这个图展示了区别 这里我还是选择默认&#xff0c;因为没有特殊需求&#xff0c;只是在PC端使用
    阅读更多...
    Spark-SQL核心编程（一）

    Spark-SQL核心编程（一）

    一、Spark-SQL 基础概念 1.定义与起源&#xff1a;Spark SQL 是 Spark 用于结构化数据处理的模块&#xff0c;前身是 Shark。Shark 基于 Hive 开发&#xff0c;提升了 SQL-on-Hadoop 的性能&#xff0c;但因对 Hive 依赖过多限制了 Spark 发展&#xff0c;后被 SparkSQL 取代&…
    阅读更多...
    AI与无人驾驶汽车：如何通过机器学习提升自动驾驶系统的安全性？

    AI与无人驾驶汽车：如何通过机器学习提升自动驾驶系统的安全性？

    引言 想象一下&#xff0c;在高速公路上&#xff0c;一辆无人驾驶汽车正平稳行驶。突然&#xff0c;前方的车辆紧急刹车&#xff0c;而旁边车道有一辆摩托车正快速接近。在这千钧一发的瞬间&#xff0c;自动驾驶系统迅速分析路况&#xff0c;判断最安全的避险方案&#xff0c;精…
    阅读更多...
    第5篇：Linux程序访问控制FPGA端LEDR＜三＞

    第5篇：Linux程序访问控制FPGA端LEDR＜三＞

    Q&#xff1a;如何具体设计.c程序代码访问控制FPGA端外设&#xff1f; A&#xff1a;以控制DE1-SoC开发板的LEDR为例的Linux .C程序代码。头文件fcntl.h和sys/mman.h用于使用/dev/mem文件&#xff0c;以及mmap和munmap内核函数&#xff1b;address_map_arm.h指定了DE1-SoC_Com…
    阅读更多...
    城市应急安防系统EasyCVR视频融合平台：如何实现多源视频资源高效汇聚与应急指挥协同

    城市应急安防系统EasyCVR视频融合平台：如何实现多源视频资源高效汇聚与应急指挥协同

    一、方案背景 1&#xff09;项目背景 在当今数字化时代&#xff0c;随着信息技术的飞速发展&#xff0c;视频监控和应急指挥系统在公共安全、城市应急等领域的重要性日益凸显。尤其是在关键场所&#xff0c;高效的视频资源整合与传输能力对于应对突发公共事件、实现快速精准的…
    阅读更多...
    【笔记ing】AI大模型-03深度学习基础理论

    【笔记ing】AI大模型-03深度学习基础理论

    神经网络&#xff1a;A neural network is a network or circuit of neurons,or in a modern sense,an artificial neural network,composed of artificial neurons or nodes.神经网络是神经元的网络或回路&#xff0c;或者在现在意义上来说&#xff0c;是一个由人工神经元或节…
    阅读更多...
    07软件测试需求分析案例-修改用户信息

    07软件测试需求分析案例-修改用户信息

    修改用户信息是后台管理菜单的一个功能模块&#xff0c;只有admin才有修改权限。包括查询用户名进行显示用户相关信息&#xff0c;并且修改用户相关信息的功能。 1.1 通读文档 通读需求规格说明书是提取信息&#xff0c;提出问题&#xff0c;输出具有逻辑、规则、流程的业务…
    阅读更多...
    设计模式 --- 状态模式

    设计模式 --- 状态模式

    状态模式​​是一种​​行为型设计模式​​&#xff0c;允许对象在内部状态改变时动态改变其行为​​&#xff0c;使对象的行为看起来像是改变了。该模式通过将状态逻辑拆分为独立类​​&#xff0c;消除复杂的条件分支语句&#xff0c;提升代码的可维护性和扩展性。 状态模式的…
    阅读更多...
    推荐文章
    最新文章

    Copyright @ 2022~2023