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

class中的private、public、protected

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

public:

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

private:

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

protected:

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

在C++代码例子如下:

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

目前感觉一些部分懵逼中

多态性详细分类

在此望:路过大佬,大牛,指导

转载于:https://www.cnblogs.com/q1076452761/p/6372327.html

你可能感兴趣的:(class中的东西和继承、多态的概念)