伟德体育官网 1

面向对象,面向对象之三大特点

学到封装伟德体育官网,就能够想到访谈修饰符,提起拜望修饰符,就能够想到访问等级,只怕说是访谈工夫的分寸。当然也不可缺少默许的拜会类型。

封装 被定义为”把一个或多少个品种密闭在叁个物理的要么逻辑的包中”。在面向对象程序设计方法论中,封装是为着幸免对得以完成细节的会见。

析构函数和布局函数

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();
        }
    }
}

 

  1. C# 方法暗中同意访问等第 : private
    (私有的) 
  2. C# 类暗许访谈等第 : internal   
    (内部的) 

空洞和包裹是面向对象程序设计的相干脾气。抽象允许相关音讯可视化,封装则使开采者完结所需品级的悬空

封装

拜候修饰符:

一经未有一点名访谈修饰符,则私下认可是private

  • Public
  • Private
  • Protected
  • Internal
  • Protected internal

封装 被定义为”把一个或五个品类密闭在贰个物理的或许逻辑的包中”。在面向对象程序设计方法论中,封装是为着以免对落实细节的拜谒。

C#
封装依据具体的内需,设置使用者的拜会权限,并经过 做客修饰符 来实现。

Public 修饰符

Public
访谈修饰符允许二个类将其成员变量和分子函数揭露给任何函数和对象。任何集体成员能够被外表访问

空泛和打包是面向对象程序设计的连带天性。抽象允许相关新闻可视化,封装则使开荒者兑现所需等级的抽象

一个 做客修饰符 定义了三个类成员的限量和可以知道性。C#
协理的会见修饰符如下所示:

Private 修饰符

Private
访谈修饰符允许二个类将其成员变量和成员函数对其余函数和对象开展隐蔽。独有同叁个类中的函数能够访谈他的个体从分子

C#
封装依据具体的须求,设置使用者的拜候权限,并因而 做客修饰符 来实现。

  • Public:全部目的都足以访问;
  • Private:对象自己在对象内部能够访问;
  • Protected:唯有该类对象及其子类对象足以访问
  • Internal:同二个程序集的靶子能够访谈;
  • Protected internal:一个主次集内的靶子,恐怕该类对象及其子类能够访谈
Protected 修饰符

Protected 修饰符允许子类访谈他的基类的成员变量和成员函数。这种办法拉动世襲

一个 访谈修饰符 定义了一个类成员的限量和可知性。C#
扶植的探访修饰符如下所示:

假若未有一点点名访谈修饰符,则选择类成员的私下认可访问修饰符,即为 private

Internal 修饰符

Internal 修饰符允许一个类将其成员变量和成员函数揭发给当下前后相继中的别的函数和目的,换句话说,带有访谈Internal
修饰符的别的成员能够被定义在改成员所定义的应用程序内的别的类或方法访问

  • public:全体指标都得以访问;(公共的)
  • private:对象自己在目的内部可以访谈;(私有的)
  • protected:独有该类对象及其子类对象足以访谈;(受保险的)
  • internal:同贰个前后相继集的对象足以访谈;(内部的)
  • protected
    internal:访问限于当前途序集或派生自包涵类的门类。(内部受保证的)

Public 访问修饰符

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

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 program1 中变量和函数被声称为 public,
因而能够被上面包车型地铁program第22中学Main()函数 使用program1类的实例
访问到。

Protected internal 修饰符

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

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

Private 访谈修饰符

除非同一个类中的函数能够访谈它的私人民居房成员,尽管是类的实例也不能够访谈它的个人成员。如若将方面程序类
program1中 a,b前的扬言改为 private
,在用类的实例对它们实行拜候时会现身下边提醒:

伟德体育官网 1

 

在此种注解下,在别的类中为了选拔(操作)这一个数值,能够在这里些数值所在的类下编写能够操作那几个数值的函数,然后在其余类中访问那一个函数,程序如下:

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

  

方法

  • 定义
  • 调用

程式集:IL+元数据

Protected 访谈修饰符

Protected
访谈修饰符允许子类访谈它的基类的分子变量和成员函数。那样有支持达成持续。

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

假设说命名空间是类库的逻辑组织方式,那么程序集正是类库的大要组织格局。唯有同时钦赐项目所在的命名空间及落到实处该项目的程序集,能力完全限制该品种。(摘抄自《精通.NET核心本领–原本与布局》 电子工业出版社)

Internal 访谈修饰符

Internal
访谈表明符允许四个类将其成员变量和分子函数揭破给当下程序中的别的函数和对象。换句话说,带有
internal
访谈修饰符的此外成员能够被定义在该成员所定义的应用程序内的别样类或方式访问。

 

调用

利用.语法调用贰个类的措施

 

诸如我们要用A类,则须求把带有A类的程序集(即*.DLL)援引到该工程中(物理);而在程序中要注解A类的命名空间(逻辑)。

Protected Internal 访问修饰符

Protected Internal
访谈修饰符允许在本类,派生类只怕隐含该类的顺序集中寻访。那也被用于落到实处三番五次。

  

 

继承

C#不扶助多三番两次,但足以动用接口来贯彻多接二连三。用C#创建三个派生类的语法如下:

<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);
        }
    }

 

 

多态

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

2.动态多态性:八个函数在运维时才显著

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
访问修饰符允许子类访谈它的基类的成员变量和分子函数。那样有利于完毕一而再一连。
放到持续的章节详细评论这些。 

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

Protected Internal 访谈修饰符

Protected Internal
访谈修饰符允许在本类,派生类或然隐含该类的顺序聚焦会见。那也被用于贯彻接二连三。 
 

发表评论