面向鸭编程
1. 面向对象编程中，接口既然不能直接描述方法，要他有何用
初学时确实很不明白为什么要费这么个二道手……
简单地说：接口就是一个约定，凡是实现了接口的类，必定是遵守了该约定的。
比如有Dog、Cat、Duck三种动物，我想听他们的叫声，然后这样进行了实现。
class Dog
{
public void Shout()
{
Console.WriteLine("汪汪");
}
}
class Cat
{
public void Shout()
{
Console.WriteLine("喵喵");
}
}
class Duck
{
public void Shout()
{
Console.WriteLine("呱呱");
}
}
class Test
{
static void Main(String[] args)
{
var dog = new Dog();
var cat = new Cat();
var ck = new Duck();
dog.Shout();
cat.Shout();
ck.Shout();
Console.Read();
}
}
然后发现，这样好麻烦啊！明明都是在叫，能不能把“叫”这一行为进行抽离，然后统一处理呢？这时候就可以用到接口了：
interface IShout
{
void Shout();
}
class Dog : IShout
{
public void Shout()
{
Console.WriteLine("汪汪");
}
}
class Cat : IShout
{
public void Shout()
{
Console.WriteLine("喵喵");
}
}
class Duck : IShout
{
public void Shout()
{
Console.WriteLine("呱呱");
}
}
class Test
{
static void Main(String[] args)
{
var lstIShout = new List<IShout>() { new Dog(), new Cat(), new Duck() };
lstIShout.ForEach(x =>
{
x.Shout();
});
Console.Read();
}
}
在这次实现中，不管对象是狗、猫还是鸭子，他们都实现了IShout接口，因此他们都必须要实现Shout方法（必须遵从的约定），从而我就可以对他们的共性进行统一化的处理。与此同时，在我看到了Dog:IShout这种声明方式时，我不需要去关注狗到底是怎么叫的，只需要知道狗会叫就足够了。这只是接口最简单的一种应用，更复杂的情况可以去研究控制反转与依赖注入。
_______________________________________________
这里再补充一下用鸭子类型（ck typing，详情可进行检索）的思想来实现，与用接口实现进行一下对比。
class Dog
{
public void Shout()
{
Console.WriteLine("汪汪");
}
}
class Cat
{
public void Shout()
{
Console.WriteLine("喵喵");
}
}
class Duck
{
public void Shout()
{
Console.WriteLine("呱呱");
}
}
class Test
{
static void Main(String[] args)
{
var lstDynamic = new List<dynamic>() { new Dog(), new Cat(), new Duck() };
lstDynamic.ForEach(x =>
{
x.Shout();
});
Console.Read();
}
}
运行后发现同样可以实现目的。那么为什么要用接口呢？
因为这里的代码都是我自己写的，我知道三种动物都实现了Shout方法，所以我才敢大胆去直接动态调用这个方法，但是这不代表这样的动态调用是安全的。
假如现在又新增了一个动物类Monkey
class Monkey{
public void Cry()
{
Console.WriteLine("唧唧");
}
}
由于手误，把方法名起成了Cry，那么可以预见的，在动态调用的过程中，就会触发运行时错误了。
class Test
{
static void Main(String[] args)
{
var lstDynamic = new List<dynamic>() { new Dog(), new Cat(), new Duck() ,new Monkey()};
lstDynamic .ForEach(x =>
{
x.Shout();//执行到猴子时，会触发运行时错误。
});
Console.Read();
}
}
如果是用实现IShout接口的方式定义的Monkey，那么这种情况是不会出现的，因为约定是必须遵守的。
2. 求一些有关java面向对象继承的编程题
鱼有游泳功能 , 麻雀有飞行功能 , 鸭子既可以飞也可以游 , 鸭子和麻雀都可以行走,三者都需要呼吸.
通过java多态的思想,用继承描述上述事物结构.
3. 卖鸭子 c语言
#include<stdio.h>
int sum;
int yazi(int n)
{
if(7==n)
return 1;
else
{
printf(" sell=%d",(sum+2)*2);
sum=(sum+1)*2;
return (yazi(n+1)+1)*2;
}
}
int main()
{ int k=1;
printf(" 总数：%d",yazi(k));
printf("\n");
return 0;
}
希望能帮到你
4. 软件设计模式鸭子模拟器
假设我们需要设计出各种各样的鸭子，一边游泳戏水， 一边呱呱叫。很明显这时我们需要设计了一个鸭子超类（Superclass），并让各种鸭子继承此超类。
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
}
每一只鸭子就继承Duck类
public class MallardDuck extends Duck {
public void display() {
// 外观是绿色的
}
}
public class RedheadDuck extends Duck{
public void display(){
// 外观是红色的
}
}
好了，我们完成这些后，但是发现我们需要有一些鸭子是会飞的，应该怎么修改呢？
也许你要说这很简单，在Duck类里面直接加入一个fly()方法，不就可以了。
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
public void fly(){
//会飞
}
}
这时你会发现所有的鸭子都变成了会飞的,很明显这是不对了，例如橡皮鸭显然就不是了。
你也许想到了另一种方法，在会飞的鸭子类里才添加该方法不就可以了嘛，
public class MallardDuck extend Duck{
public void display(){
// 外观是绿色的
}
public void fly(){
//会飞
}
}
这个方法看起来是很不错，可是有很多种鸭子都会飞的时候，代码的复用性很明显是不够好的,你不得不在
每一个会飞的鸭子类里去写上同一个fly()方法,这可不是个好主意.
可能你又想到另一个方法：采用继承和覆盖，在Duck类里实现fly()方法，在子类里如果不会飞的就覆盖它
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack(){
//会叫
}
public void fly(){
//会飞
}
}
//橡皮鸭吱吱叫，不会飞
public class RubberDuck extend Duck{
public void quack(){
//覆盖成吱吱叫
}
public void display{
//外观是橡皮鸭
}
public void fly{
//什么也不做
}
}
这样我们真实现了确实能飞的鸭子才可以飞起来了，看起来主意不错！问题到这儿似乎得到了解决
但我们现在有了一种新的鸭子，诱铒鸭(不会飞也不会叫),看来需要这样来写
public class DecoyDuck extend Duck{
public void quack(){
//覆盖，变成什么也不做
}
public void display(){
//诱饵鸭
}
public void fly(){
//覆盖，变成什么也不做
}
}
每当有新的鸭子子类出现或者鸭子新的特性出现，就不得不被迫在Duck类里添加并在所有子类里检查可能需要覆盖fly()和quark()...这简直是无穷尽的恶梦。所以，我们需要一个更清晰的方法，让某些（而不是全部）鸭子类型可飞或可叫。让鸭子的特性能有更好的扩展性。
用一下接口的方式把fly()取出来，放进一个Flyable接口中，这样只有会飞的鸭子才实现这个接口，当然我们也可以照此来设计一个Quackbable接口，因为不是所有的鸭子都会叫,也只让会叫的鸭子才去实现这个接口.
但这个方法和上面提到的在子类里去实现fly一样笨，如果几十种都可以飞，你得在几十个鸭子里去写上一样的fly(),如果一旦这个fly有所变更，你将不得不找到这几十个鸭子去一个一个改它们的fly()方法。
因为改变鸭子的行为会影响所有种类的鸭子，而这并不恰当。Flyable与Quackable接口一开始似乎还挺不错， 解决了问题（ 只有会飞的鸭子才继承Flyable） ， 但是Java的接口不具有实现代码， 所以继承接口无法达到代码的复用。这意味着：无论何时你需要修改某个行为，你必须得往下追踪并修改每一个定义此行为的类。
策略模式的第一原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 好吧，回头看一下这个Duck类，就我们目前所知，除了fly()和quack()的问题之外，Duck类还算一切正常，主要是鸭子的行为总是可能变化的，让我们头痛就在于这些行为的变化，那我们就把这些行为独立出来。
为了要把这两个行为从Duck 类中分开， 我们将把它们自Duck 类中取出，建立一组新类代表每个行为。我们建立两组类（完全远离Duck类），一个是“fly”相关的，一个是“quack”相关的，每一组类将实现各自 的动作。比方说，我们可能有一个类实现“呱呱叫”，另一个类实现“吱吱叫”，另一个类实现“安静”。我们利用接口代表每组行为，比方说， FlyBehavior来代表飞的行为，QuackBehavior代表叫的行为，而让每一种行为具体类来实现该行为接口。
在此，我们有两个接口，FlyBehavior和QuackBehavior，还有它们对应的类，负责实现具体的行为：
public interface FlyBehavior {
public void fly();
}
public class FlyWithWings implements FlyBehavior{
public void fly{}{
//实现鸭子飞行
}
}
public class FlyNoWay implements FlyBehavior{
public void fly{}{
//什么也不做，不会飞
}
}
public interface QuackBehavior{
public void quack();
}
public class Quack implements QuackBehavior{
public void quack(){
//实现鸭子呱呱叫
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//实现鸭子吱吱叫
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什么也不做，不会叫
}
}
实际上这样的设计，我们已经可以让飞行和呱呱叫的动作被其他的对象复用，因为这些行为已经与鸭子类无关了。如果我们新增一些行为，也不会影响到既有的行为类，也不会影响有已经使用到飞行行为的鸭子类。
好了，我们设计好鸭子的易于变化的行为部分后，该到了整合鸭子行为的时候了。
这时我们该想到策略模式的另一个原则了：
针对接口编程，而不是针对实现编程。
首先， 在鸭子中加入两个实例变量，分别为“flyBehavior”与“quackBehavior”，声明为接口类型（ 而不是具体类实现类型）， 每个变量会利用多态的方式在运行时引用正确的行为类型（ 例如：FlyWithWings 、Squeak...等）。我们也必须将Duck类与其所有子类中的fly()与quack()移除，因为这些行为已经被搬移到FlyBehavior与 Quackehavior类中了，用performFly()和performQuack()取代Duck类中的fly()与quack()。
public abstract class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void swim(){
//会游泳
}
public abstract void display();//各种外观不一样，所以为抽象
public void performQuack(){
quackBehavior.quack();
}
public void performFly(){
flyBehavior.fly();
}
}
很容易，是吧？想进行呱呱叫的动作，Duck对象只要叫quackBehavior对象
去呱呱叫就可以了。在这部分的代码中，我们不在乎QuackBehavior 接口的对象到底是什么，我们只关心该对象
知道如何进行呱呱叫就够了。
好吧！ 现在来关心如何设定flyBehavior 与quackBehavior的实例变量。
看看MallardDuck类：
public class MallardDuck extends Duck {
public MallardDuck() {
\\绿头鸭使用Quack类处理呱呱叫，所以当performQuack() 被调用，就把责任委托给Quack对象进行真正的呱呱叫。
quackBehavior = new Quack();
\\使用FlyWithWings作为其FlyBehavior类型。
flyBehavior = new FlyWithWings();
}
}
所以，绿头鸭会真的‘呱呱叫’，而不是‘吱吱叫’，或‘叫不出声’。这是怎么办到的？当MallardDuck实例化时，它的构造器会
把继承来的quackBehavior实例变量初始化成Quack类型的新实例（Quack是QuackBehavior的具体实现类）。同样的处理方式也可以用在飞行行为上： MallardDuck 的构造器将flyBehavior 实例变量初始化成FlyWithWings 类型的实例（
FlyWithWings是FlyBehavior的具体实现类）。
输入下面的Duck类（Duck.java） 以及MallardDuck 类MallardDuck.java），并编译之。
public abstract class Duck {
//为行为接口类型声明两个引用变量， 所有鸭子子类（在同一个packge）都继承它们。
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {
}
public abstract void display();
public void performFly() {
flyBehavior.fly();//委托给行为类
}
public void performQuack() {
quackBehavior.quack();//委托给行为类
}
public void swim() {
System.out.println("All cksfloat, even decoys!");
}
}
public class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = newQuack();
flyBehavior = newFlyWithWings();
}
public void display() {
System.out.println("I’m a real Mallard ck");
}
}
输入FlyBehavior接口（FlyBehavior.java）与两个行为实现类（FlyWithWings.java与FlyNoWay.java），并编译之。
public interface FlyBehavior {//所有飞行行为类必须实现的接口
public void fly();
}
public class FlyWithWings implements FlyBehavior {//这是飞行行为的实现， 给“真会”飞的鸭子用 .. .
public void fly() {
System.out.println("I’m flying!!");
}
}
public class FlyNoWay implements FlyBehavior {//这是飞行行为的实现， 给“不会”飞的鸭子用（ 包括橡皮鸭和诱饵鸭）
public void fly() {
System.out.println("I can’t fly");
}
}
输入QuackBehavior接口（QuackBehavior.java)及其三个实现类（Quack.java、MuteQuack.java、Squeak.java），并编译之。
public interface QuackBehavior {
public void quack();
}
public class Quack implements QuackBehavior {
public void quack() {
System.out.println(“Quack”);
}
}
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println(“<< Silence >>”);
}
}
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println(“Squeak”);
}
}
输入并编译测试类（MiniDuckSimulator.java）
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.display();
//这会调用MallardDuck继承来的performQuack() ，进而委托给该对象的QuackBehavior对象处理。（也就是说，调用继承来的quackBehavior的quack()）
mallard.performQuack();
//至于performFly() ，也是一样的道理。
mallard.performFly();
}
}
运行结果：
I’m a real Mallard ck
Quack
I’m flying!!
虽然我们把行为设定成具体的类（通过实例化类似Quack 或FlyWithWings的行为类， 并指定到行为引
用变量中），但是还是可以在运行时轻易地改变该行为。
所以，目前的作法还是很有弹性的，只是初始化实例变量的作法不够弹性罢了。
我们希望一切能有弹性，毕竟，正是因为一开始的设计的鸭子行为没有弹性，才让我们走到现在这条路。
我们还想能够“指定”行为到鸭子的实例， 比方说， 想要产生绿头鸭实例，并指定特定“类型”的飞行
行为给它。干脆顺便让鸭子的行为可以动态地改变好了。换句话说，我们应该在鸭子类中包含设定行为的方法。
因为quackBehavior实例变量是一个接口类型，所以我们是能够在运行时，透过多态动态地指定不同的QuickBehavior实现类给它。
我们在鸭子子类透过设定方法（settermethod）设定鸭子的行为，而不是在鸭子的构造器内实例化。
在Duck类中，加入两个新方法：从此以后，我们可以“随时”调用这两个方法改变鸭子的行为。
public strate class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}
}
好了，让我们再制造一个新的鸭子类型：模型鸭（ModelDuck.java）
public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();//初始状态，我们的模型鸭是不会飞的。
quackBehavior = new Quack();//初始状态，我们的模型鸭是可以叫的.
}
public void display() {
System.out.println("I’m a modelck");
}
}
建立一个新的FlyBehavior类型（FlyRocketPowered.java）
public class FlyRocketPowered implements FlyBehavior {
// 我们建立一个利用火箭动力的飞行行为。
public void fly() {
System.out.println("I’m flying with arocket!");
}
}
改变测试类（MiniDuckSimulator.java），加上模型鸭，并使模型鸭具有火箭动力。
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();
Duck model = new ModelDuck();
//第一次调用performFly() 会被委托给flyBehavior对象（也就是FlyNoWay对象），该对象是在模型鸭构造器中设置的。
model.performFly();
//这会调用继承来的setter 方法，把火箭动力飞行的行为设定到模型鸭中。哇咧！ 模型鸭突然具有火箭动力飞行能力。
model.setFlyBehavior(new FlyRocketPowered());
//如果成功了， 就意味着模型鸭动态地改变行为。如果把行为的实现绑死在鸭子类中， 可就无法做到这样。
model.performFly();
}
}
运行一下，看下结果
I’m a real Mallard ck
Quack
I’m flying!!
I’m a model ck
I can’t fly
I’m flying with a rocket!
如同本例一般，当你将两个类结合起来使用，这就是组合（composition）。这种作法和‘继承’不同的地方在于，
鸭子的行为不是继承而来，而是和适当的行为对象‘组合’而来。
这是一个很重要的技巧。其实是使用了策略模式中的第三个设计原则， 多用组合，少用继承。
现在来总结一下，鸭子的行为被放在分开的类中，此类专门提供某行为的实现。
这样，鸭子类就不再需要知道行为的实现细节。
鸭子类不会负责实现Flyable与Quackable接口，反而是由其他类专门实现FlyBehavior与QuackBehavior，
这就称为“行为”类。由行为类实现行为接口，而不是由Duck类实现行为接口。
这样的作法迥异于以往，行为不再是由继承Duck超类的具体实现而来， 或是继承某个接口并由子类自行实现而来。
(这两种作法都是依赖于“实现”， 我们被实现绑得死死的， 没办法更改行为,除非写更多代码)。
在我们的新设计中， 鸭子的子类使用接口（ FlyBehavior与QuackBehavior）所表示的行为，所以实际的实现不会被
绑死在鸭子的子类中。（ 换句话说， 特定的实现代码位于实现FlyBehavior与QuakcBehavior的特定类中）,这样我们就获得了更大的灵活性和可扩展性。
5. C++ 面向对象
面向对象，就是所有的代码一对象为基础，比如我有一个鸭子类
class ck{
public:
void yell(){ //鸭子叫唤的方法
cout<<"嘎嘎"<<endl;
}
void Move(){ //鸭子走路方法
cout<<"左摇右摆的走"<<endl;
}
};
这样就定义一个ck类，如果想生成50只鸭子，就直接定义
ck xiaoyazi[50]; xiaoyazi就是对象数组啦。
每一个xiaoyazi都是一个ck类的对象，都可以调用yell跟Move方法。
6. C# 抽象类 和结构 和类是的用处包括构造函数 接口!!
结构我没怎么用过，认为作用不大。
抽象类和接口可以放在一起看。希望不要看完了越来越混淆。
构造函数的作用：举个简单的例子，当你在实例化一个对象的时候需要初始化类中某些属性值，可以用构造函数。还有就是当我们实例化类时通过调用不同的构造函数得到我们想要的实例对象。
什么是接口？接口是包含一组虚方法的抽象类型，其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现，CLR允许接口可以包含事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。但是注意：C#中不能包含任何静态成员。一个类可以实现多个接口，当一个类继承某个接口时，它不仅要实现该接口定义的所有方法，还要实现该接口从其他接口中继承的所有方法。定义方法为：
public interface System.IComparable
{
int CompareTo(object o);
}
public class TestCls: IComparable
{
public TestCls()
{
}
private int _value;
public int Value
{
get { return _value; }
set { _value = value; }
}
public int CompareTo(object o)
{
//使用as模式进行转型判断
TestCls aCls = o as TestCls;
if (aCls != null)
{
//实现抽象方法
return _value.CompareTo(aCls._value);
}
}
} 什么是抽象类？ 抽象类提供多个派生类共享基类的公共定义，它既可以提供抽象方法，也可以提供非抽象方法。抽象类不能实例化，必须通过继承由派生类实现其抽象方法，因此对抽象类不能使用new关键字，也不能被密封。如果派生类没有实现所有的抽象方法，则该派生类也必须声明为抽象类。另外，实现抽象方法由overriding方法来实现。定义方法为：
/// <summary>
/// 定义抽象类
/// </summary>
abstract public class Animal
{
//定义静态字段
protected int _id;
//定义属性
public abstract int Id
{
get;
set;
}
//定义方法
public abstract void Eat();
//定义索引器
public string this[int i]
{
get;
set;
}
}
/// <summary>
/// 实现抽象类
/// </summary>
public class Dog: Animal
{
public override int Id
{
get {return _id;}
set {_id = value;}
}
public override void Eat()
{
Console.Write("Dog Eats.")
}
}
相同点和不同点 相同点 都不能被直接实例化，都可以通过继承实现其抽象方法。 都是面向抽象编程的技术基础，实现了诸多的设计模式。 不同点
接口支持多继承；抽象类不能实现多继承。 接口只能定义抽象规则；抽象类既可以定义规则，还可能提供已实现的成员。 接口是一组行为规范；抽象类是一个不完全的类，着重族的概念。 接口可以用于支持回调；抽象类不能实现回调，因为继承不支持。 接口只包含方法、属性、索引器、事件的签名，但不能定义字段和包含实现的方法；抽象类可以定义字段、属性、包含有实现的方法。 接口可以作用于值类型和引用类型；抽象类只能作用于引用类型。例如，Struct就可以继承接口，而不能继承类。 通过相同与不同的比较，我们只能说接口和抽象类，各有所长，但无优略。在实际的编程实践中，我们要视具体情况来酌情量才，但是以下的经验和积累，或许能给大家一些启示，除了我的一些积累之外，很多都来源于经典，我相信经得起考验。所以在规则与场合中，我们学习这些经典，最重要的是学以致用，当然我将以一家之言博大家之笑，看官请继续。规则与场合 请记住，面向对象思想的一个最重要的原则就是：面向接口编程。 借助接口和抽象类，23个设计模式中的很多思想被巧妙的实现了，我认为其精髓简单说来就是：面向抽象编程。 抽象类应主要用于关系密切的对象，而接口最适合为不相关的类提供通用功能。 接口着重于CAN-DO关系类型，而抽象类则偏重于IS-A式的关系； 接口多定义对象的行为；抽象类多定义对象的属性； 接口定义可以使用public、protected、internal 和private修饰符，但是几乎所有的接口都定义为public，原因就不必多说了。 “接口不变”，是应该考虑的重要因素。所以，在由接口增加扩展时，应该增加新的接口，而不能更改现有接口。 尽量将接口设计成功能单一的功能块，以.NET Framework为例，IDisposable、IDisposable、IComparable、IEquatable、IEnumerable等都只包含一个公共方法。 接口名称前面的大写字母“I”是一个约定，正如字段名以下划线开头一样，请坚持这些原则。 在接口中，所有的方法都默认为public。 如果预计会出现版本问题，可以创建“抽象类”。例如，创建了狗（Dog）、鸡（Chicken）和鸭（Duck），那么应该考虑抽象出动物（Animal）来应对以后可能出现风马牛的事情。而向接口中添加新成员则会强制要求修改所有派生类，并重新编译，所以版本式的问题最好以抽象类来实现。 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。 对抽象类不能使用new关键字，也不能被密封，原因是抽象类不能被实例化。 在抽象方法声明中不能使用 static 或 virtual 修饰符。 以上的规则，我就厚颜无耻的暂定为T14条吧，写的这么累，就当一时的奖赏吧。大家也可以互通有无，我将及时修订。 经典示例 绝对经典 .NET Framework是学习的最好资源，有意识的研究FCL是每个.NET程序员的必修课，关于接口和抽象类在FCL中的使用，我有以下的建议： FCL对集合类使用了基于接口的设计，所以请关注System.Collections中关于接口的设计实现； FCL对数据流相关类使用了基于抽象类的设计，所以请关注System.IO.Stream类的抽象类设计机制。 别样小菜 下面的实例，因为是我的理解，因此给经典打上“相对”的记号，至于什么时候晋升为“绝对”，就看我在.NET追求的路上，是否能够一如既往的如此执着，因此我将把相对重构到绝对为止（呵呵）。 本示例没有阐述抽象类和接口在设计模式中的应用，因为那将是另一篇有讨论价值的文本，本文着眼与概念和原则的把握，但是真正的应用来自于具体的需求规范。 设计结构如图所示： 1. 定义抽象类 public 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!");
}
}
2. 定义接口 public interface IAction
{
//定义公共方法标签
void Move();
}
3. 实现抽象类和接口
public 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("Duck also can swim.");
}
}
public 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.");
}
}
4. 客户端实现
public class TestAnmial
{
public static void Main(string [] args)
{
Animal ck = new Duck("Duck");
ck.MakeVoice();
ck.Show();
Animal dog = new Dog("Dog");
dog.MakeVoice();
dog.Show();
IAction dogAction = new Dog("A big dog");
dogAction.Move();
}
}
他山之石 正所谓真理是大家看出来的，所以将园子里有创新性的观点潜列于此，一是感谢大家的共享，二是完善一家之言的不足，希望能够将领域形成知识，受用于我，受用于众。 nai认为：抽象类是提取具体类的公因式，而接口是为了将一些不相关的类“杂凑”成一个共同的群体。至于他们在各个语言中的句法，语言细节并不是我关心的重点。 桦山涧的收藏也很不错。 Artech认为：所代码共用和可扩展性考虑，尽量使用Abstract Class。当然接口在其他方面的优势，我认为也不可忽视。 shenfx认为：当在差异较大的对象间寻求功能上的共性时，使用接口；当在共性较多的对象间寻求功能上的差异时，使用抽象基类。 最后，MSDN的建议是： 如果预计要创建组件的多个版本，则创建抽象类。抽象类提供简单易行的方法来控制组件版本。通过更新基类，所有继承类都随更改自动更新。另一方面，接口一旦创建就不能更改。如果需要接口的新版本，必须创建一个全新的接口。 如果创建的功能将在大范围的全异对象间使用，则使用接口。抽象类应主要用于关系密切的对象，而接口最适合为不相关的类提供通用功能。 如果要设计小而简练的功能块，则使用接口。如果要设计大的功能单元，则使用抽象类。 如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类。抽象类允许部分实现类，而接口不包含任何成员的实现。 结论接口和抽象类，是论坛上、课堂间讨论最多的话题之一，之所以将这个老话题拿出来再议，是因为从我的体会来说，深刻的理解这两个面向对象的基本内容，对于盘活面向对象的抽象化编程思想至关重要。本文基本概况了接口和抽象类的概念、异同和使用规则，从学习的观点来看，我认为这些总结已经足以表达其核心。但是，对于面向对象和软件设计的深入理解，还是建立在不断实践的基础上，Scott说自己每天坚持一个小时用来写Demo，那么我们是不是更应该勤于键盘呢。对于接口和抽象类，请多用而知其然，多想而知其奥吧。
7. C语言编程题：鸡兔鸭同笼问题
无语了 仅供参考= =
#include<stdio.h>
void main()
{
int chicken,ck,rabbit;
int footSum,answerNum;
for(chicken=1,answerNum=0;chicken<=A;chicken++)
{
for(ck=1;ck<=A;ck++)
{
rabbit=A-chicken-ck;
footSum=chicken*2+ck*2+rabbit*4;
if(footSum==B)
printf("第%d个答案:笼子里鸡数量%d\t笼子里鸭数量%d\t笼子里兔子数量%d\n",answerNum);
}
8. 面向对象到底是什么意思
面向对象是可以说是为了软件的健壮性而生。
通过面向对象的方法编程可更轻松，重用性、可维护性等更强
面向对象编程，其实就是把你要编的程序当成一个世界，它由哪些种类构成（类：包含属性，[方法->即此种类所能做的事，如人可以吃东西，取款机可以取款]等），种类之间有什么关系（继承，接口等），再像拼图一样把它拼接好，这就是面向对象
封装是为了类属性、方法的隐蔽，如我们吃肯德基并不需要知道肯德基是怎么做成的，肯德基是个类，鸡是它的属性，制作是它的方法
接口是特征，一些类具有相同的属性、方法等，如鹅、鸭等都会吃，会叫，但具体怎么样吃、叫不一样，那么就在鹅、鸭各自的类里具体实现
汗，这都是我自己的理解，我也正在学，希望没误导你
9. 测试人员学python时，应该如何理解面向对象更合适
与面向对象相对应的是面向过程。python如果不采用面向对象呢，就要采用面向过程。要理解面向对象，我们需要先了解什么是面向过程。
面向过程是流水线思维方式，举例面向过程吃烤鸭，那就是自己去养鸭子,杀鸭子,自己烤鸭子。自己吃。中间过程每一个步骤都是自己去实现。过于注重步骤和过程，不注重职责和分工，这样的话，去开发大型项目，代码会非常复杂。
而面向对象，是上帝思维方式。碰到事情，首先明确职责，然后根据职责来明确不同的对象。比如还是以吃烤鸭为例，吃烤鸭, 创建农民对象，去养鸭子，创建烤鸭店对象去烤鸭子，自己只需要去卖鸭子的店里买烤鸭，吃，再长胖即可。面向对象就是专门应对复杂项目开发，而提供的固定套路。所以一般的编程语言都有面向对象的概念。
10. C语言编程某老板想从5只鸡、6只鸭、7只鹅中任意拿出10只出售,且其中至少有2只
利用循环嵌套循环，循环起始值为2，穷举所有组合，并判断取出其中和为10的组合。
下面是代码：
#include <stdio.h>
int main()
{
int j,y,e,cnt=1;
for(j=2;j<=5;j++)
for(y=2;y<=6;y++)
for(e=2;e<=7;e++)
if(j+y+e==10)
printf("方案%d:鸡%d只，鸭%d只，鹅%d只 ",cnt++,j,y,e);
return 0;
}