类
1.声明类
类使用 class 关键字进行声明
//访问级别 关键字 类名称
public class Customer
{
//类成员(字段、属性、方法、事件)
}
2.创建对象
类定义对象的类型,但它不是对象本身。
对象是基于类的具体实体,有时称为类的实例。
通过使用 new 关键字(后跟对象将基于的类的名称)可以创建对象
Customer object1 = new Customer();
创建了两个对象引用,它们引用同一个对象。 因此,通过 object3 对对象所做的任何更改都将反映在随后使用的 object4 中。 由于基于类的对象是按引用来引用的,因此类称为引用类型。
Customer object3 = new Customer();
Customer object4 = object3;
抽象类
含有abstract修饰符的class即为抽象类,抽象类是特殊的类,只是不能被实例化,可以创建一个变量,其类型是一个抽象类,并让它指向具体子类的一个实例;除此以外,具有类的其他特性;重要的是抽象类可以包括抽象方法,这是普通类所不能的。抽象方法只能声明于抽象类中,且不包含任何实现,派生类必须覆盖它们。另外,抽象类可以派生自一个抽象类,可以覆盖基类的抽象方法也可以不覆盖。
语法格式为:
访问修饰符 abstract class 类名:基类或接口
{
类成员;
}
声明抽象类时,除abstract关键字,class关键字和类名外,其他的都是可选项。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
abstract class A//抽象类
{
public abstract void add(int a,int b);//抽象方法
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
class B : A//派生类B
{
public override void add(int a, int b)//重写抽象方法
{
int sum = a + b;
Console.WriteLine(sum);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
class C : A//派生类C
{
public override void add(int a, int b)//重写抽象方法
{
int sum = System.Math.Abs(a + b);//取两数和的绝对值
Console.WriteLine(sum);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
class Program
{
static void Main(string[] args)
{
B b = new B();
b.add(1,-2);
C c = new C();
c.add(1,-2);
Console.ReadLine();
}
}
}
接口
接口就是定义一个协定,只是一个架子,必须由结构或者类来实现。
interface 接口名
{
方法声明;
}
1.接口用于描述一组类的公共方法/公共属性. 它不实现任何的方法或属性,只是告诉继承它的类至少要实现哪些功能,继承它的类可以增加自己的方法.
2.使用接口可以使继承它的类: 命名统一/规范,易于维护.比如: 两个类 "狗"和"猫",如果它们都继承了接口"动物",其中动物里面有个方法Behavior(),那么狗和猫必须得实现Behavior()方法,
并且都命名为Behavior这样就不会出现命名太杂乱的现象.如果命名不是Behavior(),接口会约束即不按接口约束命名编译不会通过.
3.提供永远的接口。 当类增加时,现有接口方法能够满足继承类中的大多数方法,没必要重新给新类设计一组方法,也节省了代码,提高了开发效率.
Program.cs
namespace InterfaceExample
{
class Program
{
static void Main(string[] args)
{
//不同类的相同方法名输出不同东西
Dog myDog = new Dog();
myDog.Behavior(); //输出: "晚上睡觉,白天活动"
Cat myCat = new Cat();
myCat.Behavior(); //输出: "白天睡觉,晚上活动"
}
}
}
IAnimal.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceExample
{
//公共接口:动物
interface IAnimal
{
void Behavior();//行为方法:描述动物特性
}
}
Dog.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceExample
{
class Dog : IAnimal
{
string ActiveTime = "白天";
public void Behavior()
{
Console.WriteLine("晚上睡觉,白天活动");
}
}
}
Cat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceExample
{
class Cat : IAnimal
{
string ActiveTime = "夜晚";
public void Behavior()
{
Console.WriteLine("白天睡觉,晚上活动");
}
}
}
接口和抽象类异同
接口是引用类型的,类似于类,和抽象类的相似之处有三点:
1、不能实例化;
2、包含未实现的方法声明;
3、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员);
两者的语法区别:
1.抽象类可以有构造方法,接口中不能有构造方法。
2.抽象类中可以有普通成员变量,接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public,protected,但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法,接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。
7. 一个类可以实现多个接口,但只能继承一个抽象类。
8.接口可以用于支持回调,而继承并不具备这个特点.
9.抽象类实现的具体方法默认为虚的,但实现接口的类中的接口方法却默认为非虚的,当然您也可以声明为虚的.
抽象类和接口的使用:
1.如果预计要创建组件的多个版本,则创建抽象类。抽象类提供简单的方法来控制组件版本。
2.如果创建的功能将在大范围的全异对象间使用,则使用接口。如果要设计小而简练的功能块,则使用接口。
3.如果要设计大的功能单元,则使用抽象类.如果要在组件的所有实现间提供通用的已实现功能,则使用抽象类。
4.抽象类主要用于关系密切的对象(当在共性较多的对象间寻求功能上的差异时,使用抽象基类。);而接口适合为不相关的类提供通用功能(当在差异较大的对象间寻求功能上的共性时,使用接口。)。
5.好的接口定义应该是具有专一功能性的,而不是多功能的,否则造成接口污染。如果一个类只是实现了这个接口的中一个功能,而不得不去实现接口中的其他方法,就叫接口污染。
实例1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
class Program
{
static void Main(string[] args)
{
//抽象类
Animal duck = new Duck("Duck");
duck.MakeVoice();
duck.Show();
Animal dog = new Dog("Dog");
dog.MakeVoice();
dog.Show();
//接口
IAction dogAction = new Dog("A big dog");
dogAction.Move();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
//定义抽象类
abstract class Animal
{
protected string _name;
//声明抽象属性
public abstract string Name { get; }
//声明抽象方法
public abstract void Show();
//实现一般方法
public void MakeVoice()
{
Console.WriteLine("All animals can make voice!");
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
interface IAction
{
//定义公共方法标签
void Move();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
//实现抽象类和接口
class Duck : Animal,IAction
{
public Duck(string name)
{
_name = name;
}
//重载抽象方法
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
//重载抽象属性
public override string Name
{
get { return _name; }
}
//实现接口方法
public void Move()
{
Console.WriteLine(_name + " also can swim.");
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
//实现抽象类和接口
class Dog : Animal, IAction
{
public Dog(string name)
{
_name = name;
}
//重载抽象方法
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
//重载抽象属性
public override string Name
{
get { return _name; }
}
//实现接口方法
public void Move()
{
Console.WriteLine(_name + " also can run.");
}
}
}
实例2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//接口
interface IAnimal
{
//接口中声明的方法,这里不可用static,abstract修饰
void eating();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//抽象类Bird继承了IAnomal接口
abstract class Bird : IAnimal
{
public void eating()
{
//抽象类实现接口的方法且必须实现该方法
Console.WriteLine("eat!");
}
//定义抽象方法
abstract public void flying();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//Chick类是抽象类Bird类的派生类
class Chick :Bird
{
public int wingnum;
public Chick()
{
Console.WriteLine("This is a chick");
wingnum = 2;
}
//实现抽象类方法
public override void flying()
{
Console.WriteLine("The chick can fly!");
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//声明抽象类A
abstract class A
{
public int x;//普通公有成员
//抽象类A的构造函数
public A(int m)
{
x = m;
}
//抽象方法
abstract public int fun1();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//类C继承于抽象类B,必须实现所有抽象方法
class C :B
{
int y, z;
//构造函数
public C(int x1, int y1): base(x1)
{
y = x1;
z = y1;
}
//抽象方法fun1实现
public override int fun1()
{
return x * y;
}
//抽象方法fun2实现
public override int fun2()
{
return x / y;
}
//抽象属性px的实现
public override int px
{
get
{
try { return x + 10; }
catch
{
throw new Exception("The method or operation is not implemented.");
}
}
set
{
try { x = value; }
catch
{
throw new Exception("The method or operation is not implemented.");
}
}
}
public override int py //抽象属性py的实现
{
get
{
try { return y-10; }
catch
{
throw new Exception("The method or operation is not implemented.");
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//抽象类B继承抽象类A
abstract class B : A
{
//抽象类A的构造函数
public B(int m):base(1)
{
x = m;
}
abstract public int fun2();
public abstract int px { set; get; }
public abstract int py { get; }
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
class Program
{
static void Main(string[] args)
{
//类的使用
Chick ch = new Chick();
ch.eating();
ch.flying();
Console.WriteLine("翅膀个数是:{0}", ch.wingnum);
//多层次抽象类举例
C c = new C(5, 2); //创建类c的对象C
Console.WriteLine("{0},{1}", c.fun1(), c.fun2());
Console.WriteLine("{0}", c.x);
Console.WriteLine("{0},{1}", c.px, c.py); //调用抽象属性
}
}
}
1.声明类
类使用 class 关键字进行声明
//访问级别 关键字 类名称
public class Customer
{
//类成员(字段、属性、方法、事件)
}
2.创建对象
类定义对象的类型,但它不是对象本身。
对象是基于类的具体实体,有时称为类的实例。
通过使用 new 关键字(后跟对象将基于的类的名称)可以创建对象
Customer object1 = new Customer();
创建了两个对象引用,它们引用同一个对象。 因此,通过 object3 对对象所做的任何更改都将反映在随后使用的 object4 中。 由于基于类的对象是按引用来引用的,因此类称为引用类型。
Customer object3 = new Customer();
Customer object4 = object3;
抽象类
含有abstract修饰符的class即为抽象类,抽象类是特殊的类,只是不能被实例化,可以创建一个变量,其类型是一个抽象类,并让它指向具体子类的一个实例;除此以外,具有类的其他特性;重要的是抽象类可以包括抽象方法,这是普通类所不能的。抽象方法只能声明于抽象类中,且不包含任何实现,派生类必须覆盖它们。另外,抽象类可以派生自一个抽象类,可以覆盖基类的抽象方法也可以不覆盖。
语法格式为:
访问修饰符 abstract class 类名:基类或接口
{
类成员;
}
声明抽象类时,除abstract关键字,class关键字和类名外,其他的都是可选项。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
abstract class A//抽象类
{
public abstract void add(int a,int b);//抽象方法
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
class B : A//派生类B
{
public override void add(int a, int b)//重写抽象方法
{
int sum = a + b;
Console.WriteLine(sum);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
class C : A//派生类C
{
public override void add(int a, int b)//重写抽象方法
{
int sum = System.Math.Abs(a + b);//取两数和的绝对值
Console.WriteLine(sum);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractExample
{
class Program
{
static void Main(string[] args)
{
B b = new B();
b.add(1,-2);
C c = new C();
c.add(1,-2);
Console.ReadLine();
}
}
}
接口
接口就是定义一个协定,只是一个架子,必须由结构或者类来实现。
interface 接口名
{
方法声明;
}
1.接口用于描述一组类的公共方法/公共属性. 它不实现任何的方法或属性,只是告诉继承它的类至少要实现哪些功能,继承它的类可以增加自己的方法.
2.使用接口可以使继承它的类: 命名统一/规范,易于维护.比如: 两个类 "狗"和"猫",如果它们都继承了接口"动物",其中动物里面有个方法Behavior(),那么狗和猫必须得实现Behavior()方法,
并且都命名为Behavior这样就不会出现命名太杂乱的现象.如果命名不是Behavior(),接口会约束即不按接口约束命名编译不会通过.
3.提供永远的接口。 当类增加时,现有接口方法能够满足继承类中的大多数方法,没必要重新给新类设计一组方法,也节省了代码,提高了开发效率.
Program.cs
namespace InterfaceExample
{
class Program
{
static void Main(string[] args)
{
//不同类的相同方法名输出不同东西
Dog myDog = new Dog();
myDog.Behavior(); //输出: "晚上睡觉,白天活动"
Cat myCat = new Cat();
myCat.Behavior(); //输出: "白天睡觉,晚上活动"
}
}
}
IAnimal.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceExample
{
//公共接口:动物
interface IAnimal
{
void Behavior();//行为方法:描述动物特性
}
}
Dog.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceExample
{
class Dog : IAnimal
{
string ActiveTime = "白天";
public void Behavior()
{
Console.WriteLine("晚上睡觉,白天活动");
}
}
}
Cat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceExample
{
class Cat : IAnimal
{
string ActiveTime = "夜晚";
public void Behavior()
{
Console.WriteLine("白天睡觉,晚上活动");
}
}
}
接口和抽象类异同
接口是引用类型的,类似于类,和抽象类的相似之处有三点:
1、不能实例化;
2、包含未实现的方法声明;
3、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员);
两者的语法区别:
1.抽象类可以有构造方法,接口中不能有构造方法。
2.抽象类中可以有普通成员变量,接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public,protected,但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法,接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。
7. 一个类可以实现多个接口,但只能继承一个抽象类。
8.接口可以用于支持回调,而继承并不具备这个特点.
9.抽象类实现的具体方法默认为虚的,但实现接口的类中的接口方法却默认为非虚的,当然您也可以声明为虚的.
抽象类和接口的使用:
1.如果预计要创建组件的多个版本,则创建抽象类。抽象类提供简单的方法来控制组件版本。
2.如果创建的功能将在大范围的全异对象间使用,则使用接口。如果要设计小而简练的功能块,则使用接口。
3.如果要设计大的功能单元,则使用抽象类.如果要在组件的所有实现间提供通用的已实现功能,则使用抽象类。
4.抽象类主要用于关系密切的对象(当在共性较多的对象间寻求功能上的差异时,使用抽象基类。);而接口适合为不相关的类提供通用功能(当在差异较大的对象间寻求功能上的共性时,使用接口。)。
5.好的接口定义应该是具有专一功能性的,而不是多功能的,否则造成接口污染。如果一个类只是实现了这个接口的中一个功能,而不得不去实现接口中的其他方法,就叫接口污染。
实例1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
class Program
{
static void Main(string[] args)
{
//抽象类
Animal duck = new Duck("Duck");
duck.MakeVoice();
duck.Show();
Animal dog = new Dog("Dog");
dog.MakeVoice();
dog.Show();
//接口
IAction dogAction = new Dog("A big dog");
dogAction.Move();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
//定义抽象类
abstract class Animal
{
protected string _name;
//声明抽象属性
public abstract string Name { get; }
//声明抽象方法
public abstract void Show();
//实现一般方法
public void MakeVoice()
{
Console.WriteLine("All animals can make voice!");
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
interface IAction
{
//定义公共方法标签
void Move();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
//实现抽象类和接口
class Duck : Animal,IAction
{
public Duck(string name)
{
_name = name;
}
//重载抽象方法
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
//重载抽象属性
public override string Name
{
get { return _name; }
}
//实现接口方法
public void Move()
{
Console.WriteLine(_name + " also can swim.");
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface
{
//实现抽象类和接口
class Dog : Animal, IAction
{
public Dog(string name)
{
_name = name;
}
//重载抽象方法
public override void Show()
{
Console.WriteLine(_name + " is showing for you.");
}
//重载抽象属性
public override string Name
{
get { return _name; }
}
//实现接口方法
public void Move()
{
Console.WriteLine(_name + " also can run.");
}
}
}
实例2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//接口
interface IAnimal
{
//接口中声明的方法,这里不可用static,abstract修饰
void eating();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//抽象类Bird继承了IAnomal接口
abstract class Bird : IAnimal
{
public void eating()
{
//抽象类实现接口的方法且必须实现该方法
Console.WriteLine("eat!");
}
//定义抽象方法
abstract public void flying();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//Chick类是抽象类Bird类的派生类
class Chick :Bird
{
public int wingnum;
public Chick()
{
Console.WriteLine("This is a chick");
wingnum = 2;
}
//实现抽象类方法
public override void flying()
{
Console.WriteLine("The chick can fly!");
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//声明抽象类A
abstract class A
{
public int x;//普通公有成员
//抽象类A的构造函数
public A(int m)
{
x = m;
}
//抽象方法
abstract public int fun1();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//类C继承于抽象类B,必须实现所有抽象方法
class C :B
{
int y, z;
//构造函数
public C(int x1, int y1): base(x1)
{
y = x1;
z = y1;
}
//抽象方法fun1实现
public override int fun1()
{
return x * y;
}
//抽象方法fun2实现
public override int fun2()
{
return x / y;
}
//抽象属性px的实现
public override int px
{
get
{
try { return x + 10; }
catch
{
throw new Exception("The method or operation is not implemented.");
}
}
set
{
try { x = value; }
catch
{
throw new Exception("The method or operation is not implemented.");
}
}
}
public override int py //抽象属性py的实现
{
get
{
try { return y-10; }
catch
{
throw new Exception("The method or operation is not implemented.");
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
//抽象类B继承抽象类A
abstract class B : A
{
//抽象类A的构造函数
public B(int m):base(1)
{
x = m;
}
abstract public int fun2();
public abstract int px { set; get; }
public abstract int py { get; }
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace AbstractInterface1
{
class Program
{
static void Main(string[] args)
{
//类的使用
Chick ch = new Chick();
ch.eating();
ch.flying();
Console.WriteLine("翅膀个数是:{0}", ch.wingnum);
//多层次抽象类举例
C c = new C(5, 2); //创建类c的对象C
Console.WriteLine("{0},{1}", c.fun1(), c.fun2());
Console.WriteLine("{0}", c.x);
Console.WriteLine("{0},{1}", c.px, c.py); //调用抽象属性
}
}
}