我理解的面向对象(一)

1.枚举

//限定变量的取值范围，确定个数 bool 类型可以用枚举，只是.Net内置了bool类型，所以没人这么做

//QQ的在线，隐身。。

static void Main(string[] args)

{

  Gender g = Gender.Fremal;

  Console.WriteLine(g);

  Gender g1 = Gender.Man;

  Console.WriteLine(g1);

Console.ReadKey();

 

}

 

enum Gender { Man,Fremal,Unkown}

 

 

2.函数

//对一堆代码进行重用的一种机制，可能有输入的值（参数），可能有返回的值

返回值： Console.ReadLine(); 读取后有一个返回的值

参数：   Console.WriteLine(Console.ReadLine());

// int i = Convert.ToInt32("123");

(1)有声明返回值的

static void Main(string[] args)

{

   int inti = Readint(); //接收函数返回的值

   Console.WriteLine(inti);

   Console.ReadKey();

}

 

 

static int Readint()

{

   return 30;            //return后跟上函数返回的值

}

 

(2)没有声明返回值的 void

static void Main(string[] args)

{

  int inti = Readint();

  SayHellow();

  Console.WriteLine(inti);

  Console.ReadKey();

}

static void SayHellow()

{

   Console.WriteLine("abc");

   return;

   return 100;     //报错，由于是void所以报错。

}

 

(3)如果我想要通过void返回值，怎么办？

1)参数是字符类型string

static void Main(string[] args)

{

   string s = "Hellow";

   Str(s);                 //按值传递，外部不影响内部的值

   Console.WriteLine(s);

   Console.ReadKey();

}

 

static void Str(string strs)

{

  strs = "abc";

}

 

 

2)如果想影响的话，如何进行？

//参数的前面加上ref 按照引用传递，内部的值影响外部的值。

//①传递字符类型  

static void Main(string[] args)

{

     string s = "Hellow";

     string s1 = Str(ref s);

     Console.WriteLine(s1);

     Console.ReadKey();

}

 

static string Str( ref string strs)

{

     strs = "abc";

     return strs;

}

 

 

 

 

 

//②传递int类型

static void Main(string[] args)

{

  int a = 100;

  SayHellow(a);  // void—int 不能用隐式转换，必须显示转换.

  Console.WriteLine(a);

  Console.ReadKey();

}

 

      

static void SayHellow(int j)

{

    j = 10;

 }

 

(4) 下列关于构造函数的描述正确的是（c）理解构造函数和函数重载的区别

a)构造函数可以声明返回类型。//构造函数连返回值都没有，如何声明返回类型？

b)构造函数不可以用private修饰

c)构造函数必须与类名相同    //这个是对的。

d)构造函数不能带参数 //没有参数和不能带参数是两回事

 

class A

{

   public A()

    {

    Console.WriteLine("钩爪子");

    }

 

   

}

 

 

★★★首先理解如何构造函数（构造函数和函数重载不是一回事，构造函数是名称和类名一样的特殊函数

而函数重载是几个相同函数名使用了一些规则后，可以同时存在）

 

构造函数是用来创建对象的特殊函数，函数名和类名一样，没有返回值，连void都不用

构造函数可以有参数，默认情况下是没有参数的构造函数，记住没有没有参数和不能有参数是两回事

 

 

 

 

(5)函数的重载，就是函数的重名，

//只有参数的类型、顺序不一致才能函数重名，函数返回值类型一致与否没关系

//构成重载的条件：参数类型不同或者参数个数不同（不严谨的）,与返回值无关。

(1)static void Main(string[] args)

{

  SayHellow(123);

  Console.ReadKey();

}

 

 

static void SayHellow(string  a)

{

  Console.WriteLine("您好啊！！！");

}

 

 

static void SayHellow(int n)

{

Console.WriteLine(102);

}

 

 

(6)理解什么是可变参数 以不确定个数的数组方式进行传递的就是可变参数。

★★★可变参数就是参数的

可变参数params 可变参数必须放到最后，即最后一个参数是可变参数

个数不确定的可变参数以数组的形式传递

static void Main(string[] args)

        {

 

 

            Inta(10, "11", "22", "33", "44"); 

 

 

            Console.ReadKey();

 

        }

static void Inta(int i, params string[] s)    //可变参数必须放到最后一位，因为确定的参数传递完后，剩下的都是可变参数，否则则无法进行确定。

        {

            foreach (string a in s)

                Console.WriteLine(a);

            Console.WriteLine(i);

 

        }

(7)如何理解对象的引用

