【C#】类

缺乏、安全感 2024-04-17 15:02 56阅读 0赞

**目录**

一、类定义

二、属性

三、事件

1、定义

2、添加事件

3、自定义类和窗体之间通过自定义事件的相互作用

四、ClassBuider的使用

1、定义

2、示例代码

五、继承

1、定义

2、代码示例

六、多态的作用

1、定义

2、重载代码示例

3、重写代码示例

--------------------

## 一、类定义 ##

类定义（class definition）是一种编程语言的结构，用于定义一个新的类。类是一种创建对象的模板，它包含了属性（数据）和方法（函数），可以用来描述一组具有共同特征和行为的对象。

> 类定义通常包含以下部分：

1. 类名: 用于标识这个类，通常第一个字母大写，采用驼峰命名法。

2. 属性: 类的成员变量（数据），用于存储对象的状态。

3. 方法: 类的成员函数，用于实现类的行为。

4. 构造函数: 用于创建类的对象，并初始化其属性。

5. 析构函数: 在对象被销毁时调用，用于清理对象占用的资源。

类定义可以根据语言的不同而略有区别，但它们都具有相同的目的：定义一个新的类。在面向对象编程中，类是非常重要的概念，它们允许开发人员封装数据和方法，从而提高代码的安全性、可维护性和可扩展性。

> 1、类是群体，属于抽象概念；对象是个体，属于实体概念。
> 
> 2、类的组成：方法、数据、事件
> 
> 成员的访问权限（public\\private\\friend）
> 
> 3、对象的创建和使用
> 
> dim objname as classname
> 
> set objname = new classname
> 
> dim objname = new classname

## 二、属性 ##

属性定义是类定义中的一部分，用于定义类的成员变量或数据。属性表示类的状态，用于存储对象的数据。

> 属性定义通常包括以下部分：

1. 访问修饰符：public、private、protected等，用于控制属性的访问权限。

2. 数据类型：属性的数据类型，可以是基本类型（如int、float、double等）或自定义类类型。

3. 属性名称：属性的名称，用于标识该属性。

> 例如，下面是一个Java类中定义一个名为name的私有属性的示例：

public class Person {
        private String name; //私有属性，类型为String，名称为name
        
        //构造函数、方法等在这里省略
    }

在上面的示例中，访问修饰符为private，表示该属性只能在类的内部访问，不能被外部访问。数据类型是String，表示该属性的类型为字符串。属性名称为name，表示该属性用于存储对象的姓名信息。

需要注意的是，属性定义中只是描述了一个属性的类型、名称和访问权限，实际的属性值需要在对象创建后才能赋值。在Java中，可以通过构造函数或方法来初始化属性的值。

> 例如，在Person类中可以定义以下构造函数来初始化name属性：

public Person(String name) {
        this.name = name;
    }

在构造函数中，使用this关键字来引用当前对象，然后将传递进来的name参数赋值给对象的name属性。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ5MDAyMw_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ5MDAyMw_size_16_color_FFFFFF_t_70 1][]

## 三、事件 ##

### 1、定义 ###

> 事件定义是指在一个程序或系统中，通过用户交互、消息传递等方式引起的某些状态或行为的触发和处理。事件可以是用户输入的操作，也可以是系统发生的一些状态变化。事件通常包括以下几个部分：

1. 事件源：触发事件的对象，可以是用户界面组件、设备驱动程序或其他系统组件。

2. 事件类型：定义事件的类型，例如鼠标点击、键盘按下、网络连接断开等。

3. 事件处理程序：在事件发生时要执行的代码，用于响应事件和处理相应的逻辑。

> 事件定义通常需要在程序中进行注册和绑定，以确保事件可以正确地被监听和处理。在各种编程语言和框架中，事件定义和处理的方式可能有所不同。例如，在Java中，可以使用Java事件模型来定义和处理事件，具体步骤如下：

1. 定义事件监听器：实现事件监听器接口，定义响应事件的方法。

2. 注册事件监听器：将事件监听器注册到事件源中，以便在事件发生时能够正确地响应事件。

3. 触发事件：当事件源上发生事件时，通过相应的方法触发事件，从而让事件监听器开始处理事件。

