【C#】类

目录

一、类定义

二、属性

三、事件

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属性。

三、事件

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方法，从而实现自己特有的行为，而不影响到其他子类。另外，多态也提高了代码的可重用性，因为它可以让我们用一个父类引用来引用不同的子类对象，从而实现了代码的更好复用。