面向对象（三大特性）

面向对象
1、类：众多对象抽象出来的
2、对象：类实例化出来的

3、类的定义
关键字 class

4、类里面包含
成员属性
成员变量
成员方法

5、面向对象三大特性
（1）封装
目的：保护类，让类更加安全
做法：让类里面的成员变量变为私有的，做相应的方法或者属性去间接操作成员变量

一、封装成员变量来间接访问类里面的成员变量
例子：
class ren
{
private string name;
//取name的值
public string getname()
{
return name;
}

//给name赋值
public void setname(string n)
{
name = n;
}
}
这样做的目的是可以在输入时规定输入的方位，例如
class ren
{
private int age;
//取name的值
public int getnage()
{
return age;
}

//给name赋值
public void setage(int a)
{
if (age >= 18 && age <= 50)
{
age = a;
}
else
{
age = 18;
}
}
}

--延伸
访问修饰符
private 私有的 --只在该类中可以访问
例：C#中
private void show()
{}

protected 受保护的 --只能在该类和它的子类中访问

public 共有的 --在任何地方都可以访问

二、使用成员属性来间接访问类里面的成员变量
要使用成员属性在命名是采用下划线开头,并且首字母大写，例：_Name

C#中独有
选中要使用属性的成员变量名所在行，右键--重构--封装字段（或使用快捷键Ctrl+R+E）
可以加入控制
注意：变量名和属性名不能重复，这是成员变量要使用命名规则的原因
class student
{
private string _Name;

public string Name
{
get { return _Name; }
set { _Name = value; }
}
private int _Age;

public int Age
{
get { return _Age; }
set 
{
if (Age >= 18 && Age <= 50)
{
_Age = value;
}
else
{
_Age = 18;
}
}
}

}
也可直接输入代码，并且简写。但是简写方法不能对值进行控制
class student
{
private string _Name;

public string Name{get;set;}

}

属性和成员变量在使用上是一样的，可以之间点出。例
student s= new student;
s.name="张三"

 

构造方法（函数）：
作用：造对象所要调用的方法，用于创建对象

每一个类都有一个构造方法，不过写不写都有，不写看不到

特殊性：
（1）写法特殊
对类写构造方法，方法名必须是类名
（2）执行时间特殊
在实例化对象时执行

可以实现对成员进行初始化
student S=new student("男");

class student
{
//构造函数
public student(string s)
{
_Sex = s;

}

private string _Sex;

public string Sex
{
get { return _Sex; }
set { _Sex = value; }

}
}

 

 

（2）继承

1、使用面向对象
研究什么内容就做一个什么样的类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 面向对象2
{
class Program
{
static void Main(string[] args)
{
yuan y1 = new yuan();
y1.Banjing = 10;
yuan y2 = new yuan();
y2.Banjing = 5;

double mj = y1.mianji() - y2.mianji();

Console.WriteLine(mj.ToString());
Console.ReadLine();

}
}

class yuan
{

private int _Banjing;

public int Banjing
{
get { return _Banjing; }
set { _Banjing = value; }
}

public double mianji()
{
return _Banjing * _Banjing * 3.14;
}

public double ZhouChang()
{
return 2 * 3.14 * _Banjing;
}

}

}

2、函数重载（编译多态）
在一个类里面通过对函数的重载，实现多个功能

class Ren
{
public string Show()
{
return "没有参数";
}
public string Show(int a)
{
return "有个整形参数";
}
public string Show(string a)
{
return "有一个字符串类型的参数";
}
//函数四要素：返回类型，函数名，参数列表，函数体
//区分同名函数可以通过参数列表来区分
//函数重载的必要条件，函数名要相同，参数的个性或者参数 
类型不同
}

3、this
关键字
虽然写在类里面，但不是属于该类的，然是属于该对象的
在C#语言中this可以省略，其他语言不可以省略。但是如果有一个方法 
，形参名字和成员名字重复，这时候在调用该对象里面的成员是需要加 
this关键字

例子：

class Program
{
static void Main(string[] args)
{ 
Ren r =new Ren();
r.ShowName();

}
}

class Ren
{
//this 在该类里面带面该对象
//<div οnclick="show(this)"></div>--这次句中相当于把这 
个div元素传过去

private string _Name;

public string Name
{
get { return _Name; }
set { _Name = value; }
}

public string ShowName()
{
return "该人员名称为：" + this._Name;
}
}

在例子中，this代表Main中实例化r

4、is关键字
判断变量是不是属于某个类

if(变量 is 类型)
{
语句;
}

5、as关键字
转换类型（只能转换兼容类型，可以将子类对象转换为父类对象）

6、继承

子类可以继承父类的一切。
特点：单继承
一个子类只能有一个父类
一个父类可以有多个子类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 面向对象3
{
class Program
{
static void Main(string[] args)
{
China a = new China();
a.Age = 0;

a.Speak();

}
}

class Ren
{
private string _Name;

public string Name
{
get { return _Name; }
set { _Name = value; }
}

private int _Age;

public int Age
{
get { return _Age; }
set { _Age = value; }
}

public string Speak()
{
return "人类正在说话";
}

}

class China:Ren
{
public string Eat()
{
return base.Name+"用筷子吃饭";
}
}

class American : Ren
{
public string Eat()
{
return "用刀叉吃饭";
}
}

}

base关键字：在子类代表父类对象，用法和this关键字相同。可以调用父类的属性和方法
如果父类有构造方法，那么子类也要有构造方法，如果父类构造需要参数，那么子类构造也必须有相应的参数
子类构造后面可以通过base调用父类的构造方法
public China(string m): base(m)
{

}

C#特殊点：所有类的祖先都是object类

 

 

 

 

 

（3）多态

转载于:https://www.cnblogs.com/zl1121102942/p/5794289.html