C#类

最新推荐文章于 2024-04-17 12:29:09 发布
最新推荐文章于 2024-04-17 12:29:09 发布
阅读量337 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JunChow520/article/details/103030754
版权
4933701-3af87747dc78c02a.png
类

结构与枚举

using System;

namespace Test
{
    //结构
    struct User
    {
        public int age;
        public string name;
        public string firstname;
        public string lastname;
    }
    //枚举 限定变量的可能性
    enum Weekday
    {
        Monday=1, 
        Thuesday =2,
        Wenesday=3,
        Thursday=4,
        Friday=5,
        Saturday=6,
        Sunday=7
    }
    class Program
    {     
        static void Main(string[] args)
        {
            //使用结构体
            User user = new User();
            user.age = 20;
            Console.WriteLine($"user age is {user.age}");//user age is 20

            //使用枚举
            Console.WriteLine(Weekday.Monday);//Monday
            Console.WriteLine((int)Weekday.Monday);//1

            Console.ReadKey();
        }    
    }
}

什么是类

  • 类是一种抽象的数据结构(data structure)
  • 类是一种数据类型
  • 类代表现实世界中的种类

类是一种活动的数据结构

类是一个能存储数据并执行代码的数据结构，包含数据成员和函数成员。数据成员，存储与类或类的实例相关的数据，数据成员通常模拟该类所表示的现实世界事物的特性。函数成员，执行代码，通常会模拟类所表示的现实世界事物的功能和操作。

类是一种数据结构，包含数据成员（常量和字段）、函数成员（方法、属性、事件、索引器、运算符、实例构造函数、静态构造函数、析构函数）、嵌套类型。类类型支持继承，继承是一种机制，使派生类可对基类进行扩展和专用化。

类是逻辑相关的数据和函数的封装，通常代表真实世界中或概念上的事物。

类成员

数据成员

  • 常量

常量与类相关，尽管没有static修饰符，编译器使用真实值代替常量。

常量与类的关联方式与变量与类的关联方式相同，使用const关键字来声明常量。如果将其声明为public则在类的外部可访问它。

class User
{
    //常量
    public const string Root = "Admin";
    //字段
    public int UserID;
    public string UserName;
}
  • 字段

字段是类的数据成员，是类型的一个变量，该类型是类的一个成员，也就是说字段是与类相关的变量。

  1. 字段可以是任何类型，无论是预定义类型还是用户自定义类型。
  2. 字段和变量一样，用来保存数据，并具有可被写入和可被读取的特征。
4933701-1d18fde8fb7e8632.png
字段

最好不要将字段声明为public，如果修改类的公共成员，使用公共成员的每个调用程序也需要更改。最好是将字段声明为private，使用属性来访问字段。

与C和C++不同的是，C#在类型的外部不能声明全局变量。所有的字段都属于类型，而且必须在类型声明内部声明。

字段初始化

因为字段是一种变量，所以字段初始化和变量初始化相同。

  1. 字段初始化语句是字段声明的一部分，由等号和求值表达式组成。
  2. 初始化值必须是编译时可确定的
  3. 若没有初始化语句，字段的值会被编译器设置为默认值，默认值由字段的类型决定。

函数成员

  • 属性

属性(property)是一个方法或一对方法，在客户端代码看来，它是一个字段。

class User
{
    //常量
    public const string Root = "Admin";
    //字段
    public int UserID;
    public string UserName;
    //属性
    private string _password;
    public string Password
    {
        get { return _password; }
        set { _password = value; }
    }
}

属性是可以从客户端访问的函数组，其访问方式与访问类的公共字段类似。C#为读写类中的属性提供了专用语法，所以不必使用名称中嵌入Get或Set的方法。因为属性的这种语法不同于一般函数的语法。在客户端代码中，虚拟的对象被当作实际的东西。

get访问器不带任何参数且必须返回属性声明的类型，也不应该为set访问器指定任何显式参数，但编译器假定它带有一个参数，其类型也与属性相同，并表示为value。