int datetime,bool,char等类型都属于值类型(ValueType),赋值的时候是传递拷贝

普通的对象则是引用类型，赋值的时候是传递引用。我指向谁，兄弟你也来指向。

★★一个对象会占很大的内存，是大家共用一份。

3.如何理解 类的概念？抽象、摸不到的 而对应的具体的是对象。

类是个抽象的，对一些具有相同特征事物的一个抽象，比如一个班有同学，是一个抽象，具体到某

一个人是对象，笔记本电脑就是一个类，具体某一个人的笔记本电脑是对象。

类不占内存，对象才占内存。

static void Main(string[] args)

{

   Person per = new Person();

   per.name = "张三";

   per.age = 25;

   per.height = 180;

   Console.WriteLine("姓名为：{0},年龄为:{1},身高为{2}CM", per.name, per.age, per.height);

   Console.ReadKey();

 

}

   

 

class Person

{

    public string name { get; set; }

    public int age { get; set; }

    public int height { get; set; }

}

4.如何不使用Public 声明字段，被调用？

为什么要用属性来声明，是为了在类中控制非法或合法值

而用public字段则无法进行合法值的判断

属性不会存储值，而是由相应的字段保存值

属性后不要加()

 

//用简写方式不能只有get或者只有set。不合理

//public int Height

//{

//   get

//}

 

 

★★

a.SetAge(20);

Console.WriteLine(a.GetAge());

public int GetAge()

{

   return age;

}

public void SetAge(int _age)

{

  this.age = _age;

}

 

 

★★也可以这样调用类得方法

int t = a.SetAge(40);

Console.WriteLine(t);

public int SetAge(int _age)

{

   if (_age > 30)

   this.age = _age;

   else

   {

     this.age = 100;

   }

     return this.age;

}

 

(1)可以用字段来接收属性设置的值，并进行返回

private string name1;

public string Name1

{

     get

     {

       return this.name1;

     }

           

    set

     {

       value = "理解万岁";

       this.name1 = value; //字段的值接收方法的值，可以对方法进行设置

     }

 

}

 

(2)先通过方法进行更改，然后再通过属性进行返回值的操作。

p.giveName("张三"); //先把值传递给方法，然后再进行接收

Console.WriteLine(p.Name); p.属性名

private string name;

        public string Name     //属性再去接收方法赋予字段里的值

        {

 

            get

            {

                return this.name;

            }

        }

 

public void vname(string sname)  //先接收传过来的值，然后进行修改 字段里接收方法赋予的值

        {

            if (sname == "张三")

            {

                sname = "李四";

                this.name = sname;

            }

        }

 

5.如何理解继承?

(1)简单的 子类继承父类，其实也就是子类指向子类继承父类的字段，属性，方法。

class Progra

{

    static void Main(string[] args)

     {

        B b = new B();

        b.Say();

        Console.ReadKey();

    }

}

 

class A

{

        public string name { get; set; }

 

        public int age { get; set; }

 

public void Say()

        {

            Console.WriteLine("您好啊");

 }

}

class B : A{    }

(2)如果想让父类指向子类，该如何做？

class Progra

{

    static void Main(string[] args)

     {

        A a = new A();

        B b =(B)a; //这样就会报错，如果不想报错的话，可以用as    B b =a as B;

       // B b1 = a as B;

        Console.ReadKey();

    }

}

(3)现在我想让父类调用子类里的方法，如何进行操作？要进行方法重写

★★使用虚方法，就是使用 virtual 关键字来进行修饰，从而达到“多态”的目的

方便以后对代码进行进一步完善。

★★子类可以不进行重写。

class Program

{

   static void Main(string[] args)

    {

            //父类要先指向子类，才能用抽象的方法进行调用

            A a = new B();

            a.Say();

 

            Console.ReadKey();

      }

}

 

 

class A

{

      public string name { get; set; }

      public int age { get; set; }

 

 

      public virtual void Say()

      {

         Console.WriteLine("001");

      }

}

 

(4)除了使用上面的方法，还有没有使子类进行方法重写的呢？

答案是有的，可以使用抽象的方法，进行子类的重写，abstract

★★★就是为了子类去继承，不能new，不能实例化的

static void Main(string[] args)

{

     //父类要先指向子类，才能用抽象的方法进行调用

        A a = new B();

        a.Say();

 

        Console.ReadKey();

}

   

 

abstract class A

{

       public string name { get; set; }

       public int age { get; set; }

       abstract public void Say();  //★★★这里声明抽象的，那么类也要是抽象的。

 

}

 

