创建一个接口. 新建类->新建接口 . 接口都是I开头, 且默认public 不用写public

接口的作用: 只改变了传入的参数, 就实现了多态, 而且对ErissonPhone和NokiaPhone没有做出修改, 减少了耦合性. 解耦, 松耦合, 功能的提供方可以快速替换

using System;

namespace ConsoleTest1
{
    class Program
    {
        static void Main(string[] args)
        {
            //多态实现1
            //PhoneUser user = new PhoneUser(new NokiaPhone());
            /*
            PhoneUser user = new PhoneUser(new NokiaPhone());
            user.UsePhone();
            的结果
            Nokia calling...
            Nokia Picking...
            Nokia Sending...
            Nokia Recieving...
             */
            PhoneUser user = new PhoneUser(new ErissonPhone());
            user.UsePhone();
            /*
            Erisson calling...
            Erisson Picking...
            Erisson Sending...
            Erisson Recieving...
             */
            Console.ReadKey();

            //接口的作用: 只改变了传入的参数, 就实现了多态, 而且对ErissonPhone和NokiaPhone没有做出修改, 减少了耦合性
        }
    }

    class PhoneUser
    {
        private IPhone _phone;

        //通过构造函数传入参数, 对字段_phone初始化, 只要是继承 IPhone 接口的类都可以, 并实现其方法
        public PhoneUser(IPhone phone)
        {
            _phone = phone;
        }

        public void UsePhone()
        {
            _phone.Dail();
            _phone.PickUp();
            _phone.Send();
            _phone.Recieve();
        }
    }

    interface IPhone
    {
        void Dail();
        void PickUp();
        void Send();
        void Recieve();
    }

    class NokiaPhone : IPhone
    {
        public void Dail()
        {
            Console.WriteLine("Nokia calling...");
        }

        public void PickUp()
        {
            Console.WriteLine("Nokia Picking...");
        }

        public void Recieve()
        {
            Console.WriteLine("Nokia Recieving...");
        }

        public void Send()
        {
            Console.WriteLine("Nokia Sending...");
        }
    }

    class ErissonPhone : IPhone
    {
        public void Dail()
        {
            Console.WriteLine("Erisson calling...");
        }

        public void PickUp()
        {
            Console.WriteLine("Erisson Picking...");
        }

        public void Recieve()
        {
            Console.WriteLine("Erisson Recieving...");
        }

        public void Send()
        {
            Console.WriteLine("Erisson Sending...");
        }
    }
}

/**

• 接口规则:
• 1.接口中的方法不能实现.没有实现的方法也叫抽象方法
• 2.接口中最主要的成员就是:常量和抽象方法
• 3.接口不能实例化,需要其他的类来实现它
• 4.一个类可以实现多个接口,以逗号分隔,还可以继承自其他类(单继承)
• 5.接口可以继承自另外一个接口,继承里边的抽象方法
  */

package fly;

public interface YunDong {

}

package fly;

public interface Fly extends YunDong{

	public void doFly();
}

package fly;

/**
 * 一个类实现了一个接口,他就必须要实现接口中的所有抽象方法
 */
public class DaYan implements Fly {

	@Override // 注解,子类重写父类时写错了会给报错
	public void doFly() {
		System.out.println("大雁在飞");
	}

}

package fly;

public class MaQue implements Fly {

	@Override // 注解,子类重写父类时写错了会给报错
	public void doFly() {
		System.out.println("麻雀在飞");
	}

}

package fly;

public class Plane implements Fly {

	@Override
	public void doFly() {
		System.out.println("飞机在飞");

	}

}

package fly;

public class ShenFei {

	public void testFly(Fly fly) {
		fly.doFly();
	}
}

package fly;

public class Test {

	public static void main(String[] args) {
		ShenFei sf = new ShenFei();
		Fly dayan = new DaYan();//声明为接口类型
		Fly Maque = new MaQue();
		Fly plane = new Plane();
		sf.testFly(plane);

		/*
		 * 多态:
		 * 一个父类的引用,指向它的子类对象
		 * 一个接口的引用,指向它的实现类对象
		 * 即多态可以用继承来实现也可以用接口来实现
		 * 如果存在继承关系,那么就用继承实现多态
		 * 如果不存在继承关系,那么就用接口实现多态
		 * 趋势是:都倾向于使用接口实现多态
		 * 
		 * 继承更多的体现在重用方面
		 * 接口更多的体现在多态(制定规范)
		 * 
		 * 面向对象最终实现的目标:可扩展 可重用 灵活性好
		 * 
		 */
	}

}

1 题目

使用类的继承和接口实现多态举例

2 源代码

2.1 使用接口实现多态

2.1.1 源代码

abstract class Vehicle  //交通车辆抽象类
{
	abstract void consume();//使用能源
}

interface fare    //费用接口
{
	void charge();  //收费
}

class Bus extends Vehicle implements fare   //公共汽车
{
	@Override
    void consume()       //实现抽象类的抽象方法
	{
		System.out.println("此公交使用电力驱动");
	}
	
	@Override
	public void charge()       //实现接口的抽象方法
	{
		System.out.println("此公交收费1元/人");
	}
}

public class TestBus
{
	public static void main(String[] args)
	{
		Bus bus = new Bus();
		bus.consume();
		bus.charge();
	}
}

2.1.2 运行结果

2.2 使用类继承实现多态

2.2.1 源代码

abstract class Animal    //定义抽象类
{
	String name;
	int age;
	abstract public void cry();  //定义抽象方法，动物会叫
}
 
/*class Animal   //定义基类
{
	String name;
	int age;
	public void cry()
	{
	 System.out.println("动物会叫");
    }
}*/

class Dog extends Animal   //定义子类Dog,继承先后向类Animal
{
	@Override
	public void cry()   //实现父类cry()方法
	{
		System.out.println("汪汪叫...");
	}
}

class Cat extends Animal   //定义子类Cat,继承抽象类Animal
{
	@Override
	public void cry()   //实现父类cry()方法
	{
		System.out.println("喵喵叫...");
	}
}

public class AnimalCry 
{

	public static void main(String[] args) 
	{
		Dog dog = new Dog();
		dog.cry();         //调用子类方法，不会产生歧义，强耦合
		Cat cat = new Cat();
		cat.cry();         //调用子类方法，不会产生歧义，强耦合
		System.out.println("......");
		//后期动态绑定：根据对象类型选择相应的方法
		Animal ani1 = new Dog();  //向上转型安全
		ani1.cry();
		Animal ani2 = new Cat();   向上转型安全
		ani2.cry();
	}

}

2.2.2 运行结果