学到封装就会想到访问修饰符,提及走访修饰符,就会想到访问等级,可能说是访问能力的高低。当然也少不了默许的访问类型。

封装 被定义为”把一个或四个体系封闭在二个物理的恐怕逻辑的包中”。在面向对象程序设计方法论中,封装是为了防患对达成细节的拜会。

析构函数和构造函数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 面向对象编程
{
    class Person
    {
       /***********构造函数************/
        // 构造函数,函数名和类同名,当用new关键字实例化Person对象时,就会调用这个函数
        // public 公共的,表示这个构造方法是公共的,任何类都可以调用
        //public Person(string a)
        //{
        //    Console.WriteLine(a);
        //}


        // 静态构造函数,只会被执行一次,他是属于类的,不属于那个实例

        /* 静态构造函数特点:
         1.静态构造函数既没有访问修饰符,也没有参数
         2.在创建第一个实例或者引用任何一个静态成员之前,将自动调用静态构造函数来出事化类,也就是无法直接调用静态构造函数,也无法控制什么时候执行
         3.一个类只能有一个静态构造函数,最多只能运行一次
         4.静态构造函数不可以被继承
         5.如果静态构造函数,而类中静态成员有初始值,那么编译器会自动生成默认的静态构造函数。

             */
        static int i = 0;
        static Person()
        {
            i++;

            Console.WriteLine("我被访问了{0}次", i);
        }


        // 私有构造函数
        // private 私有的,访问修饰符,当实例化对象时使用默认构造方法时,编译器就会报错,无法编译通过
        //private Person()
        //{
        //    Console.WriteLine("无参构造函数");

        //}

        /************析构函数***************/
        /*
         1.析构函数没有参数没有返回值,为了与构造函数区别,在前面加上一个符号“~”
         2.一个类智能有一个析构函数,不能重载
         3.如果用户没有编写析构函数,编译系统自动生成一个缺省的析构函数
             */
        ~Person()
        {
            Console.WriteLine("死了");
        }
    }

    class Program
    {
        static void test()
        {
            Person person = new Person();
            //Console.WriteLine(person.GetName());
            Person person2 = new Person();
            person = null;
            person2 = null;

        }


        static void Main(string[] args)
        {

            test();
            Console.ReadKey();
        }
    }
}

 

     public意思是指变量能够被几次三番的类和new的实例条用.成效于全域.

  1. C# 方法私下认可访问级别 : private
    (私有的) 
  2. C# 类暗中同意访问级别 : internal   
    (内部的) 

泛泛和包装是面向对象程序设计的相干特性。抽象允许相关音信可视化,封装则使开发者金玉锦绣所需级别的画个饼来解除饥饿

封装

访问修饰符:

若是未有点名访问修饰符,则暗许是private

  • Public
  • Private
  • Protected
  • Internal
  • Protected internal

     private 只可以在基类中运用. 继承的,实例后的都不得以.

封装 被定义为”把一个或四个连串封闭在1个大体的如故逻辑的包中”。在面向对象程序设计方法论中,封装是为着预防对促成细节的造访。

C#
封装依照实际的需求,设置使用者的拜会权限,并由此 做客修饰符 来实现。

【金沙注册送58】走访修饰符,面向对象。Public 修饰符

Public
访问修饰符允许3个类将其成员变量和成员函数揭穿给别的函数和对象。任何国有成员能够被外表访问

 

虚幻和包装是面向对象程序设计的有关性情。抽象允许相关新闻可视化,封装则使开发者金玉锦绣所需级别的架空

一个 访问修饰符 定义了八个类成员的范围和可知性。C#
扶助的拜访修饰符如下所示:

Private 修饰符