class B : A

{

        public override void Say()

        {

            Console.WriteLine("子类说Say");

            this.name = "张三丰";

            Console.WriteLine("我叫张三丰");

        }

}

 

 

 

 

 

(5)★★父类用  abstract 子类必须进行重写  子类也不能用new。

★★父类用virtual 子类可以用new不进行重写,那么就只能自己使用，不允许调用和继承。

 

 

(6)如果父类声明一个属性或字段，只想在本类中进行使用，不允许别人进行访问的话，可以用private

★★声明private的话，子类也不允许访问，继承。

那么如果只想子类进行继承，不允许别人访问的话，用用protected,相当于遗产保护。

protected void Name()

{

  Console.WriteLine("输出姓名");

}

 

6.如何理解成员访问级别

(1)理解什么是成员？

★★字段、方法、属性  都可以叫做类的成员  都需要定义访问级别

访问级别的用处在于控制成员在哪些地方可以被访问，这样达到面向对象中“封装”的目的。

public（任何地方都可以访问）；

private（默认级别。只能由本类中的成员访问）

 

(1)

p.Height = 180;

 

class Person

{

        private string name { get; set; }

        public int age { get; set; }

       

 

        private int height;//外部程序无法调用private 声明的height

        public int Height

        {

            get

            {

                return this.height;    //内部使用的话，需要

            }

            set

            {

 

                this.height = Height;

            }

 

        }

}

 

 

7.如何理解全局变量(static)与变量，常量之间的区别。

变量与常量的区别

(1)常量

1)对于任何的对象的值都不变，所以不需要通过对象来调用，直接通过类名来引用。   类名.常量名

常量一般全部大写，不能进行赋值。

private const double P1 = 3.14;

static void Main(string[] args)

{

   // P1 = 5; 常量不能进行赋值        

   Console .WriteLine(P1);

   M1();

   Console .ReadKey();

}

 

 

 

 

static void M1()

{

   Console.WriteLine(P1*2);    

}

 

 

2)PI.P1 类名.常量名

class Program

{

static void Main(string[] args)

    {

       // P1 = 5; 常量不能进行赋值

       Console.WriteLine(PI.P1);

       M1();

       Console.ReadKey();

}

static void M1()

     {

    Console.WriteLine(PI.P1 * 2);

}

}

 

class PI

{

 public const double P1 = 3.14;

}

 

(3)变量 程序易读，一个地方变了，所有地方都变了。

1)以字母或者下划线_开头，后面可以是任意字母，数字或下划线_,但不能是关键字（如class,new,int 在VS中蓝色的为关键字）。

int a3=9;

int _a3=9;

 

2)变量在声明后才能使用

int i3=10;

Console.WriteLine(i3);

变量在使用之前必须赋值

int i1;

i1 = 10;

Console.WriteLine(i1);

 

 

 

 

3)变量可以任意进行赋值，如需通过对象来调用的话，那么需要调用类里的属性或方法才能进行使用。

static void Main(string[] args)

{

    Person p1 = new Person();

    p1.age = 25;

    p1.height = 175;

    p1.Name = "张三丰";

   

    Console.WriteLine("姓名为：{0},年龄为:{1},身高为：{2}",p1.Name,p1.age,p1.height);

    Console.ReadKey();

 

}

  

 

class Person

{

  public int age;     //声明名称为age的变量

  public int height;

 

  public string Name  //声明一个名称为Name的属性

   {

     get;

     set;

   }

}

 

//或者这样声明也是可以的。

class Person

{

        public int age;

        public int height;

 

        private string name;

        public string Name  //声明一个名称为Name的属性

        {

          get{ return this.name; }

set{ this.name = value; }

        }

}

 

(4)全局变量static 调用非static成员必须通过对象

class Program

{

  static void Main(string[] args)

  {

    St a = new St();

    a.Hellow();

    St.Say();//静态static 的只能 类名.方法名

    Console.ReadKey();

}

}

 

class St

{

    public void Hellow()

      {    }

static public void Say()

      {    }

}

★★没有对象，即方法名前声明了 static ，那么只能类名.方法名,

★★如果有对象，即方法名前没有声明 static,那么要用一个变量指向类，然后用变量名.方法名

class Program

{

   static void Main(string[] args)

   {

     St.age = 15;

     Console.WriteLine(St.age);

     Console.ReadKey();

    }

}

 

static class St

{

     public static int age;

}

转载于:https://www.cnblogs.com/dmh365/archive/2011/04/18/2019558.html