class中的东西和继承、多态的概念

class中的private、public、protected

最近看了一些视频顺便总结一下class中的这几个类型以及继承

public：

在C++和C#中类的用法，语法是差不多的。当变量，函数之类的对象放在public中时，说明这些变量和函数是可以被外界访问的，自己本身可以使用，也可以在其他函数中调用。

private：

顾名思义，就是私有的，只有自己本身可以调用，其他外来的函数，是不能访问到的，是属于class中内部的。

protected：

在这个区域的东西，能够访问的就是自己本身-父类，还有衍生出来的子类。

在C++代码例子如下：

#include<iostream>
using namespace std;
class A{//定义一个父类
	public:
		A():i(0){
			cout << "A::A()" << endl;
		}
		~A(){
			cout << "~A::A()" << endl;
		}//以上是构造函数和析构函数
		/*构造函数我认为主要是用于对一些数值进行初始化，当然没有这个函数存在也可以，
		然后析构函数我认为就是用来回收内存的，就是当它整个类的使用过后，回收其使用的内存*/
	protected://表示只有它自己和子类可以访问
		void set(int ii) {
			i=ii;
			cout << i << endl;
		}
	private://只有自己才能够访问的，可以防止外部对其内部数据的修改。
		int i;// i是私有的，只有父类可以调用；
};
class B : public A{//B为A的子类-也是和继承有关
	public :
		void f(){
			set(20);//可以使用
		//	i=30;
		} 

};
/*在调用B类时,B类继承了A所有的部分，当然不包括private部分
B可以在A的基础上添加一些自己所需要的性质，因此在调用B时，可以调用A的函数*/
int main()
{
	B b;//定义一个B类型
	int n;
	cin >> n;
	//b.set(n);//此时在main（）函数中不能调用 因为set（）函数只能在B中使用，
	b.f();//B类函数的调用
	return 0;
}

C#代码例子：

class A
    {
        public int c;//所有都可访问
        public void print() { Console.WriteLine("class A :: print()"); }//定义函数
        public A()
        {
            this.d = 10;//初始化定义
            Console.WriteLine("A的构造函数");
        }
        ~A()
        {
            Console.WriteLine("析构函数");
        }
        protected void f()//只有A和B可以访问
        {
            print();
            Console.WriteLine(d + e);
        }
        private int d, e=20;//只有A可以访问
    }
    class B : A//B继承A，B是A的子类
    {
        public void sum(int x, int y)
        {
            Console.WriteLine(x + y);
            f();
        }
        private int i=0;//B的私有变量
    }
    class Program
    {
        static void Main(string[] args)
        {
            A a=new A();//调用
            B b=new B();
            a.print();
            b.sum(1, 1);
        }
    }

继承：

继承的例子也在以上代码中，主要是父类的派生。继承允许我们根据一个类来定义另一个类来定义一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

abstract：

abstract可以用来修饰类,方法,属性,索引器和时间,这里不包括字段. 使用abstrac修饰的类,该类只能作为其他类的基类,不能实例化,而且abstract修饰的成员在派生类中必须全部实现,不允许部分实现,否则编译异常.C#中的abstract类不能被实例化，他只提供其他类的继承的接口。我自己理解成它就是作为子类而存在的，给其他class调用。目测很抽象。

例子：

abstract class MyAbs
    {
        public void HELLO()
        {
            Console.WriteLine("hello world");
        }
    }
    class MyClass : MyAbs
    {
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass a = new MyClass();
            a.HELLO();
           //MyAbs b = new  MyAbs();这是无法建立的
        }
    }

多态性：

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。可以理解成出现函数同名的情况，但是参数类型，数量不同，出现不同性质的函数。

代码例子：

using System;
namespace PolymorphismApplication
{
   class Printdata
   {
      void print(int i)//不同的参数类型
      {
         Console.WriteLine("Printing int: {0}", i );
      }
      void print(double f)
      {
         Console.WriteLine("Printing float: {0}" , f);
      }
      void print(string s)
      {
         Console.WriteLine("Printing string: {0}", s);
      }
      static void Main(string[] args)
      {
         Printdata p = new Printdata();
         // 调用 print 来打印整数
         p.print(5);
         // 调用 print 来打印浮点数
         p.print(500.263);
         // 调用 print 来打印字符串
         p.print("Hello C++");
         Console.ReadKey();
      }
   }
}

目前感觉一些部分懵逼中

多态性详细分类

在此望：路过大佬，大牛，指导