class User
{
    //属性
    private DateTime createTime;
    public DateTime CreatedTime
    {
        get
        {
            return createTime;
        }
        set
        {
            createTime = value;
        }
    }
}

命名约定

采用C#区分大小写模式，使用相同的名称，公有属性采用Pascal大小写形式命名。若存在一个等价的私有字段，则采用Camel大小写形式命名。在使用私有成员时，.NET Core团队使用下划线作为字段的前缀，.NET没有严格的命名约定。

自动实现的属性

若属性的set和get访问器中没有任何逻辑，就可以使用自动实现的属性。该属性会自动实现后备成员变量。

public int UserID { get; set; }

此时无需声明私有字段，编译器会自动创建它。使用自动实现的属性，就不能直接访问字段，因为不知道编译器生成的名称。

使用自动实现的属性，就不能在属性设置中验证属性的有效性。

自动实现的属性可以使用属性初始化其来初始化

public DateTime CreateTime { get; set; } = DateTime.Now

属性的访问修饰符

C# 允许给属性的get和set访问器设置不同的访问修饰符，属性可以有公有的get访问器和私有或受保护的set访问器。这有助于控制属性的设置方式或时间。

private string _username;
public string UserName
{
  // 公有的get访问器
  get
  {
    return _username;
  }
  // 私有或受保护的set访问器
  private set
  {
    _name = value;
  }
}

在get和set访问器中，必须有一个具备属性的访问级别。如果get访问器的访问级别是protected，会产生一个编译错误，因为会使两个访问器的访问级别都不是属性。

通过自动实现的属性，可以设置不同的访问级别。

public int UserID { get; private set; }
  • 方法
    方法是与特定类相关联的函数
  • 事件
    事件是类的成员，在发生某些行为时，如修改类的字段或属性，或进行某种形式的用户交互操作时，可以让对象通知调用方。客户可包含所谓“事件处理程序”的代码来响应事件。
  • 索引器
    索引器允许对象使用访问数组的方式访问
  • 运算符
    运算符执行的最简单的操作就是加法和减法，两个整数相加时，严格来说是对整数使用“+”运算符。C#允许指定把已有的运算符应用于自己的类（运算符重载）。
  • 构造函数
    构造函数是在实例化对象时自动调用的特殊函数，必须与所属类同名，且不能有返回值。构造函数用于初始化字段的值。
  • 析构函数
    析构函数或终结器的语法类似于构造函数的语法，在CLR检测到不再需要某个对象时调用，其名称与类相同，但前面有一个~符号。不可能预测什么时候调用终结器。

嵌套类型

类可以包含内部类，如果内部类只和外部类型结合使用则很有趣。

using System;

namespace Test
{
    class User
    {
        public int ID { get; set; }
        public string UserName { get; set; }
        public void Report()
        {
            Console.WriteLine($"I am user #{ID}, my name is {UserName}.");
        }
        //实例构造器
        public User(int id, string username)
        {
            this.ID = id;
            this.UserName = username;
            Amount++;
        }
        //实例析构器 托管语言
        ~User()
        {
            Amount--;
            Console.WriteLine("Release the system resource...");
        }
        //静态成员
        public static int Amount { get; set; }
        //静态构造器 只能构造静态成员
        static User()
        {
            Amount = 100;
        }
    }
    class Program
    {     
        static void Main(string[] args)
        {
            //声明类并创建类的实例，使用默认构造器
            //User user = new User() {
            //    ID = 1,
            //    UserName = "JunChow"
            //};
            //user.Report();

            //使用实例构造器实例化对象
            //User user = new User(100, "junchow");
            //user.Report();

            //使用反射创建类
            //Type t = typeof(User);
            //object obj = Activator.CreateInstance(t, 200, "alice");//创建实例
            //Console.WriteLine(obj.GetType().Name);//User
            //Console.WriteLine(obj is User);//True

            //User user = obj as User;
            //user.Report();

            //动态类型
            //Type t = typeof(User);
            //dynamic u = Activator.CreateInstance(t, 300, "alibaba");
            //u.Report();

            //调用静态
            Console.WriteLine(User.Amount);

            User u1 = new User(1000, "Jacky");
            User u2 = new User(2000, "Tim");
            Console.WriteLine(User.Amount);

            Console.ReadKey();
        }    
    }
}