> 示例代码如下：

// 定义事件监听器接口
    interface MyEventListener {
        void handleEvent(MyEvent event);
    }
    
    // 定义事件类
    class MyEvent {
        private String eventType;
    
        public MyEvent(String eventType) {
            this.eventType = eventType;
        }
    
        public String getEventType() {
            return eventType;
        }
    }
    
    // 定义事件源
    class MyEventSource {
        private MyEventListener listener;
    
        public void setListener(MyEventListener listener) {
            this.listener = listener;
        }
    
        public void fireEvent(MyEvent event) {
            if (listener != null) {
                listener.handleEvent(event);
            }
        }
    }
    
    // 使用事件
    public class Main {
        public static void main(String[] args) {
            // 创建事件源和事件监听器
            MyEventSource source = new MyEventSource();
            MyEventListener listener = new MyEventListener() {
                @Override
                public void handleEvent(MyEvent event) {
                    System.out.println("Event received: " + event.getEventType());
                }
            };
    
            // 注册事件监听器
            source.setListener(listener);
    
            // 触发事件
            MyEvent event = new MyEvent("click");
            source.fireEvent(event);
        }
    }

在上面的例子中，我们定义了一个MyEventSource类作为事件源，通过setListener()方法将事件监听器注册到事件源中，然后通过fireEvent()方法触发事件。当事件发生时，监听器会自动调用handleEvent()方法来处理事件，输出相应的日志。

### 2、添加事件 ###

定义事件：Public Event MyEventName

产生事件消息：RaiseEvent MyEventname

给用户窗体（Form1）添加属性、方法、事件

### 3、自定义类和窗体之间通过自定义事件的相互作用 ###

自定义类产生事件，窗体接受

窗体产生自定义事件，类模块接受

声明事件源变量：【Public|Private】WithEvents

## 四、ClassBuider的使用 ##

### 1、定义 ###

ClassBuilder是一种Java字节码操作工具，可以在运行时动态地创建新的类并操作其成员，包括字段、方法、构造函数等。使用ClassBuilder可以实现动态生成Java类的需求，例如根据数据库表结构动态生成实体类、根据XML配置文件动态生成操作类等。

> ClassBuilder提供了一系列方法来创建和操作类，常用的方法包括：

**1. setName(String name)：设置类名；**

**2. setSuperclass(Class<?> superclass)：设置父类；**

**3. addField(String name, Class<?> type, int modifiers)：添加字段；**

**4. addMethod(String name, Class<?> returnType, int modifiers)：添加方法；**

**5. addConstructor(int modifiers, Class<?>... parameterTypes)：添加构造函数；**

**6. toClass()：生成Java类并返回Class对象。**

### 2、示例代码 ###

import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    import org.objectweb.asm.ClassWriter;
    import org.objectweb.asm.Opcodes;
    
    public class ClassBuilderDemo {
        public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
            // 创建ClassWriter对象，用于生成类的字节码
            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
    
            // 创建类
            cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "com/example/MyClass", null, "java/lang/Object", null);
    
            // 添加字段
            cw.visitField(Opcodes.ACC_PUBLIC, "name", "Ljava/lang/String;", null, null).visitEnd();
    
            // 添加方法
            Method println = System.out.getClass().getDeclaredMethod("println", String.class);
            cw.visitMethod(Opcodes.ACC_PUBLIC, "sayHello", "()V", null, null)
                .visitCode()
                .visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;")
                .visitLdcInsn("Hello, world!")
                .visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false)
                .visitInsn(Opcodes.RETURN)
                .visitMaxs(2, 1)
                .visitEnd();
    
            // 生成字节码并返回Class对象
            byte[] code = cw.toByteArray();
            Class<?> generatedClass = new GeneratedClassLoader().defineClass("com.example.MyClass", code);
    
            // 使用动态生成的类
            Object obj = generatedClass.newInstance();
            Method method = generatedClass.getDeclaredMethod("sayHello");
            method.invoke(obj);
        }
    
        // 自定义ClassLoader，用于加载动态生成的类
        static class GeneratedClassLoader extends ClassLoader {
            public Class<?> defineClass(String name, byte[] code) {
                return defineClass(name, code, 0, code.length);
            }
        }
    }