Private
访问修饰符允许二个类将其成员变量和分子函数对其余函数和对象进行隐蔽。唯有同多个类中的函数能够访问他的私家从分子

 1金沙注册送58 1class Vehicle
 2金沙注册送58 2金沙注册送58 3金沙注册送58 4{
 3金沙注册送58 5 public int wheel; //公有变量wheel,
 4金沙注册送58 6 private float weight; //私有变量weight
 5金沙注册送58 7 public void F()
 6金沙注册送58 8金沙注册送58 9 金沙注册送58 10{
 7金沙注册送58 11    wheel=四;   //合法调用
 8金沙注册送58 12    weight=二.2;  //合法调用. 
 9金沙注册送58 13 }
10金沙注册送58 14}
11金沙注册送58 15
12金沙注册送58 16class Train
13金沙注册送58 17金沙注册送58 18金沙注册送58 19{
14金沙注册送58 20 public int num;   //公有变量 num
15金沙注册送58 21 private int passenger; //私有变量passenger
16金沙注册送58 22 public void F()
17金沙注册送58 23金沙注册送58 24 金沙注册送58 25{
18金沙注册送58 26    num=4; //合法
19金沙注册送58 27    passenger=100; //合法
20金沙注册送58 28    Vehicle v= new Vehicle();
21金沙注册送58 29    v.wheel=四;  //合法, 调用到Vehicle的类中变量.
22金沙注册送58 30    v.weight=贰.二;  //违法. 因为vehicle中的weight是个体的.
23金沙注册送58 31 } 
24金沙注册送58 32}
25金沙注册送58 33
26金沙注册送58 34class Car:Vehicle  //car的类继承自vehicle类.
27金沙注册送58 35金沙注册送58 36金沙注册送58 37{
28金沙注册送58 38 int passenger;  
29金沙注册送58 39 public void K()
30金沙注册送58 40金沙注册送58 41 金沙注册送58 42{   
31金沙注册送58 43   wheel=6;  //合法.
32金沙注册送58 44   weight = 4.二;  //不合规. //因为vehicle里面包车型的士是私有.
33金沙注册送58 45 }
34金沙注册送58 46}

C#
封装依据现实的急需,设置使用者的拜访权限,并通过 走访修饰符 来实现。

  • Public:全体目的都能够访问;
  • Private:对象自小编在对象内部能够访问;
  • Protected:只有该类对象及其子类对象足以访问
  • Internal:同3个主次集的指标能够访问;
  • Protected internal:贰个先后集内的目的,恐怕该类对象及其子类能够访问
Protected 修饰符

Protected 修饰符允许子类访问他的基类的积极分子变量和成员函数。那种方法推进继承

 

一个 走访修饰符 定义了八个类成员的范围和可知性。C#金沙注册送58
帮助的拜访修饰符如下所示:

比方未有点名访问修饰符,则选用类成员的默许访问修饰符,即为 private

Internal 修饰符

Internal 修饰符允许二个类将其成员变量和成员函数揭露给当下先后中的别的函数和指标,换句话说,带有访问Internal
修饰符的别的成员能够被定义在改成员所定义的应用程序内的其他类或方法访问


  • public:全体目标都足以访问;(公共的)
  • private:对象自作者在目标内部能够访问;(私有的)
  • protected:唯有该类对象及其子类对象足以访问;(受保险的)
  • internal:同一个程序集的靶子能够访问;(内部的)
  • protected
    internal:访问限于当前先后集或派生自包涵类的类型。(内部受保障的)

Public 访问修饰符

Public
访问修饰符允许3个类将其成员变量和分子函数暴光给其余的函数和对象。任何国有成员能够被外表的类访问。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program1
    {
        public int a;
        public int b;

        public int AddData()
        {
            return a + b;
        }
        public void Display()
        {
            Console.WriteLine("a: {0}", a);
            Console.WriteLine("b: {0}", b);
            Console.WriteLine("和: {0}", AddData());
        }
    }

    class Program2
    {
        static void Main(string[] args)
        {
            Program1 a = new Program1();
            a.a = 3;
            a.b = 5;
            a.Display();
            Console.ReadLine();
        }
    }
}

当上边包车型客车代码被编写翻译和履行时,它会时有发生下列结果:

a: 3
b: 5
和: 8

地点程序中,class program一 中变量和函数被声称为 public,
因而能够被下面包车型大巴program第22中学Main()函数 使用program一类的实例
访问到。

Protected internal 修饰符