类包含成员，成员可以是静态或实例。静态成员属于类，实例成员属于对象。静态字段的值对每个对象都是相同的。而每个对象的实例字段都可以有不同的值。静态成员关联了static修饰符。

类的声明与访问级别

  • 类声明的全貌 声明既定义（C#与Java）
  • 简单的类声明 类的访问控制
  • 类成员的访问控制
  • 类的继承
    • 派生类对基类的成员获得与访问
    • 在派生类中访问基类的成员
    • 构造器的不可继承性

类声明的位置

  • 声明在命名空间中
  • 声明在命名空间外，实际上在全局命名空间Global下。
  • 声明在类体中作为成员类
using System;

namespace Test
{
    /*在命名空间中声明类*/
    class User
    {

    }
    class Program
    {     
        static void Main(string[] args)
        {
            Console.ReadKey();
        }   
        /*成员类：在类中声明类*/
        class Inner
        {

        }
    }
}
namespace NS
{
    class Member
    {

    }
}
/*在类声明在所有命名空间在外，实际上它声明在全局名称空间Global下。*/
class Klass
{
}

声明declare与定义define

C++中类的声明和定义是分开的

4933701-2b2aca114e8eab73.png
C++类的声明与定义 
$ vim User.h
class User
{
public:
    User();
    ~User();
    void Print();
};

$ vim User.cpp
#include "pch.h"
#include "User.h"
#include "iostream"

User::User()
{
}

User::~User()
{
}

void User::Print() {
    std::cout << "Hello" << std::endl;
}

$ vim ConsoleApp.cpp
#include "pch.h"
#include <iostream>
#include "User.h"

int main()
{
    User *user = new User();
    user->Print();

    //std::cout << "Hello World!\n"; 
    return 0;
}

Java和C#中类的声明与定义放在一起

类声明

类的声明定义了新类的特征和成员，类声明并不创建类的实例，但创建了用于创建实例的模板。

类的声明提供以下内容：类的名称、类的成员、类的特征

4933701-a950c14f6beffc01.png
类的声明
4933701-4d0eb1bcb782b05c.png
类的声明

类修饰符

class-declaration 可以根据需要包含一个类修饰符序列，同一修饰符在一个类声明中多次出现是编译时错误。

4933701-eaa7304c8e161715.png
类修饰符

new修饰符适用于嵌套类，指定类隐藏同名的继承成员。如果在不是嵌套类声明的类声明中使用new修饰符，则会导致编译时错误。

访问修饰符（access modifier）

访问修饰符标识了所修饰成员的封装级别，可选择5个访问修饰符，即public、protected、internal、private、protected internal修饰符将控制类的可访问性，根据类声明所处的上下文，可访问性修饰符可能不允许使用。

封装：信息隐藏

除了组合数据和方法，封装的另一个重要作用是隐藏对象的数据和行为的内部细节。方法在某种程序上也能做到这一点，在方法外部，调用者看到的只是方法声明，内部实现不可见。面向对象编程更进一步，它能控制类成员在类外部的可视程度。在类的外部不可见的成员称为私有成员。

在面向对象编程中，封装的作用不仅仅是组合数据和行为，还能隐藏类中的数据和行为的实现细节，使类的内部工作机制不被暴露。这减少了调用者对数据进行不恰当修改的几率。

访问修饰符的作用是提供封装，如果不为类成员添加访问修饰符则默认使用private，即成员默认为私有成员。公共成员必须显式指定。

class Employee
{
    public string FirstName;
    public string LastName;
    public double Salary;

    //允许调用Employee对象并用Logon()方法验证密码，但不允许从类的外部访问Employee对象的Password字段。
    //为了隐藏Password字段，禁止从它的包容类的外部访问，应使用private访问修饰符替代public。
    private string Password;

    private bool IsAuthenticated;