> 在上面的例子中，我们使用ClassWriter创建了一个名为com.example.MyClass的类，添加了一个名为name的字段和一个名为sayHello的方法，在sayHello方法中调用System.out.println输出"Hello, world!"。最后，将生成的字节码通过自定义ClassLoader加载为Class对象，并通过反射调用动态生成类的方法。

> 需要注意的是，ClassBuilder是一个底层的字节码操作工具，使用时需要熟悉Java字节码的工作原理和相关的操作。同时，ClassBuilder生成的类在Java虚拟机中的性能与手写的类相比可能有所差异，在使用时需要注意评估性能影响。

## 五、继承 ##

### 1、定义 ###

继承是面向对象编程中的一种核心概念，它指的是通过一个已有的类来创建一个新类，新类继承了原有类的属性和方法。原有类称为父类或超类，新类称为子类或派生类。

### 2、代码示例 ###

Java中继承的定义使用extends关键字，子类通过extends关键字声明继承父类，例如：

public class Animal {
        public void eat() {
            System.out.println("I am eating.");
        }
    }
    
    public class Dog extends Animal {
        public void bark() {
            System.out.println("Woof!");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.eat(); // 调用父类的方法
            dog.bark(); // 调用子类自己的方法
        }
    }

> 在上面的例子中，Dog类继承自Animal类，因此它也拥有Animal类中的方法，同时它还新增了一个自己的bark方法。在Main类中，我们创建了一个Dog对象，并调用了它的eat和bark方法。

> 需要注意的是，子类不能访问父类中的private属性和方法，因为private修饰的属性和方法只能在当前类中访问。如果父类中的属性或方法需要被子类访问，则需要使用protected修饰。

另外，Java中类只能单继承，也就是说一个类只能有一个直接父类。但是Java中支持多层继承，也就是说可以有一个类继承另一个类，而后者又继承另一个类，以此类推。例如：

class Grandparent {
        // 父类中的属性和方法
    }
    
    class Parent extends Grandparent {
        // 子类中的属性和方法
    }
    
    class Child extends Parent {
        // 孙子类中的属性和方法
    }

在这个例子中，Child类继承了Parent类的属性和方法，Parent类又继承了Grandparent类的属性和方法，因此Child类间接继承了Grandparent类的属性和方法。

## 六、多态的作用 ##

### 1、定义 ###

多态是面向对象编程中的一个重要概念，它指的是同一种类型的对象，在不同情况下表现出不同的行为，即具有多种形态。多态的作用在于它可以提高代码的可扩展性、可维护性和可重用性，从而提高了代码的可靠性和效率。

**多态的实现方式主要有两种：重载和重写。**

### 2、重载代码示例 ###

重载是指在同一个类中，通过改变方法的参数列表来实现多态。例如：

public class Calculator {
        public int add(int a, int b) {
            return a + b;
        }
        
        public int add(int a, int b, int c) {
            return a + b + c;
        }
    }

在这个例子中，Calculator类中的add方法被重载了，它既可以接收两个参数，也可以接收三个参数，从而实现了多态。

### 3、重写代码示例 ###

重写是指子类覆盖父类中的方法来实现多态。例如：

class Animal {
        public void eat() {
            System.out.println("I am eating.");
        }
    }
    
    class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("I am eating bones.");
        }
    }

在这个例子中，Dog类继承了Animal类中的eat方法，并在自己的eat方法中覆盖了父类的实现，从而实现了多态。

> 多态的作用在于它提高了代码的可扩展性和可维护性。如果我们新增一个Animal的子类，它也可以覆盖父类的eat方法，从而实现自己特有的行为，而不影响到其他子类。另外，多态也提高了代码的可重用性，因为它可以让我们用一个父类引用来引用不同的子类对象，从而实现了代码的更好复用。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ5MDAyMw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/93c23a6c04bd4273bb757f0298f5fdb5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQ5MDAyMw_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/23258059fbdb4a0587027fe29760bcf1.png