C#简单承袭示例详解——快速入门

在面向对象个中承袭是格外关键的,也是面向对象的三大特征之一,今日大家来揭示她的机密面纱。

 [学学笔记]

复制代码 代码如下:

复制代码 代码如下:

元组的大致:

话非常少说,大家上菜。

一、简介

$defined = function (v) {
    return v != undefined;
}

$defined = function (v) {
    return v != undefined;
}

数组合併了一直以来类别的靶子,而元组合併了分裂种类的对象。元组源点于函数编制程序语言(如F#)
,在
那么些语言中频仍利用元组。在N盯4中,元组可通过.NET
Fmmework用于全数的NET语言。
.NET
4概念了8个泛型Tuple类和三个静态Tuple类,它们用作元组的工厂。这里的不等泛型Tuple
类扶助分化数量的要素。例如,Tuple<T1>包罗-个成分,Tuple<T1,T2>包涵三个因素,以此类推。

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;/** * 假设我们公司有两种程序员: * java程序员指的是用java语法写程序的程序员,用Jpro这个类表示; * C#程序员指的是用C#语法写程序的程序员,用Cpro这个类来表示。 * 每个类都有一个WriteCode()方法。 * 都属于程序员,用Programmer这个类表示。 * 现在公司来了一个项目,要求派某个程序员写一个程序。 */namespace inheritApplication{    //程序员类    class Programmer    {        public  string name = "我是程序员";    }    //java程序员类    class Jpro     {        public string name = "java程序员";        public string language = "我用java语法写代码";    }    //C程序员类    class Cpro     {        public string name = "C#程序员";        public string language = "我用C#语法写代码";    }    //编写项目类    class Pro : Programmer  //继承基类    {        public void WriteProgram(Jpro program)  //继承java程序员类        {            Console.WriteLine("" + program.name + ":" + name + "," + program.language + "");        }        public void WriteProgram(Cpro program)        {            Console.WriteLine("" + program.name + ":" + name + "," + program.language + "");        }    }    //主程序    class Program    {        static void Main(string[] args)        {            Pro p = new Pro();            Jpro p1 = new Jpro();            p.WriteProgram;            Cpro p2 = new Cpro();            p.WriteProgram;            Console.ReadKey();        }    }}

1、C#是由AndersHejlsberg和他的公司在.Net框架开垦时期支付的;是.Net框架的一局地。

Class = function () {
    var base = {};
    for (var k=0; k<arguments.length; k++) {
    //{{new arguments[k]() with custom constructor field.
        var o = arguments[k].prototype;
        o.constructor = arguments[k];
        arguments[k].call(o);
    //}}
        for (key in o) base[key] = o[key];
    }
    function Klass () {
        // for every class one object cache.
        var clso = null;
        function klass() {
            if (arguments.length<=0 && clso!=null) {
                // hit cache.
                return clso;
            }
            if ($defined(this.constructor.init)) {
                // use init() for class initialization.
                this.constructor.init.apply(this, arguments);
            }
            clso = this;
        }
        klass.prototype = base;
        return klass;
    }
    return Klass();
}

Class = function () {
    var base = {};
    for (var k=0; k<arguments.length; k++) {
    //{{new arguments[k]() with custom constructor field.
        var o = arguments[k].prototype;
        o.constructor = arguments[k];
        arguments[k].call(o);
    //}}
        for (key in o) base[key] = o[key];
    }
    function Klass () {
        // for every class one object cache.
        var clso = null;
        function klass() {
            if (arguments.length<=0 && clso!=null) {
                // hit cache.
                return clso;
            }
            if ($defined(this.constructor.init)) {
                // use init() for class initialization.
                this.constructor.init.apply(this, arguments);
            }
            clso = this;
        }
        klass.prototype = base;
        return klass;
    }
    return Klass();
}

 

写好代码后大家运营看看效果!

  C#是专为公共语言功底结构(CLI)设计的,CLI由可举办代码和平运动作时意况结合,允许在分化Computer平台和种类布局上利用各个高端语言。

A = new Class();
A.init = function () {
    this.x = 400;
    this.y = 300;
}
B = new Class(A);
B.init = function () {
    this.y = 200;
    this.z = 100;
}
威尼斯网址开户网站,C = new Class(B);
C.init = function () {
    this.z = 0;
}
c = new C();
alert(c.x);
alert(c.y);
alert(c.z); 

A = new Class();
A.init = function () {
    this.x = 400;
    this.y = 300;
}
B = new Class(A);
B.init = function () {
    this.y = 200;
    this.z = 100;
}
C = new Class(B);
C.init = function () {
    this.z = 0;
}
c = new C();
alert(c.x);
alert(c.y);
alert(c.z); 

1.先是个例证

威尼斯网址开户网站 1

2、C#是大小写敏感的,每条语句都是 ;
结尾。程序实施从main起首,与Java差别的是,文件名能够不相同于类名称;一个文书里能够有三个class;

代码如下: $defined=function(v){
returnv!=undefined; } Class=function(){ varbase={};
for(vark=0;karguments.length;k++){
//{{newarguments[k]()withcustomconstructorfi…

你可能感兴趣的篇章:

  • 深远理解JavaScript承袭的有余办法和优短处
  • JavaScript
    mixin实现多再而三的法子详解
  • JS
    面向对象之继续—七种组成继承详解
  • 谈一谈javascript中三番五次的有余主意
  • ExtJS4中利用mixins完结多三回九转示例
  • 用JavaScript完结单承继和多承继的总结方法
  • Javascript基于对象三大特点(封装性、承接性、多态性)
  • js中达成多态选取和接二连三类似的章程
  • javascript
    面向对象全新理练之继续与多态
  • JavaScript落到实处多种承接的方法剖析

        private Tuple<int, int> Divide(int dividend, int
divisor)
        {
            int result = dividend / divisor;
            int reminder = dividend % divisor;
            return Tuple.Create<int, int>(result,
reminder);           //再次回到五个同样体系成分的元组
        }

很鲜明看出来,公司五个程序猿都一而再了程序猿类。

3、Console.Write()             
打字与印刷,二回同有时候打字与印刷多个参数可用占位符{0}…类似于format,前边用逗号隔离依次要输入各位的参数;

       ——–测试————-

总结:

4、Console.ReadLine()   输入;

        private void button1_Click(object sender, EventArgs e)
        {
            Tuple<int, int> result = Divide(13, 2);
            Console.WriteLine(“result of divison:{0},” +
                “reminder:{1}”, result.Item1,
result.Item2);                //用属性item1,item2访谈元组的项
        }

父类蕴含了多少内容,派生类全部承受(包含属性 字段 方法等),

5、Console.ReadKey()    等待开关;

       ——-结果————-

能够重写覆盖,使用override重写,能够行使base调用父类中的内容。

6、// 或者 /*…*/           注释

       result of divison:6,reminder:1

接轨能够减弱代码的冗余,也为顺序的改换提供了比非常大的方便之处。

7、hello world

2.次之个例证

自然,假如构成接口那就完善了,下一篇中我们将关乎接口的落实。

 1 //hello world.cs
 2 
 3 using System; //使用系统命名空间
 4 
 5 namespace HelloWorldApplication //声明命名空间
 6 
 7 {
 8 
 9    class HelloWorld            //class声明
10 
11    {
12 
13       static void Main(string[] args)  /* main   方法 */
14 
15       {
16 
17          /* 我的第一个 C# 程序*/
18 
19          Console.WriteLine("Hello World");
20 
21          Console.ReadKey();
22 
23       }
24 
25    }
26 
27 }

        private Tuple<int, string> MyTest2(int dividend, string
Name)
        {
            int result = dividend / 2;
            string name = “Hello,” + Name;
            return Tuple.Create<int, string>(result, name);     
//重临三个不等种类成分的元组
        }

 

        ——–测试————-

 

        private void button2_Click(object sender, EventArgs e)
        {
            Tuple<int, string> result = MyTest2(13, “limin”);
            Console.WriteLine(“result of divison:{0},” +
                “Name:{1}”, result.Item1, result.Item2);               
//用属性item1,item2访谈元组的项
        }

二、基础      

        ——-结果————-

1、数据类型

        result of divison:6,Name:Hello,limin

bool        布尔值

3.第3个例子

byte 8     位无符号整数(0到255)

一旦元组包蕴的项超越8个,就可以利用带8个参数的Tuple类定义。倒数模板参数是TRest
,
意味着必需给它传递一个元组。这样,就足以创制带大四个参数的元组了。
上面表明这一个成效:
public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>
内部,最终二个模板参数是二个元组类型,所以能够创立带率性多项的元组:
var tuple = Tuple.Create<string,string,string, int,int,int,double,
Tuple<int,int>>(
“stephanie”,”Alina”,”Nagel”, 2009,6,2,1.37,
Tuple.Create<int,int> (52,3490));

char 16    位Unicod字符

decimal   1贰21个人可信赖的十进制值,28-二十几个人有效数

double    63个人双精度浮点型

float 32    位单精度浮点型

int          三18人有标记整型

long 64    位有号子整型

sbyte      8位有暗记整型

short      16个人有标识整型

uint 32    位无符号整型

ulong     62人无符号整型

ushort    14人无符号整型

 

可用sizeof(type)方法来赢得三个变量在特定平台上的纯正尺寸;

string            
字符串可用引号和@辅导,用@指导时名称为“逐字字符串”,此时转义字符会被看作普通字符管理,且可开展随机的换行和缩进管理;多个字符串可用+号连接

type* name    指针类型

dynamic        动态类型

const             常量

nullable         可空类型(注脚:<data_type> ?
<variable_name> = null;合併运算符 ??
用于定义可空类型和援用类型默许值,若是不为空则为??后面包车型大巴值,借使给定值为空,则用??后面包车型地铁暗中认可值)

 

2、数据类型调换

来得类型转变(强制转变)

double d = 1.23;

int x;

i = (int)d;

 

3、内置类型转变方法

ToBooolean   假使可能的话,把类型转变为布尔型

ToByte           把类型转变为字节类型

ToChar          如若恐怕的话,把类型调换为单个Unicode字符类型

ToDate提姆e   把类型转变为时间协会

ToDecimal     把浮点型或整数类型转变为十进制类型

ToDouble      把类型调换为双精度浮点型

ToInt16          把类型调换为16个人整数类型

ToInt32          把类型变换为三十二个人整数类型

ToInt64          把类型转变为六16位整数类型

ToSbyte         把类型转变为有标识字节类型;

ToSingle 把类型调换为有号子字节类型

ToString  把类型转变为字符串类型

ToType          把类型调换为钦命项目

ToUInt16 把类型调换为二十个人无符号整数类型

ToUInt32 把类型转换为32人无符号整数类型

ToUInt64 把类型调换为六12个人无符号整数类型

 

示例:int i = 5;

         i.ToSingle()  

string locstr = 123.ToString();

//假设要将”locstr”转成整型数

//方法一: 用 Convert

int i = Convert.ToInt16(locstr);

//方法二: 用 Parse

int ii = int.Parse(locstr);

 

4、数据装箱与拆箱

装箱(值类型调换为对象类型)

int x = 8;

object ob = x;

拆箱(在此以前由值类型转变而来的目的类型再转回值类型)

int x = 9;

object ob = x;

int y = (int)ob

 

5、运算符

算术运算符:+,-,*,/,%,++,–

提到运算符:==,!=,>,<,>=,<=

逻辑运算符:&&,||,!

位运算符:&,|,^,~,<<,>>

赋值运算符:=,+=,-=,*=,/=,%=,<<=,>>=,^=,|=

任何运算符:

sizeof()    再次来到数据类型的大大小小

typeof()   返回class类型

&                  重临变量的地方

*                    变量的指针

?:                   条件表明式

is                   推断指标是或不是为某一品类

as                  强制调换,纵然失利也不会抛出特别

 

6、数组(Array)

声明: datatype[] arrayName;

初始化: double[] a = new
double[10],可选拔foreach来遍历数组:foreach (double i in a)

C#援救多维数组;在概念贰个新数组时[ ]也得以不给定个数。

 

7、结构(struct)

struct name

{

       Access_Specifier type name

}

C#中结构与C或C++比较有以下特征:

1)结构可含蓄艺术、字段、索引、属性、运算符方法和事件;

2)结构可定义构造函数,但无法定义析构函数;但也无法定义暗许的构造函数;

3)与类差异,结构无法三番八遍别的组织或类的功底结构;

4)结构可达成三个或三个接口;