Protected internal
修饰符允许1个类将其成员变量和分子航沪深对相同应用程序诶的子类以外的其余类对象和函数实行隐蔽

  • Public,采纳它的主意是在成员声称中回顾 public 修饰符。public
    的直观含义是“访问不受限制”。
  • Protected,选择它的不二法门是在成员声称中回顾 protected
    修饰符。protected
    的直观含义是“访问范围限定于它所属的类或从该类派生的品类”。
  • Internal,采用它的法门是在成员声称中包蕴 internal
    修饰符。internal 的直观含义是“访问范围限定于此程序”。
  • Protected
    internal(意为受保障或内部的),选取它的法子是在成员声称中包罗
    protectedinternal 修饰符。protected internal
    的直观含义是“访问范围界定于此程序或那多少个由它所属的类派生的品种”。
  • Private,选拔它的艺术是在成员声称中回顾 private 修饰符。private
    的直观含义是“访问范围限制于它所属的类型”。

对于访问修饰符中 涉及的程序集和命名空间 :   

Private 访问修饰符

只有同二个类中的函数能够访问它的私家成员,固然是类的实例也不能够访问它的私人住房成员。假如将地点程序类
program第11中学 a,b前的注明改为 private
,在用类的实例对它们进行访问时会出现下边提醒:

金沙注册送58 47

 

在那种注明下,在任何类中为了采纳(操作)这个数值,能够在这个数值所在的类下编写能够操作这一个数值的函数,然后在别的类中访问那些函数,程序如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program1
    {
        private int a;
        private int b;

        public void Acceptdetails()
        {
            Console.WriteLine("请输入a:");
            a = Convert.ToInt16(Console.ReadLine());
            Console.WriteLine("请输入b:");
            b = Convert.ToInt16(Console.ReadLine());
        }
        public int AddData()
        {
            return a + b;
        }
        public void Display()
        {
            Console.WriteLine("a: {0}", a);
            Console.WriteLine("b: {0}", b);
            Console.WriteLine("和: {0}", AddData());
        }
    }

    class Program2
    {
        static void Main(string[] args)
        {
            Program1 a = new Program1();
            a.Acceptdetails();
            a.Display();
            Console.ReadLine();
        }
    }
}

运维结果如下:

请输入a:
5
请输入b:
4
a: 5
b: 4
和: 9

  

方法

  • 定义
  • 调用

扬言3个成员时所能选拔的已注解可访问性的类型,信赖于该成员声称出现处的上下文。别的,当成员声称不分包其余访问修饰符时,注解发出处的左右文子禽为该成员选拔四个暗中同意的已声明可访问性。

程式集:IL+元数据

Protected 访问修饰符

Protected
访问修饰符允许子类访问它的基类的成员变量和分子函数。那样有助于达成几次三番。

定义
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}
  • 命名空间隐式地享有 public
    已扬言可访问性。在命名空间评释中不容许利用访问修饰符。
  • 编译单元或命名空间中扬言的门类能够具备 publicinternal
    已扬言可访问性,默许的已申明可访问性为 internal
  • 类成员可具有二种已扬言可访问性中的任何1种,暗许为 private
    已扬言可访问性。(请留心,表明为类成员的品种可具备四种已证明可访问性中的任何一种,而评释为命名空间成员的档次只好拥有
    publicinternal 已声明可访问性。)
  • 结构成员能够拥有 publicinternalprivate
    已注脚可访问性并暗中同意为 private
    已扬言可访问性,那是因为组织是隐式地密封的。结构的分子若是在此布局中宣示的(也正是说,不是由该组织从它的基类中继承的)不能够拥有
    protectedprotected internal
    已扬言可访问性。(请留意,证明为结构成员的花色可享有
    publicinternalprivate
    已扬言可访问性,而注解为命名空间成员的种类只好拥有 public
    internal 已评释可访问性。)
  • 接口成员隐式地拥有 public
    已表明可访问性。在接口成员声称中区别意使用访问修饰符。
  • 枚举成员隐式地拥有 public
    已扬言可访问性。在枚举成员声称中不容许利用访问修饰符。

