做些技术积累,高手不要见笑。因为C#有点Java和C++杂交的味道,太容易让人记混了。
指定声明的类型和类型成员的可访问性。
public:
访问不受限制, 任何地方都可以访问。
protected:
访问仅限于类或派生类。
private:
访问仅限于类
internal:
访问仅限于当前程序集。
protected internal:
访问仅限于当前程序集或派生类。
-----------------------------------------------------------
一个成员或类型只能有一个访问修饰符
命名空间上不允许使用访问修饰符。命名空间没有访问限制。
不嵌套在其他类型中的顶级类型的可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。
类中成员的默认可访问性是private
命名空间中的类型可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。
------------------------------------------------------------
abstract:
抽象类
不能被实例化
可包含抽象方法和抽象属性
派生类必须实现抽象基类的所有抽象成员,通过重写抽象成员实现。
------------------------------------------------------------
Sealed
密封类
不能被继承 , 可防止意外的继承
abstract 修饰符与密封类一起使用是错误的。
结构是隐式密封的,因此它们不能被继承。
ps:我晕,Java中final关键字的翻版。
-------------------------------------------------------------
static
静态类:
仅包含静态成员。
不能被实例化。不能使用 new 关键字创建静态类的实例
是密封的。
不能包含实例构造函数, 可包含静态构造函数
-------------------------------------------------------------
成员修饰符
abstract:
方法或属性不能实现。都是隐式虚拟,且在派生类中必须实现。
const
它指定字段(域)成员或局部变量的值是常数,不能被修改。
不允许在常数声明中使用 static 修饰符 。
event:
声明事件。
extern:
指示方法在外部实现.
virtual:
virtual:
指示一个方法或属性可以被派生类改写.
override:
对由基类继承的虚( virtual )、抽象(abstract)的成员的新实现.
readonly:
指示一个域成员只能在声明时以及相同类的构造函数中被赋值.
static:
指示一个成员属于类,而不是属于类的实例.
可用于域成员、方法、属性、操作符、构造函数
可用于域成员、方法、属性、操作符、构造函数
-----------------------------------------------------------
此段摘自:
1,整型
C# 支持九种整型:
其中char类型比较特殊。虽然属于整型类别。但是以下两个方面不同于其他整型:
1)不存在从其他类型到
2,浮点型
浮点型精度较低,不推荐两个浮点型之间比较大小的判断。
3,decimal类型
decimal类型是采用四舍六入五考虑的银行家舍入法进行计算的。
4,值类型
C# 支持九种整型:
sbyte
、
byte
、
short
、
ushort
、
int
、
uint
、
long
、
ulong
和
char
。
其中char类型比较特殊。虽然属于整型类别。但是以下两个方面不同于其他整型:
1)不存在从其他类型到
char
类型的隐式转换。具体说来,即使
sbyte
、
byte
和
ushort
类型具有完全可以用
char
类型来表示的值范围,也不存在从
sbyte
、
byte
或
ushort
到
char
的隐式转换。
2
)char
类型的常数必须写成字符或带有强制转换为类型
char
的整数。例如,
(char)10
与
'"x000A'
是相同的。
2,浮点型
C#
的浮点型包括:float和double。
float
类型可表示精度为 7 位、在大约 1.5 × 10−
45 到 3.4 × 10
38 的范围内的值。
double
类型可表示精度为 15 位或 16 位、在大约 5.0 × 10−
324 到 1.7 × 10
30
8 的范围内的值。
浮点型精度较低,不推荐两个浮点型之间比较大小的判断。
3,decimal类型
decimal
类型是适合财务和货币计算的 128 位数据类型。
decimal
类型可以表示具有 28 或 29 个有效数字、从 1.0 × 10
-28 到大约 7.9 × 10
28 范围内的值。
decimal类型是采用四舍六入五考虑的银行家舍入法进行计算的。
4,值类型
![](https://images.cnblogs.com/cnblogs_com/sutengcn/valueType.png?x-oss-process=image/resize,w_1400/format,webp)
PS: 这图不错!
------------------------------------------------------------------
const 、 readonly区别
const 字段只能在该字段的声明中初始化。
readonly 字段可以在声明或构造函数中初始化。
因此,根据所使用的构造函数,readonly 字段可能具有不同的值。
const 字段为编译时常数
readonly 字段可用于运行时常数
const 字段类外通过类名访问
readonly 字段通过类实例(实例变量)或类(静态变量)访问
------------------------------------------------------------------
对于那些本质上应该是常量,但是却无法使用const来声明的地方,可以使用static readonly
下面是一段关于C#继承与封装的程序,不过我估计这应该是最老的一个写法了,现在C#的语法糖,应该
已经有更方便的实现方式了,只不过我还没接触到。
using
System;
namespace test{
public class Student{
private string student_id; // 学号
private string student_name; // 姓名
public static string information = " ---------学生上课情况表---------- " ;
public Student( string id, string name) // 构造函数
{
student_id = id;
student_name = name;
}
public string StudentID // 用于访问私有字段 student_id的属性
{
get
{ return student_id;}
set
{ student_id = value;}
}
public string StudentName // 用于访问私有字段 student_name的属性
{
get
{ return student_name;}
set
{ student_name = value;}
}
public string AddressClass( int i)
{
string CAddress;
if (i == 1 )
CAddress = " 2楼 " ; // 研究生在2楼上课
else
CAddress = " 3楼 " ; // 本科生在3楼上课
return CAddress;
}
}
public class Graduate:Student{
public Graduate( string i, string j, string tn): base ( i, j )
{ teacher_name = tn; }
public string TeacherName // 用于访问私有字段 student_name的属性
{
get
{ return teacher_name;}
set
{ teacher_name = value;}
}
private string teacher_name; // 导师名
}
class AppStudent
{
public static void Main(){
Console.WriteLine( " {0} " ,Student.information);
Graduate gs = new Graduate( " 2007480*** " , " 哈哈 " , " 施杨 " );
Console.WriteLine( " 研究生学号={0} " ,gs.StudentID); // 调用属性StudentID
Console.WriteLine( " 研究生姓名={0} " ,gs.StudentName); // 调用属性StudentName
Console.WriteLine( " 研究生上课地点={0} " ,gs.AddressClass( 1 )); // 调用方法
Console.WriteLine( " 教师姓名={0} " ,gs.TeacherName);
Console.ReadLine();
}
}
}
namespace test{
public class Student{
private string student_id; // 学号
private string student_name; // 姓名
public static string information = " ---------学生上课情况表---------- " ;
public Student( string id, string name) // 构造函数
{
student_id = id;
student_name = name;
}
public string StudentID // 用于访问私有字段 student_id的属性
{
get
{ return student_id;}
set
{ student_id = value;}
}
public string StudentName // 用于访问私有字段 student_name的属性
{
get
{ return student_name;}
set
{ student_name = value;}
}
public string AddressClass( int i)
{
string CAddress;
if (i == 1 )
CAddress = " 2楼 " ; // 研究生在2楼上课
else
CAddress = " 3楼 " ; // 本科生在3楼上课
return CAddress;
}
}
public class Graduate:Student{
public Graduate( string i, string j, string tn): base ( i, j )
{ teacher_name = tn; }
public string TeacherName // 用于访问私有字段 student_name的属性
{
get
{ return teacher_name;}
set
{ teacher_name = value;}
}
private string teacher_name; // 导师名
}
class AppStudent
{
public static void Main(){
Console.WriteLine( " {0} " ,Student.information);
Graduate gs = new Graduate( " 2007480*** " , " 哈哈 " , " 施杨 " );
Console.WriteLine( " 研究生学号={0} " ,gs.StudentID); // 调用属性StudentID
Console.WriteLine( " 研究生姓名={0} " ,gs.StudentName); // 调用属性StudentName
Console.WriteLine( " 研究生上课地点={0} " ,gs.AddressClass( 1 )); // 调用方法
Console.WriteLine( " 教师姓名={0} " ,gs.TeacherName);
Console.ReadLine();
}
}
}
----------------------------------------------------------------------------------
base关键字
base 关键字用于从派生类中访问基类的成员
----------------------------------------------------------------------------------
方法的覆写与调用
using
System;
namespace test{
class BaseClass{
public void TestMethod(){
Console.WriteLine( " BaseClass:: TestMethod " );
}
}
class DerivedClass:BaseClass{
new public void TestMethod(){
base . TestMethod(); // base访问基类中被隐藏的方法
Console.WriteLine( " DerivedClass:: TestMethod " );
}
}
class App
{
public static void Main(){
DerivedClass t = new DerivedClass();
t.TestMethod(); // 调用DerivedClass:: TestMethod()
((BaseClass)t). TestMethod(); // 调用BaseClass:: TestMethod()
Console.ReadLine();
}
}
}
namespace test{
class BaseClass{
public void TestMethod(){
Console.WriteLine( " BaseClass:: TestMethod " );
}
}
class DerivedClass:BaseClass{
new public void TestMethod(){
base . TestMethod(); // base访问基类中被隐藏的方法
Console.WriteLine( " DerivedClass:: TestMethod " );
}
}
class App
{
public static void Main(){
DerivedClass t = new DerivedClass();
t.TestMethod(); // 调用DerivedClass:: TestMethod()
((BaseClass)t). TestMethod(); // 调用BaseClass:: TestMethod()
Console.ReadLine();
}
}
}
-------------------------------------------------------------------------------
引用参数:
ref修饰符声明,不创建新的存储位置
变量被作为实参传递前,自身必须被明确赋值。
引用参数被认为是初始化过的。
out修饰符声明,不创建新的存储位置
变量被作为实参传递前,自身不需要明确地赋值。
调用后,实参变量被认为已被明确赋值
输出参数被认为是未初始化过的。
返回之前,必须为每一个输出参数明确地赋值。
实现多值返回
参量参数:
params修饰符声明
一个参量参数必须是形式参数列表中的最后一个
参量参数的类型必须是一个单维数组类型。
例如,类型int[]可以被用作参量参数类型,但是类型int[,]不能用。
using
System;
namespace test{
class Test{
static void F( params int [] args){
Console.WriteLine( " # of arguments: {0} " , args.Length);
for ( int i = 0 ; i < args.Length; i ++ )
Console.WriteLine( " \t args[{0}] = {1} " , i, args[i]);
}
static void Main(){
F( );
F( 1 , 2 );
F( 1 , 2 , 3 );
F( new int [] { 1 , 2 , 3 , 4 });
Console.ReadLine();
}
}
}
namespace test{
class Test{
static void F( params int [] args){
Console.WriteLine( " # of arguments: {0} " , args.Length);
for ( int i = 0 ; i < args.Length; i ++ )
Console.WriteLine( " \t args[{0}] = {1} " , i, args[i]);
}
static void Main(){
F( );
F( 1 , 2 );
F( 1 , 2 , 3 );
F( new int [] { 1 , 2 , 3 , 4 });
Console.ReadLine();
}
}
}
PS:Java里没有,个人觉得有点多余。
--------------------------------------------------------------------------------
多态上要强于Java,因为Java中的子类中如果有与父类同名同参的方法,必须覆写,否则报错,而C#可以new一个方法,从而实现
在不改变父类方法的同时,新开辟一块内存空间,保存子类的同名同参方法。但是同样Java中的继承机制也没有C#复杂,但是也不失
简练,子类不用重写父类方法,就可以用super调用。Java中的接口对应C#中的虚函数。相对而言,比较习惯用Java的接口。
as运算符的功能与强制类型转换类似。
可将一个对象强制转换为另一类型。
如果源类型无法转换为目标类型,则首先将其置为null,然后再转换为目标类型
本文转自施杨博客园博客,原文链接:http://www.cnblogs.com/shiyangxt/archive/2009/05/03/1447865.html,如需转载请自行联系原作者