做客修饰符，面向对象

学到封装就会想到访问修饰符，提及走访修饰符，就会想到访问等级，或许说是访问能力的大小。当然也不可缺少暗许的拜访类型。

封装 被定义为”把三个或三个品类封闭在一个大体的要么逻辑的包中”。在面向对象程序设计方法论中，封装是为着幸免对贯彻细节的走访。

析构函数和构造函数

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 只幸好基类中央银行使. 继承的,实例后的都不行以.

封装 被定义为”把二个或八个品类封闭在三个大体的照旧逻辑的包中”。在面向对象程序设计方法论中，封装是为着防患对贯彻细节的拜访。

C#
封装依照实际的需求，设置使用者的访问权限，并经过 做客修饰符 来实现。

Public 修饰符

Public
访问修饰符允许2个类将其成员变量和成员函数暴光给此外函数和目的。任何国有成员能够被外表访问

 

虚幻和包装是面向对象程序设计的相关特性。抽象允许相关新闻可视化，封装则使开发者落到实处所需级别的空洞。

一个 走访修饰符 定义了1个类成员的限定和可知性。C#
帮衬的走访修饰符如下所示：

Private 修饰符

Private
访问修饰符允许1个类将其成员变量和成员函数对别的函数和指标开展隐蔽。只有同3个类中的函数能够访问他的民用从分子

 1class Vehicle
 2{
 3 public int wheel; //公有变量wheel,
 4 private float weight; //私有变量weight
 5 public void F()
 6 {
 7    wheel=四;   //合法调用
 8    weight=二.2;  //合法调用. 
 9 }
10}
11
12class Train
13{
14 public int num;   //公有变量 num
15 private int passenger; //私有变量passenger
16 public void F()
17 {
18    num=4; //合法
19    passenger=100; //合法
20    Vehicle v= new Vehicle();
21    v.wheel=四;  //合法, 调用到Vehicle的类中变量.
22    v.weight=贰.二;  //非法. 因为vehicle中的weight是个人的.
23 } 
24}
25
26class Car:Vehicle  //car的类继承自vehicle类.
27{
做客修饰符，面向对象。28 int passenger;  
29 public void K()
30 {   
31   wheel=6;  //合法.
32   weight = 四.2;  //违规. //因为vehicle里面包车型大巴是私有.
33 }
34}

C#
封装根据实际的需求，设置使用者的访问权限，并通过 做客修饰符 来实现。

• Public：全部指标都得以访问；
• Private：对象自我在对象内部能够访问；
• Protected：唯有该类对象及其子类对象足以访问
• Internal：同1个主次集的对象足以访问；
• Protected internal：四个先后集内的对象，恐怕该类对象及其子类可以访问

Protected 修饰符

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

 

一个 走访修饰符 定义了3个类成员的界定和可知性。C#
帮助的拜访修饰符如下所示：

若果没有点名访问修饰符，则选拔类成员的暗许访问修饰符，即为 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一类的实例
a 访问到。

Protected internal 修饰符

Protected internal
修饰符允许二个类将其成员变量和成员航沪深对相同应用程序诶的子类以外的别样类对象和函数举办隐蔽

• Public，选用它的章程是在成员声称中回顾 public 修饰符。public
  的直观含义是“访问不受限制”。
• Protected，选取它的方法是在成员声称中总结 protected
  修饰符。protected
  的直观含义是“访问范围限定于它所属的类或从该类派生的品类”。
• Internal，采用它的措施是在成员声称中包涵 internal
  修饰符。internal 的直观含义是“访问范围界定于此程序”。
• Protected
  internal（意为受保证或内部的），选取它的点子是在成员声称中总结
  protected 和 internal 修饰符。protected internal
  的直观含义是“访问范围限制于此程序或这些由它所属的类派生的花色”。
• Private，选取它的方法是在成员声称中包含 private 修饰符。private
  的直观含义是“访问范围限定于它所属的项目”。

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

Private 访问修饰符