假如说命名空间是类库的逻辑协会情势,那么程序集正是类库的物理组织格局。只有同时钦命项目所在的命名空间及落实该品种的程序集,才能一心限定该类型。(摘抄自《驾驭.NET宗旨技术–原来与框架结构》 电子工业出版社)

Internal 访问修饰符

Internal
访问说明符允许二个类将其成员变量和分子函数揭示给当下程序中的别的函数和对象。换句话说,带有
internal
访问修饰符的别的成员能够被定义在该成员所定义的应用程序内的其余类或措施访问。

 

调用

采纳.语法调用三个类的点子

 

public, internal, protected internal, private申明类实例方法的可访问性.

比如说大家要用A类,则供给把带有A类的程序集(即*.DLL)引用到该工程中(物理);而在程序中要注明A类的命名空间(逻辑)。

Protected Internal 访问修饰符

Protected Internal
访问修饰符允许在本类,派生类或然隐含该类的程序集中走访。那也被用来落实持续。

  

 

继承

C#不帮助多一连,但能够动用接口来促成多连续。用C#创造2个派生类的语法如下:

<acess-specifier> class <base_class>
{
   ...
}
class <derived_class> : <base_class>
{
   ...
}

C#接二连三实例:

class Rectnangle
    {
        protected double length;
        protected double width;
        public Rectnangle(double l, double w)
        {
            length = l;
            width = w;

            Console.WriteLine("Rectnangle 构造方法{0}{1}",length, width);
        }
    }

    class SubRectangle:Rectnangle
    {
        // base(); 向父类构造函数传递相同的参数
        public SubRectangle(double l, double w) :base(l, w)
        {
            Console.WriteLine("SubRectnangle 构造方法{0}{1}", l, w);
        }
    }

 

public, protected, protected internal,
private注明持续时父类方法的可访问性.

 

多态

①.静态多态性:三个函数在编写翻译时才规定

二.动态多态性:三个函数在运营时才分明

 

Public(公共的) 访问修饰符

Public
访问修饰符允许三个类将其成员变量和成员函数暴露给其余的函数和指标。任何国有成员可以被表面包车型客车类访问

上边是个小例子

using System;

namespace ConsoleApp1
{
    class Rectangle
    {
        public double length { get; set; }
        public double width { get; set; }

        public double Getarea()
        {
            return length * width;
        }

        public void Display()
        {
            Console.WriteLine($"长度:{length}");
            Console.WriteLine($"宽度:{width}");
            Console.WriteLine($"面积:{Getarea()}");
        }
    }




    class Program
    {
        static void Main(string[] args)
        {
            Rectangle rectangle = new Rectangle();
            rectangle.width = 55.5;
            rectangle.length = 12.32;
            rectangle.Getarea();
            rectangle.Display();
            Console.ReadKey(true);
        }
    }
}

 

当上面的代码被编写翻译和进行时,它会时有产生下列结果:

长度:12.32
宽度: 55.5 
面积: 683.76

在上面的实例中,成员变量 length 和 width
被声称为 public,所以它们能够被函数 Main() 使用 Rectangle
类的实例  rectangle 访问。

分子函数 Display() 和 GetArea() 可以直接待上访问那几个变量。

成员函数 Display() 也被声称为 public,所以它也能被 Main() 使用
Rectangle 类的实例 rectangle 访问。

接口

概念:把集体实例方法和质量组合起来,以封装特定成效的3个成团

接口申明:使用首要字interface,接口评释缺省为 public 类型

实例:

 public interface car
    {
        void showName(double a);
        void showAge();
    }

    // 接口实现
    class aodi : car
    {
        public void showName(double a)
        {

        }

        public void showAge()
        {

        }
    }

 


Private(私有的) 访问修饰符

Private
访问修饰符允许多少个类将其成员变量和成员函数对其余的函数和指标开始展览隐蔽。唯有同二个类中的函数能够访问它的村办成员。就算是类的实例也不能够访问它的个体成员。

using System;

namespace ConsoleApp1
{
    class Rectangle
    {
        private double length { get; set; }
        private double width { get; set; }

        public void Acceptdetails()
        {
            Console.WriteLine("请输入长度:");
            length = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入宽度:");
            width = Convert.ToDouble(Console.ReadLine());
        }