    public bool Logon(string password)
    {
        if(Password == password)
        {
            IsAuthenticated = true;
        }
        return IsAuthenticated;
    }

    public bool GetIsAuthenticated()
    {
        return IsAuthenticated;
    }
}

例如：仪表盘

仪表盘包含哪些部件和动作呢？
部件：表值、名称、零件
动作：指针转动、指针复位、显示度数

4933701-ca5f36ff460763a0.png
仪表盘

流程：

  1. class仅仅是定义，即自定义引用类型。使用class需要使用new进行实例化生成对象。
  2. 理解字段和访问修饰符，访问修饰符用于信息隐藏。
//获取表盘读数 
private double Value = 0;
public double GetValue()
{
    return this.Value;
}
public void SetValue(double value)
{
    this.Value = value;
}
  1. 理解方法和修饰符
  2. 理解关键字this，例如将读数保存到数据库。
//数据库操作类
class DB
{
    public bool Store(DashBoard dashboard)
    {
        double val = dashboard.GetValue();
        //...
        return true;
    }
}

//保存读数到数据库
public bool Save()
{
    DB db = new DB();
    return db.Store(this);
}
  1. 理解属性
    灵活的属性，可提供验证，且保持只读只写。
//属性 惯用手法 getter和setter
//获取表盘读数
public double GetValue()
{
    return this.Value;
}
public void SetValue(double value)
{
    this.Value = value;
}

//属性
public string Name
{
    get { return _Name; }
    //value为上下文关键字，仅仅在特定环境下才有确切含义。
    set { _Name = value; }
}

//属性自动实现
public string Name {
    //只读
    get
    {
        return _Name;
    }
    //只写 private 仅仅内部可写
    set
    {
        if (string.IsNullOrEmpty(value))
        {
            throw new ArgumentException();//抛出参数异常
        }
        _Name = value;
    }
}
  1. 构造器
    理解自定义构造器，例如实例化时必须定义Name，实例化时让指针清零。
    理解默认构造器，一旦有了自定义构造器，默认构造器则无效。
    理解构造器重载，定义多个构造器。
//构造器 无返回值
public DashBoard()
{
    Amount++;//静态属性
    this.Reset();
}
public DashBoard(string name):this() //此处this()调用默认构造器
{
    if (string.IsNullOrEmpty(name))
    {
        this.Name = "unknow";
    }
    else
    {
        this.Name = name;
    }           
}

理解this调用构造器

//构造器 无返回值
public DashBoard()
{
    Amount++;//静态属性
    this.Reset();
}
public DashBoard(string name):this() //此处this()调用默认构造器
{
    if (string.IsNullOrEmpty(name))
    {
        this.Name = "unknow";
    }
    else
    {
        this.Name = name;
    }           
}

理解对象初始化器，扩展集合初始化器、终结器、匿名对象。

//对象初始化器
DashBoard dashboard1 = new DashBoard()
{
    Name = "油表盘"
};
dashboard1.Show();
//匿名对象
var user = new { UserID = 1, UserName = "JunChow" };
Console.WriteLine($"user#{user.UserID}: {user.UserName}");
  1. 静态
    理解静态成员（全局性），属于类型而非实例。
  • 字段、属性：访问时无需实例化
//静态成员 属于类型 属性 共享
public static long Amount { get; set; }
  • 方法：内部不能使用this
//静态方法 静态只能调用静态
public static void ResetAmount()
{
    Amount = 0;
}
  • 构造器：初始化静态成员
//静态成员 属于类型 属性 共享
public static long Amount { get; set; }
//静态构造函数 无public修饰符
//public static是不完整的修饰符，后面要加上 void,String,int等类型，表示方法是静态方法。
static DashBoard()
{
    Amount = 0;
}
//静态方法 静态只能调用静态
public static void ResetAmount()
{
    Amount = 0;
}
  • 类：静态类如Math
//静态类
Console.WriteLine(Math.PI);
  1. 初探设计模式
    单例模式