5)结构成员不可能钦点为abstract、virturl或protected;

6)当使用New操作符创制一个协会对象时,会调用适当的构造函数来创立布局;但组织可不采纳New操作符就能够被实例化;

7)假如不应用New操作符,只有在具备的字段都被起始化之后,字段才被赋值,对象才被使得;

 

8、枚举(Enum)

enum <enum_name>

{

       enumeration list

}

默许枚举的第二个记号的值是0,但也能够协调内定每种符号的值。

 

三、调控结构

1、if…else语句

if(boolean_expression){

}

else if{

}

else{

}

 

2、switch语句

switch(expression){

       case const-expression:

              statement(a);

              break;

       case const-expression:

              statement(b);

              break;

       default:

              statement(c);

              break;

}

 

3、while循环

while(condition){

       statement;

}

 

4、do…while循环

do{

       statement;

}while(condition);

 

5、for循环

for(init;condition;increment){

       conditional code;

}

 

6、函数

<Access Specifier> <Return Type> <Method
Name>(Parameter List)

{

       Method Body;

}

 

四、面向对象编制程序(Class)

1、C#的封装

public            全部目的都得以访谈;

private           对象自己在对象内部能够访谈;

protected       只有该类对象及其子类对象足以访问;

internal   同三个主次集的目的能够访谈;

