我理解的面向对象(一)
1.枚举
//限定变量的取值范围，确定个数 bool 类型可以用枚举，只是.Net内置了bool类型，所以没人这么做
//QQ的在线，隐身。。
static void
{
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
{
int inti = Readint(); //接收函数返回的值
Console.WriteLine(inti);
Console.ReadKey();
}
static int Readint()
{
return 30; //return后跟上函数返回的值
}
(2)没有声明返回值的 void
static void
{
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
{
string s = "Hellow";
Str(s); //按值传递，外部不影响内部的值
Console.WriteLine(s);
Console.ReadKey();
}
static void Str(string strs)
{
strs = "abc";
}
2)如果想影响的话，如何进行？
//参数的前面加上ref 按照引用传递，内部的值影响外部的值。
//①传递字符类型
static void
{
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
{
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
{
SayHellow(123);
Console.ReadKey();
}
static void SayHellow(string a)
{
Console.WriteLine("您好啊！！！");
}
static void SayHellow(int n)
{
Console.WriteLine(102);
}
(6)理解什么是可变参数 以不确定个数的数组方式进行传递的就是可变参数。
★★★可变参数就是参数的
可变参数params 可变参数必须放到最后，即最后一个参数是可变参数
个数不确定的可变参数以数组的形式传递
static void
{
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
{
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
{
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
{
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
{
//父类要先指向子类，才能用抽象的方法进行调用
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
{
//父类要先指向子类，才能用抽象的方法进行调用
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
{
// P1 = 5; 常量不能进行赋值
Console .WriteLine(P1);
M1();
Console .ReadKey();
}
static void M1()
{
Console.WriteLine(P1*2);
}
2)PI.P1 类名.常量名
class Program
{
static void
{
// 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
{
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
{
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
{
St.age = 15;
Console.WriteLine(St.age);
Console.ReadKey();
}
}
static class St
{
public static int age;
}
