C#随记05
方法
方法在类或结构中声明，声明时需要指定访问级别，返回值，方法名称及方法参数，方法参数放在括号中，并用逗号隔开。括号中没有内容表示声明的方法没有参数。
修饰符 返回值类型 方法名（参数列表）{
//方法的具体实现
}
如果方法不需要返回一个值，则使用void关键字。
方法的定义必须在某个类中，定义方法时如果没有声明访问修饰符，方法的默认访问权限为private
如果定义的方法有返回值，则必须使用renturn关键字返回一个指定类型的数据。
public int ShowGoods(){
Console.writeLine("商品信息")；
return 1；
}
方法的参数
传给方法的值叫实参
接收实参的变量叫形参
形参只在方法内部有效。
- 值参数
值参数就是在声明时不加修饰符的参数。它表明实参与形参之间按值传递。 - ref参数
ref参数使用形参按引用传递（即使形参是值类型），其效果是：在方法中对形参所做的任何更改都将反应在实参中。如果要使用ref参数，则方法声明和调用都必须显示使用ref关键字。
变量必须在传递之前赋值。 - out参数
定义输出参数，会导致参数通过引用来传递、 - params参数
声明方法时，如果有多个相同类型的参数，可以定义为params参数，params参数是一个一维数组，主要用来指定在参数数目可变时所采用的方法参数。
方法的重载
方法重载是指方法名相同，但参数的数据类型，个数，顺序不同的方法。
类的静态成员
共享的变量或者方法用static修饰，它们被称作静态变量和静态方法，也被称为类的静态成员，静态成员是属于类所有的，在调用时，不用创建类的对象，而且直接使用类名调用。
class Program{
public static int Add(intx, int y){
return x+y;
}
static void Main(string[] args){
Console.WriteLine("{0}+{1}={2}",23,43,Program.Add(23+34));
Console.ReadLine();
}
}
对象的创建及使用
在一类事物中抽象出某一个特例，通过这个特例来处理这类事物出现的问题。
Test test=new Test();
当使用new关键字创建对象后，可使用“对象.类成员”来获取对象的属性和行为。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace studyDaily
{
public class cStockInfo
{
public string FullName
{
get;
set;
}
public void ShowGoods()
{
Console.WriteLine("库存商品名称：");
Console.WriteLine(FullName);
}
}
class Program
{
static void Main(string[] args)
{
cStockInfo stockInfo = new cStockInfo();
stockInfo.FullName = "笔记本电脑";
stockInfo.ShowGoods();
Console.ReadLine();
}
}
}
对象的销毁
每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址将会被回收。
垃圾：
- 对象引用超过其作用返回
- 将对象赋值为null
类与对象的关系
类是具有相同或相似结构、操作和约束规则的对象组成的集合，而对象是某一类的具体化实例，每一个类都是具有某些共同特征的对象的抽象。
继承
在程序设计中实现继承，表示这个类拥有它继承的类的所有公有成员或者受保护成员。在面向对象编程中，被继承的类称为父类或基类，实现继承的类称为子类或派生类
继承的实现
派生类可以继承基类原有的属性和方法，也可以增加原来基类所不具备的属性和方法，或者直接重写基类中的某些方法。
C#使用“：”来标识两个类的继承关系，继承一个类时，类成员的可访问性是一个重要的问题。派生类不能访问基类的私有成员，但是可以访问其公共成员。
父类和派生类可以访问protected成员。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace studyDaily
{
class Goods {
public string TradeCode { get; set; }
public string FullName { get; set; }
}
class JHInfo : Goods
{
public string JHID { get; set; }
public void showInfo()
{
Console.WriteLine("进货编号：{0}\n商品编号：{1}\n商品名称：{2}", JHID, TradeCode, FullName);
}
}
class Program
{
static void Main(string[] args)
{
JHInfo jh = new JHInfo();
jh.TradeCode = "T100001";
jh.FullName = "笔记本电脑";
jh.JHID = "JH0001";
jh.showInfo();
Console.ReadLine();
}
}
}
只支持单继承，不支持多重继承
base关键字
this关键字代表本类对象，base关键字代表父类对象。
base.property;//调用父类的属性
base.method();//调用父类的方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace studyDaily
{
class Computer //父类
{
public string sayHello()
{
return "欢迎使用！";
}
}
class Pad:Computer //子类：平板电脑
{
public new string sayHello()
{
//子类重写父类方法
return base.sayHello() + "平板电脑";
}
}
class Program
{
static void Main(string[] args)
{
Computer pc = new Computer();
Console.WriteLine(pc.sayHello());
Pad ipad = new Pad();
Console.WriteLine(ipad.sayHello());
Console.ReadLine();
}
}
}
访问父类成员只能在构造函数、实例方法、实例属性中进行。不能在静态方法中使用base
多态
类的多态性是通过在派生类中重写基类的虚方法来实现的。
方法在默认情况下不是虚拟的，但（除了构造函数以外）可以显式地声明为virtual，在方法前面加上关键字virtual，则成该方法为虚方法。
public virtual void Move(){
Console.WriteLine("交通工具都可以移动")；
}
定义为虚方法后，可以在派生类中重写虚方法，重写虚方法使用override关键字
public override void Move(){
Console.WriteLine("火车都可以移动");
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace studyDaily
{
class Vehicle
{
string name;
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
public virtual void Move() {
Console.WriteLine("{0}都可移动", Name);
}
}
class Train : Vehicle
{
public override void Move()
{
Console.WriteLine("{0}在公路上行驶", Name);
}
}
class Car: Vehicle
{
public override void Move()
{
Console.WriteLine("{0}在公路上行驶", Name);
}
}
class Program{
static void Main(string[] args)
{
Vehicle vehicle = new Vehicle();
Train train = new Train();
Car car = new Car();
Vehicle[] vehicles = { vehicle, train, car };
vehicle.Name = "交通工具";
train.Name = "火车";
car.Name = "汽车";
vehicles[0].Move();
vehicles[1].Move();
vehicles[2].Move();
Console.ReadLine();
}
} }
抽象类与抽象方法
如果一个类不与具体的事物相联系，而只是表达一种抽象的概念或行为，仅仅是作为其派生类的一个基类，这样的类就可以声明为抽象类。
去商场买衣服。
- 声明抽象类时需要使用abstract关键字
访问修饰符 abstract class 类名：基类或接口{
类成员
}
抽象类主要用来提供多个派生类可共享的基类的公共定义，它与非抽象类的主要区别如下：
- 抽象类不能直接实例化
- 抽象类中可以包含抽象成员，但非抽象类中不可以
- 抽象类不能被密封
声明抽象方法： - 抽象方法必须声明在抽象类中
- 声明抽象方法时，不能使用virtual、static、private修饰符
public abstract class TestClass{
public abstract void AbsMethod();
}
类中只要有一个方法声明为抽象方法，这个类必须被声明为抽象类
当从抽象类派生一个非抽象类时，需要在非抽象类中重写抽象方法，以提供具体实现，在重写抽象方法时需要使用override关键字。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace studyDaily
{
public abstract class Market
{
public string Name { get; set; }
public string Goods { get; set; }
public abstract void Shop();
}
public class WallMarket : Market
{
public override void Shop()
{
Console.WriteLine(Name + "购买" + Goods);
}
}
public class TaobaoMarket : Market
{
public override void Shop()
{
Console.WriteLine(Name + "购买" + Goods);
}
}
class Program
{
static void Main(string[] args)
{
Market market = new WallMarket();
market.Name = "沃尔玛";
market.Goods= "苹果";
market.Shop();
market = new TaobaoMarket();
market.Name = "淘宝";
market.Goods = "耳环";
market.Shop();
Console.ReadLine();
}
}
}
接口的使用
C#不支持多重继承
可通过接口实现多重继承的功能
接口提出了一种规范，强制性要求派生类必须实现接口约定的规范，以保证派生类必须拥有某些特性
修饰符 interface 接口名称：继承的接口列表{
接口内容
}
- 接口类似于抽象基类：继承接口的任何类型都必须实现接口的所有成员
- 接口中不能包括构造函数，因此不能直接实例化接口
- 接口可以包含属性、方法、索引器和事件
- 接口只能定义成员不能实现成员
- 接口定义的成员不允许加访问修饰符，因为接口成员永远是公共的
- 接口中的成员不能声明为虚拟或者静态
interface Information{
string Code{get;set;}
string Name{get;set;}
void showInfo（）；
}
接口的实现通过继承来实现，一个类虽然只能继承一个基类，但可以继承任意多个接口。声明实现接口的类时，需要在继承列表中包含所实现的接口的名称，多个接口之间用逗号分隔。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace studyDaily
{
interface IPerson
{
string Name { get; set; }
int Age { get; set; }
void Speek();
void Work();
}
class Student:IPerson
{
public string Name { get; set; }
private int age;
public int Age
{
get
{
return age;
}
set
{
if (age > 0 && age < 120)
{
age = value;
}
}
}
public void Speek()
{
Console.WriteLine(Name+"老师好！");
}
public void Work()
{
Console.WriteLine(Name + "同学们开始记笔记");
}
}
class Teacher : IPerson
{
public string Name { get; set; }
private int age;
public int Age
{
get
{
return age;
}
set
{
if (age > 0 && age < 120)
{
age = value;
}
}
}
public void Speek()
{
Console.WriteLine(Name + "同学们好！");
}
public void Work()
{
Console.WriteLine(Name + "同学们开始记笔记");
}
}
class Program
{
static void Main(string[] args)
{
IPerson[] person = new IPerson[] { new Student(), new Teacher() };
person[0].Name = "小明";
person[0].Age = 12;
person[1].Name = "小红";
person[1].Age= 32;
person[0].Speek();
person[1].Speek();
Console.WriteLine();
person[0].Work();
person[1].Work();
Console.WriteLine();
Console.ReadLine();
}
}
}
浙公网安备 33010602011771号