        public double Getarea()
        {
            return length * width;
        }

        public void Display()
        {
            Console.WriteLine($"长度:{length}");
            Console.WriteLine($"宽度:{width}");
            Console.WriteLine($"面积:{Getarea()}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Rectangle rectangle = new Rectangle();
            rectangle.Getarea();
            rectangle.Display();
            Console.ReadKey(true);
        }
    }
}

在上边的实例中,成员变量 length 和 width
被声称为 private,所以它们无法被函数 Main() 访问。

分子函数 AcceptDetails() 和 Display() 能够访问这一个变量。

出于成员函数 AcceptDetails() 和 Display() 被声称为 public,所以它们得以被 Main() 使用
Rectangle 类的实例 rectangle 访问。

那一段讲的是private 而不是public
所以请认真看那多少个访问修饰符,小编先是次看的时候也看错了。所以请认真对照!

运算符重载

class Rectnangle
    {
        public double length;
        public double width;


        public Rectnangle(double l, double w)
        {
            length = l;
            width = w;

            Console.WriteLine("Rectnangle 构造方法{0}{1}",length, width);
        }

       // 重载+号运算符,当两个rectnangle对象相加时,就会执行这里
        public static Rectnangle operator+ (Rectnangle a, Rectnangle b)
        {
            Rectnangle rectnagle = new Rectnangle(10, 20);
            rectnagle.length = a.length + b.length;
            rectnagle.width = a.width + b.width;            
            return rectnagle;

        }
    }

static void main(string[] args){
    Rectnangle rectna1 = new Rectnangle(10, 20);
            Rectnangle rectna2 = new Rectnangle(10, 20);
            // 执行运算符重载
            Rectnangle rectna3 = rectna1 + rectna2;
}

 

Protected 访问修饰符

Protected
访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于达成持续。
放到后续的章节详细谈论这么些。 

msdn的诠释如下:internal指的是同五个程序集,内部成员和品种才是能够访问的.内部访问平常用于基于组件的开发,因为它使一组组件可以以个人格局开始展览同盟,而无需向应用程序代码的其余部分公开

Internal 访问修饰符

Internal
访问表明符允许一个类将其成员变量和成员函数揭破给当下先后中的其余函数和目的。

换句话说,带有 internal
访问修饰符的 任何成员 能够被定义在该成员所定义的应用程序内的其余类或情势访问。 

using System;

namespace RectangleDemo 
{
    class Rectangle
    {
        //成员变量
        internal double length;
        internal double width;

        double GetArea()
        {
            return length * width;
        }
       public void Display()
        {
            Console.WriteLine("长度: {0}", length);
            Console.WriteLine("宽度: {0}", width);
            Console.WriteLine("面积: {0}", GetArea());
        }
    }   
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

当上边的代码被编写翻译和执行时,它会发生下列结果:

长度: 4.5
宽度: 3.5
面积: 15.75

在上边包车型大巴实例中,请小心成员函数 GetArea() 注脚的时候不包罗其它访问修饰符。如若没有点名访问修饰符,则接纳类成员的私下认可访问修饰符,即为 private

四个成员或项目只可以有三个造访修饰符,使用 protectedinternal 组合时除了。

Protected Internal 访问修饰符

Protected Internal
访问修饰符允许在本类,派生类或许隐含该类的程序集中走访。那也被用来落到实处持续。 
 

命名空间上不允许行使访问修饰符。命名空间未有访问限制。

基于产生成员声称的上下文,只同意一些证明的可访问性。假如在成员声称中未钦赐访问修饰符,则应用暗中同意的可访问性。

不嵌套在别的门类中的一级类型的可访问性只可以是 internal 或
public。那一个项指标默承认访问性是 internal。

嵌套类型是任何品类的积极分子,它们能够拥有下表所示的宣示的可访问性。

 

 

属于 默认的成员可访问性 该成员允许的声明的可访问性

enum

public

class

private

public

protected

internal

private

protected internal

interface

public

struct

private

public

internal

private

 

 

相关文章

网站地图xml地图