//单例模式
private static DashBoard _Instance = null;
public static DashBoard Instance {
    get
    {
        if (_Instance == null)
        {
            _Instance = new DashBoard();
        }
        return _Instance;
    }  
}
  1. readonly
    readonly仅仅能在声明、构造函数中赋值。
    const在编译时固定，readonlly在运行时固定。
//readonly 声明时 运行时确定常量
readonly string guid = Guid.NewGuid().ToString();
  1. 嵌套类、分部类、分部方法（存在于分部类中的方法）

综合实例

using ClassLibrary.NS;
using System;
using System.Collections.Generic;

namespace Test
{
    //数据库操作类
    class DB
    {
        public bool Store(DashBoard dashboard)
        {
            double val = dashboard.GetValue();
            //...
            return true;
        }
    }
    //定义类 零件
    class Part
    {

    }
    //定义类 仪表盘
    class DashBoard
    {
        //字段
        private string _Name = "unknow";
        private double Value = 0;
        public List<Part> Parts = null;
        //静态成员 属于类型 属性 共享
        public static long Amount { get; set; }
        //属性 惯用手法 getter和setter
        //获取表盘读数
        public double GetValue()
        {
            return this.Value;
        }
        public void SetValue(double value)
        {
            this.Value = value;
        }
        //属性
        //public string Name {
        //    get { return _Name; }
        //    //value为上下文关键字，仅仅在特定环境下才有确切含义。
        //    set { _Name = value; }
        //}
        //属性自动实现
        public string Name {
            //只读
            get
            {
                return _Name;
            }
            //只写 private 仅仅内部可写
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw new ArgumentException();//抛出参数异常
                }
                _Name = value;
            }
        }

        //指针复位
        private void Reset()
        {
            Value = 0.0;
        }
        //表盘转动
        public void Rotate(double degree)
        {
            Value = degree;
        }
        //显示读数
        public void Show()
        {
            Console.WriteLine("{0}: {1}", Name, Value);
        }
        //保存读数到数据库
        public bool Save()
        {
            DB db = new DB();
            return db.Store(this);
        }
        //构造器 无返回值
        public DashBoard()
        {
            Amount++;//静态属性
            this.Reset();
        }
        public DashBoard(string name):this() //此处this()调用默认构造器
        {
            if (string.IsNullOrEmpty(name))
            {
                this.Name = "unknow";
            }
            else
            {
                this.Name = name;
            }           
        }
        //静态构造函数 无public修饰符
        //public static是不完整的修饰符，后面要加上 void,String,int等类型，表示方法是静态方法。
        static DashBoard()
        {
            Amount = 0;
        }
        //静态方法 静态只能调用静态
        public static void ResetAmount()
        {
            Amount = 0;
        }
    //单例模式
    private static DashBoard _Instance = null;
    public static DashBoard Instance {
        get
        {
            if (_Instance == null)
            {
                _Instance = new DashBoard();
            }
            return _Instance;
        }  
    }
        //readonly 声明时 运行时确定常量
        readonly string guid = Guid.NewGuid().ToString();
    }

    class Program
    {     
        static void Main(string[] args)
        {
            //实例化
            DashBoard dashboard = new DashBoard("仪表盘");
            //dashboard.Name = "仪表盘";
            //dashboard.Reset();
            dashboard.Rotate(10.0);
            dashboard.Show();
            dashboard.Save();

            //对象初始化器
            DashBoard dashboard1 = new DashBoard()
            {
              Name = "油表盘"
            };
            dashboard1.Show();

            //集合对象初始化器

            //匿名对象
            var user = new { UserID = 1, UserName = "JunChow" };
            Console.WriteLine($"user#{user.UserID}: {user.UserName}");

            //终结器

            //静态属性
            Console.WriteLine(DashBoard.Amount);
            DashBoard.ResetAmount();
            Console.WriteLine(DashBoard.Amount);

            //静态类
            Console.WriteLine(Math.PI);

            //单例模式
            var instance1 = DashBoard.Instance;
            instance1.Name = "jacky";
            instance1.Show();
            var instance2 = DashBoard.Instance;
            instance2.Name = "junchow";
            instance2.Show();
            var instance3 = DashBoard.Instance;
            instance3.Show();

            Console.ReadKey();
        }  
    }
}
JunChow520
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 类（Class）
weixin_43055166的博客
11-23 698
当你定义一个类时，你定义了一个数据类型的蓝图。这实际上并没有定义任何的数据，但它定义了类的名称意味着什么，也就是说，类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量称为类的成员。 类的定义 类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。下面是类定义的一般形式： class class_name { // member variables variable1; variable2; … variableN; // membe
C# 学习-常用类梳理
weixin_46024391的博客
05-19 775
C#学习成长篇
部分类、console类、Math类
weixin_57727027的博客
11-01 309
部分类、console类、Math类 C# 部分类 在 C# 语言中提供了一个部分类，正如字面上的意思，它用于表示一个类中的一部分。 关键 字：partial。 一个类可以由多个部分类构成。 定义格式如下： 1 访问修饰符 修饰符 partial class 类名{……} 在这里，partial 即为定义部分类的关键字。 部分类主要用于当一个类中的内容较多时将类 中的内容拆分到不同的定义中，并且部分类的名称必须相同。 注意：部分类中所有的类定义都需要添加partial关键字。 举例如下： 1 /// &l
深入剖析C#类型体系：概念、分类、特性与代码示例
最新发布
java专栏
04-17 508
C#类型体系涵盖了值类型、引用类型、指针类型和可空类型，提供了丰富的数据结构和编程工具。通过类型转换、装箱与拆箱等机制，C#类型体系在保证类型安全的同时，提供了足够的灵活性以适应各种编程场景。在实际编程中，应遵循良好的类型设计原则，合理选择和使用不同类型，以充分发挥C#类型体系的强大功能。C#类型体系是C#语言的基础组成部分，它定义了程序中所有数据的结构、行为和交互规则。C#类型体系的构建旨在提供一种强大、安全且易于使用的类型系统，支持面向对象编程、泛型、接口、枚举、委托等多种编程特性。
c#中的常用类
m0_61551200的博客
03-05 644
除了以上列举的类，还有很多其他的常用类，如DateTime、TimeSpan、Guid等等。String：用于操作字符串的类，包含了很多字符串的方法，如比较、拼接、分割、替换等等。Math：用于数学计算的类，包含了各种数学计算的方法，如求平方根、取整、绝对值等等。MemoryStream：用于操作内存中的数据流的类，可以读写内存中的二进制数据。Array：用于存储同类型元素的集合类，可以快速访问其中的元素。List：用于存储元素的集合类，可以存储各种类型的数据。
C# 中类的基本概念
chinaherolts2008的博客
02-16 2870
一、类的概述 在上一篇文章中（C# 中的类型和变量），我们看到 C# 提供了 6 种用户定义类型。其中最重要的，也是首先要阐述的是类。因为类在 C# 中是个很大的主题，所以关于它的讨论将会延伸到接下来的几篇文章。 类是一种活动的数据结构 在面向对象的分析和设计出现之前，程序员们仅把程序当作指令的序列，那时的焦点主要放在指令的组合和优化上。随着面向对象的出现，焦点从优化指令转移到组织程序的数据和功能上来。程序的数据和功能被组织为逻辑上相关的数据项和函数的封装集合，并被称为类。 类是一个能存储数据并执行代码的数
【Unity】升级版·Excel数据解析，自动创建C#类，自动创建ScriptableObject生成类，自动序列化Asset
07-05
Excel数据解析，自动创建对应C#类，自动创建ScriptableObject生成类，自动序列化Asset文件 功能介绍链接 https://z-c-s.blog.csdn.net/article/details/125608062
C# JSON实体类生成工具
02-24
总的来说，C# JSON实体类生成工具是C#开发者的得力助手，它能帮助开发者快速、准确地构建与JSON数据对应的C#类，简化JSON操作，提升开发效率。通过熟练掌握这类工具的使用，开发者可以在项目中更好地管理和利用JSON...
C# 开发中常用的类大全，C#类
11-09
最全的C#常用开发类，cs文件，使用起来非常方便。大约有100多个常用类，
根据WebService和WCF地址生成C#类
04-08
根据WebService和WCF地址生成C#类，无需使用VS恶心的引用功能，直接new那个类出来调用对应的函数即可，也可以写成动态调用，用法：把wsdl.exe拖到cmd框里，然后空格+服务地址，然后回车即可在根目录生成cs文件
使用OpenXML实现的一个C#类生成器和数据转Json功能.zip
03-08
使用OpenXML实现的一个C#类生成器和数据转Json功能.zip使用OpenXML实现的一个C#类生成器和数据转Json功能.zip使用OpenXML实现的一个C#类生成器和数据转Json功能.zip使用OpenXML实现的一个C#类生成器和数据转Json功能...
Object-C 类和对象
zhongnanshan_001的博客
05-05 3330
Object-C 语言的介绍，网上有很多基础教程，这边就不介绍了，可以在网上搜索一下。主要是归纳一下Object-C的知识。简单说明一下：Object-C简称OC，扩充自C语言，对C语言做了面向对象的处理。                      是OS X和iOS操作系统的主要编程语言。                      Swift 是最新的苹果推荐的编程语言，再过几年也许都使用Swi...
java 初始化从句,JAVA学习笔记
weixin_33598481的博客
03-20 443
1. 如何设置Java开发环境(Win2000)答：Start-Control panel-System-Advance-Environment Variables设置环境变量：PATH = %PATH%;c:\j2sdk1.4.2_05\bin;CLASSPATH = .;注：javac编辑器总是在当前查找文件，而java解释器只有在类路径中包含“.” 目录的情况下才会查找当前目录。如果类路径...
C#---类的定义及声明
qq_46289420的博客
12-18 7275
1.类的定义 我们知道，在C#编程里，类是一种数据结构，它可以包含名词和动词，名词可以理解成数据成员（常量和 域）、而动词可以理解成函数成员（方法、属性）。其实，类实际上是创建变量（对象）的模板。同时，类描述了一系列在概念上有相同含义的对象，并为这些对象统一定义了编程语言上的属性和方法。 比如，水果就可以看做一个类，苹果，葡萄，梨都是该类的子类（派生类），苹果的生产地，名称（如红富士苹果）、价格，运输途径相当于该类的属性，苹果的种植方法相当于类方法。 2.类的声明及使用 a.声明： C#中，类是使用cla
C#中类的定义
chaojishuaigeli的专栏
08-11 848
类是面向对象编程的基本单位，是一种包含数据成员、函数成员和嵌套类型的数据结构。类的数据成员有常量、域和事件。函数成员包括方法、属性、索引指示器、运算符、构造函数和析构函数。类和结构同样都包含了自己的成员，但它们之间最主要的区别在于：类是引用类型，而结构是值类型。   类支持继承机制，通过继承，派生类可以扩展基类的数据成员和函数方法，进而达到代码重用和设计重用的目的。   有关类的概念将放在
类的基本概念
weixin_30945039的博客
07-06 211
类是一种活动的数据结构 类是一个能存储数据并执行代码的数据结构 a)数据成员：它存储与类或类实例相关的数据。 b)函数成员：它执行代码。 字段是隶属于类的变量 显示和隐式字段初始化 a)字段初始化语句是字段声明的一部分，由一个等于号后面跟着一个求值表达式组成。 b...
Class类 getName()、getCanonicalName()、getSimpleName()、getTypeName() 方法的异同
热门推荐
Gene Xu
11-03 1万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Bind 和 ScaffoldColumn
weixin_30260399的博客
04-29 87
今天看了一个源代码，看到里面有这么一段 [MetadataType(typeof(FormMetaData))] public partial class Form { [Bind(Exclude = "Uid")] public class FormMetaData { [ScaffoldColumn(false)] ...
c#类
05-31
下面是一个简单的C#类示例： ``` public class Person { // 成员变量 private string name; private int age; // 属性 public string Name { get { return name; } set { name = value; } } public int...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值