唯有同多少个类中的函数能够访问它的民用成员，就算是类的实例也不能够访问它的私家成员。假设将方面程序类
program第11中学 a,b前的扬言改为 private
，在用类的实例对它们进行访问时会出现上边提醒：

 

在那种申明下，在别的类中为了选拔（操作）这个数值，能够在那么些数值所在的类下编写能够操作这几个数值的函数，然后在其他类中访问这个函数，程序如下：

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

　　

方法

• 定义
• 调用

声美素佳儿（Friso）个成员时所能采纳的已注解可访问性的项目，依赖于该成员声称出现处的上下文。别的，当成员声称不带有别的访问修饰符时，评释发出处的光景文仲为该成员选拔叁个默许的已注明可访问性。

程式集：IL+元数据

Protected 访问修饰符

Protected
访问修饰符允许子类访问它的基类的积极分子变量和分子函数。这样有助于达成连续。

定义

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

• 取名空间隐式地有所 public
  已扬言可访问性。在命名空间证明中不允许接纳访问修饰符。
• 编写翻译单元或命名空间中申明的品种能够有所 public 或 internal
  已扬言可访问性，暗许的已申明可访问性为 internal。
• 类成员可拥有种种已扬言可访问性中的任何1种，暗中同意为 private
  已扬言可访问性。（请小心，表明为类成员的档次可具有七种已扬言可访问性中的任何1种，而证明为命名空间成员的种类只好拥有
  public 或 internal 已表明可访问性。）
• 布局成员能够享有 public、internal 或 private
  已注脚可访问性并暗许为 private
  已申明可访问性，那是因为结构是隐式地密封的。结构的分子固然在此布局中表明的（相当于说，不是由该协会从它的基类中继续的）无法具备
  protected 或 protected internal
  已扬言可访问性。（请留意，注脚为结构成员的连串可具有
  public、internal 或 private
  已申明可访问性，而表明为命名空间成员的门类只可以拥有 public 或
  internal 已注脚可访问性。）
• 接口成员隐式地有所 public
  已注明可访问性。在接口成员声称中不允许使用访问修饰符。
• 枚举成员隐式地有所 public
  已扬言可访问性。在枚举成员声称中不相同意利用访问修饰符。

假使说命名空间是类库的逻辑组织格局，那么程序集正是类库的大体协会格局。唯有同时钦命项目所在的命名空间及贯彻该项目标程序集，才能完全限定该品种。（摘抄自《领会.NET核心技术–原来与架构》 电子工业出版社）

Internal 访问修饰符

Internal
访问表达符允许二个类将其成员变量和分子函数暴露给当下程序中的其余函数和对象。换句话说，带有
internal
访问修饰符的其余成员可以被定义在该成员所定义的应用程序内的别的类或格局访问。

 

调用

应用.语法调用3个类的法子

 

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

譬如说大家要用A类，则须要把带有A类的程序集(即*.DLL）引用到该工程中（物理）；而在先后中要证明A类的命名空间(逻辑）。

Protected Internal 访问修饰符

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

　　

 

继承

C#不支持多两次三番，但足以动用接口来兑现多再三再四。用C#创办3个派生类的语法如下：

<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证明持续时父类方法的可访问性.

 

多态

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

二.动态多态性：贰个函数在运作时才规定

 

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 访问。

接口

概念：把公家实例方法和性子组合起来，以封装特定功能的三个会面

接口注脚：使用首要字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
访问修饰符允许在本类,派生类只怕隐含该类的顺序集中走访。那也被用于落到实处三番五次。 
 

取名空间上不容许使用访问修饰符。命名空间未有访问限制。

据说产生成员声称的上下文，只允许1些评释的可访问性。如若在成员声称中未钦命访问修饰符，则动用暗中同意的可访问性。

不嵌套在其余种类中的一流类型的可访问性只可以是 internal 或
public。这个类其余默承认访问性是 internal。

嵌套类型是其余品种的分子，它们能够具备下表所示的注解的可访问性。

 

 

属于	默认的成员可访问性	该成员允许的声明的可访问性
enum	public	无
class	private	public protected internal private protected internal
interface	public	无
struct	private	public internal private