protected internal 一个前后相继集内的目的,或然该类对象及其子类能够访谈;

 

2、类的概念

<access specifier> class class_name

{

       <access specifier> <data_type> variable_name1;

       <access specifier> <data_type> variable_name2;

       …

       <access specifier> <return_type>
method1(parameter_list){

              body;

       }

       <access specifier> <return_type>
method1(parameter_list){

              body;

       }

       …

}

3、构造函数

类的多个新鲜成员函数,当创制类的新对象时施行;构造函数名称与类名称完全同样,但它未有其余重临类型。

私下认可的构造函数没有任何参数,但也足以有参数,这种方法能够扶助在创造对象相同的时候给指标赋最早值。

4、析构函数:

类的多个异样成员函数,当类的靶子超出范围时举办;

析构函数的称谓是在类的称谓前拉长多少个 ~
作为前缀,它不再次来到值,也不带参数;

析构函数用于在截止程序在此以前释放能源。析构函数无法一而再或重载;

 

5、类的一而再:

class <derived_class> : <base_class>{

}

对于构造函数的承接需求在参数后加 : baseMethod(parameter_list)

对此表明为sealed类为密封类,密闭类没办法被接二连三。

C#不协理多种承接,但可以由此接口来贯彻。

6、函数重载

在同贰个限量内对同样的函数名有三个概念,但函数的概念必得彼此差别,能够是参数类型分化,也得以是个数分裂,但不可能唯有重返类型差别。

