进程类:Process
//通过线程打开文件
//ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\Administrator\Desktop\test\1.txt");
//Process.Start(psi);
//也可以使用下面的写法
ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\Administrator\Desktop\test\1.txt");
Process p = new Process();
p.StartInfo = psi;
p.Start();
面向对象:
面向对象的三大特征:封装,继承,多态
封装的好处,就是隐藏具体的细节,从而简化使用的过程
好比手机,我们不需要知道他的内部构成和电路的工作原理,我们只要知道输入手机号,按下拨号键,就可以通话就可以了
继承的好处,代码复用,不用重复的写相同的代码
多态的好处，把不同的子类对象当做父类来看,可以屏蔽不同子类对象之间的差异
写出通用的代码,做出通用的编程,以适应需求的不断变化
类中的成员：字段、属性、方法、构造函数
字段:类中唯一存储数据
属性:保护字段，对字段的取值和赋值进行限定，属性的本质就是两个方法 get() set()
方法:对象的行为
构造函数：初始化对象(给对象的每个属性依次的赋值)，可以有重载。
类当中默认会有一个无参数的构造函数,当你写了一个新的构造函数之后,那个默认的无参数的就被干掉了。
类写好后，我们需要创建这个类的对象，我们管创建这个类的对象的过程称之为类的实例化
/// <summary>
/// 在属性的get方法中做限制
/// </summary>
public string Name
{
get { return _name; }
set
{
if (value != "张三")
{
value = "张三";
}
_name = value;
}
}
private int _age;
/// <summary>
/// 在属性的set方法做限制
/// </summary>
public int Age
{
get
{
if (_age < 0 || _age > 100)
{
return _age = 0;
}
return _age;
}
set { _age = value; }
}
return的作用
在方法中返回要返回的值
立即结束本次方法的执行
//break;//跳出当前循环
//continue; 跳到循环条件进行判断
new的作用
1.创建对象
在堆中开辟空间
在开辟的堆空间中创建对象
调用对象的构造函数
2.在子类中隐藏从父类那里继承过来的成员
this的作用
表示当前类的对象
如果一个类中有多个构造函数的时候,可以显示的调用自己的构造函数
base的作用
在子类中显示的调用父类的构造函数,避免参数的赋值代码多次书写
在子类中调用父类中的重名方法
继承:
好处：减少代码的冗余
子类继承了父类,继承了父类的属性和方法
并没有继承父类的私有字段
也没有继承父类的构造函数,但是会去调用父类中的无参的构造函数
目的是为了能够初始化父类,为了让子类能够调用到父类中的成员
当你在父类中重新写了有参数的构造函数之后，那个无参数的就被干掉了，
此时,子类将无法调用父类的无参构造函数而报错,解决办法：
在父类中重新写一个无参数的构造函数
在子类中显示的调用父类的构造函数 :base
静态和非静态
在一个类中,如果既有静态成员,也有非静态成员,则首先初始化静态成员,并且只初始化一次
不管你有多少个对象,都只初始化一次。
而我们的非静态成员,有多少个对象,就初始化多少次
在整个项目当中静态成员是资源共享的
静态成员只有在整个项目都结束的时候,才释放资源,所以在项目中应该少使用静态成员
里氏转换
子类可以赋值给父类(如果有一个地方需要父类作为参数,我们可以给一个子类代替)
如果这个父类中装的是子类对象，则可以将这个父类强转为子类对象
is:表示类型转换,如果转换成功返回一个true,否则返回false
as:表示类型转换,如果转换成功,则返回对应的对象,否则返回null
访问修饰符
public:公开的公共的,在哪都可以访问到,
internal:只能在当前项目内部访问.在项目的内部,public的权限跟internal是一样的
private:私有的,只能在当前类的内部访问
protected:受保护的,只能在当前类的内部以及该类的子类中访问
protected internal：
修饰符类的访问修饰符：public internal
修饰符类中的成员的访问修饰符：public private internal protected protected internal
注意:子类的访问权限不能高于父类的访问权限
因为子类肯能会暴漏父类的成员
如果父类的访问权限做了限制,肯定是希望父类只在某些情况下使用,其他情况不允许使用
而如果子类继承了父类并且权限比父类高
则外部的程序虽然不能直接访问父类,但是却可以通过子类访问父类的成员,这显然是有违初衷的
所以限制了子类的访问权限不能比父类高
多态:
虚方法:virtual
如果父类需要被实例化
如果父类中的方法需要有实现
虚方法在父类中必须被实现,哪怕是空的实现
虚方法在子类中可以被重写也可以不重写
/// <summary>
/// 父类
/// </summary>
public class RealDuck
{
public virtual void Bark()
{
Console.WriteLine("真的鸭子嘎嘎叫");
}
}
public class MuDuck : RealDuck
{
public override void Bark()
{
Console.WriteLine("木头鸭子吱吱叫");
}
}
public class XPDuck : RealDuck
{
//如果在子类中不对父类进行重写,则下面的方法调用返回的值是【真的鸭子嘎嘎叫】
//这是因为虽然父类rd里面装入的是XPDuck的对象,但是他让然表现出父类的特性
//而无法表现出子类的特性
//RealDuck rd = new XPDuck();
//rd.Bark();
//如果是下面的写法,返回值是【橡皮鸭子唧唧叫】
//这是子类隐藏了父类的Bark方法
//XPDuck xp = new XPDuck();
//xp.Bark();
public void Bark()
{
Console.WriteLine("橡皮鸭子唧唧叫");
}
}
抽象类:abstract
抽象方法不能有任何方法实现,空实现也不行
抽象成员必须包含在抽象类中
由于抽象成员没有任何实现,子类中必须对抽象成员重写
抽象类中可以包含抽象成员,也可以包含实例成员
抽象类不能被static关键字修饰
抽象类不能被实例化
抽象类 的作用就是要被子类继承
/// <summary>
/// 动物类(抽象类)
/// 抽象类可以有实例成员
/// </summary>
public abstract class Animal
{
/// <summary>
/// 抽象类中可以有实例对象
/// </summary>
public string Name
{
get;
set;
}
/// <summary>
/// 动物类的无参构造函数
/// </summary>
public Animal()
{
}
/// <summary>
/// 动物类的有参构造函数
/// </summary>
/// <param name="name"></param>
public Animal(string name)
{
this.Name = name;
}
/// <summary>
/// 抽象类里的抽象方法
/// </summary>
public abstract void Bark();
}
/// <summary>
/// 狗狗类
/// </summary>
public class Dog : Animal
{
public override void Bark()
{
Console.WriteLine("狗狗旺旺的叫");
}
}
/// <summary>
/// 猫咪类
/// </summary>
public class Cat : Animal
{
public override void Bark()
{
Console.WriteLine("猫咪喵喵的叫");
}
}
接口:interface
接口中只能包含方法(函数,属性,事件,索引器)
接口中的成员都不能有实现,空实现也不行
接口不能被实例化
接口中的成员不能有任何访问修饰符,接口默认为public
继承接口的子类必须将接口中的所有成员实现
接口存在的意义:实现了多态
多态的意义:提高程序的可扩展性,最终节省成本,提高效率
/// <summary>
/// 飞的接口
/// </summary>
interface IFlyable
{
void Fly();
}
/// <summary>
/// 鸟的父类
/// </summary>
public class Bird
{
public int Wings
{
get;
set;
}
}
/// <summary>
/// 鹦鹉子类,继承鸟的类和飞行的接口
/// </summary>
public class YingWu : Bird, IFlyable
{
/// <summary>
/// 鹦鹉类自己的飞行方法
/// </summary>
public void Fly()
{
Console.WriteLine("鹦鹉会飞");
}
//显示实现接口的方法
void IFlyable.Fly()
{
Console.WriteLine("接口中的飞方法");
}
}
索引器:
class Program
{
static void Main(string[] args)
{
Person p = new Person();
//在这里赋值的时候其实就是跟索引器里的数组赋值
p[0] = "张三";
p[1] = "李四";
Console.WriteLine(p[0]);
Console.WriteLine(p[1]);
Console.ReadKey();
}
}
/// <summary>
/// 创建一个类
/// </summary>
public class Person
{
//创建一个数组
string[] nums = new string[100];
/// <summary>
/// 创建一个索引器
/// 使用索引器就是为了方便使用类中的集合
/// 类似于一个属性
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public string this[int index]
{
get { return nums[index]; }
set { nums[index] = value; }
}
}
//通过线程打开文件
//ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\Administrator\Desktop\test\1.txt");
//Process.Start(psi);
//也可以使用下面的写法
ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\Administrator\Desktop\test\1.txt");
Process p = new Process();
p.StartInfo = psi;
p.Start();
面向对象:
面向对象的三大特征:封装,继承,多态
封装的好处,就是隐藏具体的细节,从而简化使用的过程
好比手机,我们不需要知道他的内部构成和电路的工作原理,我们只要知道输入手机号,按下拨号键,就可以通话就可以了
继承的好处,代码复用,不用重复的写相同的代码
多态的好处，把不同的子类对象当做父类来看,可以屏蔽不同子类对象之间的差异
写出通用的代码,做出通用的编程,以适应需求的不断变化
类中的成员：字段、属性、方法、构造函数
字段:类中唯一存储数据
属性:保护字段，对字段的取值和赋值进行限定，属性的本质就是两个方法 get() set()
方法:对象的行为
构造函数：初始化对象(给对象的每个属性依次的赋值)，可以有重载。
类当中默认会有一个无参数的构造函数,当你写了一个新的构造函数之后,那个默认的无参数的就被干掉了。
类写好后，我们需要创建这个类的对象，我们管创建这个类的对象的过程称之为类的实例化
使用关键字 new
保护字段的3种方式:
1.get()
2.set()
3.构造函数
/// <summary>
/// 在属性的get方法中做限制
/// </summary>
public string Name
{
get { return _name; }
set
{
if (value != "张三")
{
value = "张三";
}
_name = value;
}
}
private int _age;
/// <summary>
/// 在属性的set方法做限制
/// </summary>
public int Age
{
get
{
if (_age < 0 || _age > 100)
{
return _age = 0;
}
return _age;
}
set { _age = value; }
}
return的作用
在方法中返回要返回的值
立即结束本次方法的执行
//break;//跳出当前循环
//continue; 跳到循环条件进行判断
new的作用
1.创建对象
在堆中开辟空间
在开辟的堆空间中创建对象
调用对象的构造函数
2.在子类中隐藏从父类那里继承过来的成员
this的作用
表示当前类的对象
如果一个类中有多个构造函数的时候,可以显示的调用自己的构造函数
base的作用
在子类中显示的调用父类的构造函数,避免参数的赋值代码多次书写
在子类中调用父类中的重名方法
继承:
好处：减少代码的冗余
子类继承了父类,继承了父类的属性和方法
并没有继承父类的私有字段
也没有继承父类的构造函数,但是会去调用父类中的无参的构造函数
目的是为了能够初始化父类,为了让子类能够调用到父类中的成员
当你在父类中重新写了有参数的构造函数之后，那个无参数的就被干掉了，
此时,子类将无法调用父类的无参构造函数而报错,解决办法：
在父类中重新写一个无参数的构造函数
在子类中显示的调用父类的构造函数 :base
静态和非静态
在一个类中,如果既有静态成员,也有非静态成员,则首先初始化静态成员,并且只初始化一次
不管你有多少个对象,都只初始化一次。
而我们的非静态成员,有多少个对象,就初始化多少次
在整个项目当中静态成员是资源共享的
静态成员只有在整个项目都结束的时候,才释放资源,所以在项目中应该少使用静态成员
里氏转换
子类可以赋值给父类(如果有一个地方需要父类作为参数,我们可以给一个子类代替)
如果这个父类中装的是子类对象，则可以将这个父类强转为子类对象
is:表示类型转换,如果转换成功返回一个true,否则返回false
as:表示类型转换,如果转换成功,则返回对应的对象,否则返回null
访问修饰符
public:公开的公共的,在哪都可以访问到,
internal:只能在当前项目内部访问.在项目的内部,public的权限跟internal是一样的
private:私有的,只能在当前类的内部访问
protected:受保护的,只能在当前类的内部以及该类的子类中访问
protected internal：
修饰符类的访问修饰符：public internal
修饰符类中的成员的访问修饰符：public private internal protected protected internal
注意:子类的访问权限不能高于父类的访问权限
因为子类肯能会暴漏父类的成员
如果父类的访问权限做了限制,肯定是希望父类只在某些情况下使用,其他情况不允许使用
而如果子类继承了父类并且权限比父类高
则外部的程序虽然不能直接访问父类,但是却可以通过子类访问父类的成员,这显然是有违初衷的
所以限制了子类的访问权限不能比父类高
多态:
虚方法:virtual
如果父类需要被实例化
如果父类中的方法需要有实现
虚方法在父类中必须被实现,哪怕是空的实现
虚方法在子类中可以被重写也可以不重写
/// <summary>
/// 父类
/// </summary>
public class RealDuck
{
public virtual void Bark()
{
Console.WriteLine("真的鸭子嘎嘎叫");
}
}
public class MuDuck : RealDuck
{
public override void Bark()
{
Console.WriteLine("木头鸭子吱吱叫");
}
}
public class XPDuck : RealDuck
{
//如果在子类中不对父类进行重写,则下面的方法调用返回的值是【真的鸭子嘎嘎叫】
//这是因为虽然父类rd里面装入的是XPDuck的对象,但是他让然表现出父类的特性
//而无法表现出子类的特性
//RealDuck rd = new XPDuck();
//rd.Bark();
//如果是下面的写法,返回值是【橡皮鸭子唧唧叫】
//这是子类隐藏了父类的Bark方法
//XPDuck xp = new XPDuck();
//xp.Bark();
public void Bark()
{
Console.WriteLine("橡皮鸭子唧唧叫");
}
}
抽象类:abstract
抽象方法不能有任何方法实现,空实现也不行
抽象成员必须包含在抽象类中
由于抽象成员没有任何实现,子类中必须对抽象成员重写
抽象类中可以包含抽象成员,也可以包含实例成员
抽象类不能被static关键字修饰
抽象类不能被实例化
抽象类 的作用就是要被子类继承
/// <summary>
/// 动物类(抽象类)
/// 抽象类可以有实例成员
/// </summary>
public abstract class Animal
{
/// <summary>
/// 抽象类中可以有实例对象
/// </summary>
public string Name
{
get;
set;
}
/// <summary>
/// 动物类的无参构造函数
/// </summary>
public Animal()
{
}
/// <summary>
/// 动物类的有参构造函数
/// </summary>
/// <param name="name"></param>
public Animal(string name)
{
this.Name = name;
}
/// <summary>
/// 抽象类里的抽象方法
/// </summary>
public abstract void Bark();
}
/// <summary>
/// 狗狗类
/// </summary>
public class Dog : Animal
{
public override void Bark()
{
Console.WriteLine("狗狗旺旺的叫");
}
}
/// <summary>
/// 猫咪类
/// </summary>
public class Cat : Animal
{
public override void Bark()
{
Console.WriteLine("猫咪喵喵的叫");
}
}
接口:interface
接口中只能包含方法(函数,属性,事件,索引器)
接口中的成员都不能有实现,空实现也不行
接口不能被实例化
接口中的成员不能有任何访问修饰符,接口默认为public
继承接口的子类必须将接口中的所有成员实现
接口存在的意义:实现了多态
多态的意义:提高程序的可扩展性,最终节省成本,提高效率
/// <summary>
/// 飞的接口
/// </summary>
interface IFlyable
{
void Fly();
}
/// <summary>
/// 鸟的父类
/// </summary>
public class Bird
{
public int Wings
{
get;
set;
}
}
/// <summary>
/// 鹦鹉子类,继承鸟的类和飞行的接口
/// </summary>
public class YingWu : Bird, IFlyable
{
/// <summary>
/// 鹦鹉类自己的飞行方法
/// </summary>
public void Fly()
{
Console.WriteLine("鹦鹉会飞");
}
//显示实现接口的方法
void IFlyable.Fly()
{
Console.WriteLine("接口中的飞方法");
}
}
索引器:
class Program
{
static void Main(string[] args)
{
Person p = new Person();
//在这里赋值的时候其实就是跟索引器里的数组赋值
p[0] = "张三";
p[1] = "李四";
Console.WriteLine(p[0]);
Console.WriteLine(p[1]);
Console.ReadKey();
}
}
/// <summary>
/// 创建一个类
/// </summary>
public class Person
{
//创建一个数组
string[] nums = new string[100];
/// <summary>
/// 创建一个索引器
/// 使用索引器就是为了方便使用类中的集合
/// 类似于一个属性
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public string this[int index]
{
get { return nums[index]; }
set { nums[index] = value; }
}
}