7、动态多态性(抽象类和虚方法)

利用abstract关键字创设抽象类,用于提供接口的局部类的落到实处。当三个派生类继承自该抽象类时,完毕即完毕;抽象类包涵抽象方法,抽象方法可被派生完结;

接轨八个虚幻方法时用override评释;

无法创设一个抽象类的实例;

不可能在三个抽象类外界声Bellamy(Bellamy)个浮泛方法;

抽象类不可能被声称为sealed。

 

虚方法用virtual注脚,在差别的承袭类中有不相同的贯彻,对虚方法的调用是在运营时爆发的。

 

8、运算符的重载

在类中对运算符的双重定义,通过主要字operator+运算符 来定义的;

除非算术运算符和相比较运算符可以被重载。

 

9、接口(interface)

接口定义了全体类继承袭口时应按照的语法公约,定义了品质、方法和事件;接口使得达成接口的类或协会在情势上保持一致。

接口使用interface证明,前边接接口名称就可以。

接口的一而再和类一样,类继承袭口时必需先在static void
main()中实例三个脚下的类,然后调用接口的办法,再落到实处接口的办法。

 

附:

1、命名空间(namespace)

用于提供一种让一组名称与任何名目分隔开分离的格局。在同一程序内选拔八个命名空间,在调用其余的类或情势时需用命名空间名后跟
. 举行定点分别。

也得以选取using来提前命名空间。(using还能用来给不长的路线起小名)

取名空间能够扩充嵌套。

 

2、预管理器指令:

#define          定义一文山会海成为符号的字符;

#undef          打消定义符号;

#if                 测验符号是或不是为真;

#else             与#if一齐行使;

#elif        与#if一齐利用;

#endif            钦点叁个规范指令的利落;

#line              修改编写翻译器的行数及出口错误和警戒的公文名;

#error            允许代码的钦点地方生成三个破绽百出;

#warning       允许代码的钦赐地方生成超级警告;

#region         内定三个可开展或折叠的代码块;

#endregion    与#region一齐用,表示停止。

 

相关文章