JAVA——接口

接口基础概念：

        1、接口也是一种引用数据类型。编译之后也是一个class字节码文件。

        2、接口是完全抽象。（抽象类是半抽象。）或者说接口是特殊的抽象类

        3、接口的定义：
            [修饰符列表] interface 接口名{
            }

        4、接口支持多继承，一个接口可以继承多个接口。

//定义接口
interface A
{
}

interface B
{
}

//一个接口可以继承多个接口。
interface C extends A,B
{
}

        5、接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。没有其他内容了。

        6、接口中所以的元素都是public修饰的。（都是公开的。）

        7、接口中定义抽象方法的时候，public abstract可以省略不写。

        8、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。

        9、接口中的常量中的public static final可以省略不写。

interface MyMath{

	//抽象方法
	public abstract int sum(int a ,int b);
	int add(int a ,int b);

	//常量
	public static final double PI = 3.1415926;
	double G = 9.8;
}

类和接口

    1、类和类之间叫继承，类和接口之间叫实现。
    别多想，你仍然可以将实现看为"继承"。
    继承使用extends关键字。
    实现使用implements关键字完成。

    2、重要结论（******）：当一个非抽象的类实现接口的话，必须将接口中所以的方法实现

    3、接口和接口之间支持多继承，（******）那么一个类也可以同时实现多个接口
        例：对于计算机而言，一个机箱上有多个接口。
      

        interface X{}
        interface Y{}
        interface Z extends X,Y{}
    //=================================//
        interface A{}
        interface B{}
        class C implements A,B{/*有方法要全部实现*/}

    4、接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转，
       编译器没意见。但是运行时可能出现ClassCastException异常。

public static void main(String args[]){
            M m = new E();
            //经过测试：接口和接口在进行强制类型转换的时候，没有继承关系也可以强制转型。
            //但一定要处于，运行时可能出现ClassCastException异常。
            //K k = (K)m;
            if(m instanceof k)
            {
                K k = (K)m;
            }
        }

        interface M{}
        interface K{}
        class E implements M{}

测试过程： 

public class InterfaceTest
{
	public static void main(String args[]){
		//能使用多态吗
		//错误，MyMath是抽象的，不能实例化
		/*new MyMath();*/

		//父类型引用指向子类型对象：
		MyMath mm = new ABC();
		//调用接口中方法（面向接口编程。）
		System.out.println(mm.sum(10,20));

	}
}
//接口
interface MyMath
{
	double PI = 3.1415926;
	int sum(int a, int b);
	int sub(int a, int b); 
}


//非抽象类
//错误: ABC不是抽象的, 并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class ABC implements MyMath{

}
*/

//编译通过
class ABC implements MyMath
{
	//重写/覆盖/实现 接口中的方法（同常叫做实现。）
	public int sum(int a, int b){
		return a + b;
	};
	public int sub(int a, int b){
		return a - b;
	};
}

Extends 和 Implements

继承和实现都存在的话，代码如何写？
        extends关键字在前, implements关键字在后。
        能插拔的是接口，没有接口怎么插拔呢。
        “内存条插到主板上，他们之间有接口，内存条可以更换。”
    接口通常提取的是行为动作。 

实现程序：

public class InterfaceTest02 
{
	public static void main(String args[]){
		//创建对象：(表面看Animal类没有起作用)
		Flyable f = new Cat();//多态
		f.fly();
	}
}

class Animal
{

}

//可飞翔的接口（翅膀）
//能插拔的是接口，没有接口怎么插拔呢
//内存条插到主板上，他们之间有接口，内存条可以更换
interface Flyable
{
	void fly();
}

//Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变得可以飞翔。
class Cat extends Animal implements Flyable
{
	public void fly(){
		System.out.println("飞猫起飞！");
	}
}


//如果你不想让它飞，不实现接口
class Snake extends Animal
{

}

  接口的基础语法
        1、接口是一种“引用数据类型”。
        2、接口是完全抽象的。
        3、接口怎么定义：[修饰符列表] interface 接口名{}
        4、接口支持多继承。
        5、接口中只有常量+抽象方法。
        6、接口中所有的元素都是public修饰的
        7、接口中抽象方法的public abstract可以省略。
        8、接口中常量的public static final可以省略。
        9、接口中方法不能有方法体。
        10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。
        11、一个类可以实现多个接口。
        12、extends和implements可以共存，extends在前，implements在后。
        13、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。

接口在开发中的作用

注意：接口在开发中的作用，类似于多态在开发中的作用。

多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力

           /*
            public class Master{
                public void feed(Dog d){}
                public void feed(Cat c){}
                //假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
                //这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
            }
            */

            public class Master{
                public void feed(Animal a){
                    // 面向Animal父类编程，父类是比子类更抽象的。
                    //所以我们叫做面向抽象编程，不要面向具体编程。
                    //这样程序的扩展力就强。
                }
            }

接口在开发中的作用
            接口是不是完全抽象？是。
            而我们以后正好要求，面向抽象编程。
            面向抽象编程这句话以后可以修改为：面向接口编程。
            有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。

            主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新
            买一个换下来。这叫做高扩展性。（低耦合度。）

            接口在现实世界中是不是到处都是呢？
                螺栓和螺母之间有接口
                灯泡和灯口之间有接口
                笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
                接口有什么用？扩展性好。可插拔。
                接口是一个抽象的概念。
            
            分析：
                中午去饭馆吃饭，这个过程中有接口吗？

                    接口是抽象的。    

                    菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）

                    谁面向接口调用。（顾客面向菜单点菜，调用接口。）

                    谁负责实现这个接口。（后台的厨师负责把西红柿鸡蛋做好！是接口的实现者。）

                    这个接口有什么用呢？
                        这个饭馆的“菜单”，让“顾客”和“后厨”解耦合了。
                        顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通。
            代码演示：菜单、顾客、厨师

/*
	接口：菜单，抽象的
*/

public interface FoodMenu{

	void TomatoOmelette();

	void StewedNoodles();

}

//顾客
public class Customer{
	//顾客手里有菜单
	//Customer has a FoodMenu!
	//以后凡是能用 has a 来描述的，统一以属性的方式存在。
	//实例变量，属性
	private FoodMenu foodmenu;  //封装
}

Customer has a FoodMenu!
以后凡是能用 has a 来描述的，统一以属性的方式存在。

实现： FoodMenu foodmenu;(声明实例变量)

Cat is a Animal!
但凡满足用 is a 来描述的，都可以设置为继承。

实现：
            public class Cat extends Animal{  } (继承)

//1号厨师实现菜单上的菜
public class Cook1 implements FoodMenu{
	public void TomatoOmelette(){
		System.out.println("1号厨师做的西红柿炒蛋");
	}

	public void StewedNoodles(){
		System.out.println("1号厨师做的烩面");
	}
}

厨师是菜单（接口）的实现者（implements） 

整个测试程序：

public class Test
{
	public static void main(String args[]){
		
		//创建厨师对象
		FoodMenu cook1 = new Cook1();

		//创建顾客对象
		Customer customer = new Customer(cook1);

		//顾客点菜
		customer.order();

	}
}

public interface FoodMenu{

	void TomatoOmelette();

	void StewedNoodles();

}

public class Cook1 implements FoodMenu{
	public void TomatoOmelette(){
		System.out.println("1号厨师做的西红柿炒蛋");
	}

	public void StewedNoodles(){
		System.out.println("1号厨师做的烩面");
	}
}

public class Customer{
	//顾客手里有菜单
	//Customer has a FoodMenu!
	//以后凡是能用 has a 来描述的，统一以属性的方式存在。
	//实例变量，属性
	private FoodMenu foodmenu;	//封装

	public Customer(){
	}
	public Customer(FoodMenu foodmenu){
		this.foodmenu = foodmenu;
	}

	public void setFoodMenu(FoodMenu foodmenu){
		this.foodmenu = foodmenu;
	}
	public FoodMenu getFoodMenu(){
		return foodmenu;
	}

	//提供一个点菜的方法
	public void order(){
		//先拿到菜单才能点菜
		//调用get方法
		//FoodMenu fm = this.getFoodMenu();
		//不调用get方法
		foodmenu.TomatoOmelette();
		foodmenu.StewedNoodles();
		
	}
}

总结一句话：三个字“解耦合”
                面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
                接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

                接口可以解耦合，解开的是谁和谁的耦合！！！
                任何一个接口都有调用者和实现者。
                接口可以将调用者和实现者解耦合。
                调用者面向接口调用。
                实现者面向接口编写实现。

                以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，
                模块和模块之间采用接口衔接。降低耦合度。

类型和类型之间的关系

is a（继承）、has a（关联）、like a（实现）

            is a：
                Cat is a Animal（猫是一个动物）
                凡是能够满足is a的表示“继承关系”
                A extends B

            has a：
                I has a Pen（我有一支笔）
                凡是能够满足has a关系的表示“关联关系”
                关联关系通常以“属性”的形式存在。
                A{
                    B b;
                }
            
            like a:
                Cooker like a FoodMenu（厨师像一个菜单一样）
                凡是能够满足like a关系的表示“实现关系”
                实现关系通常是：类实现接口。
                A implements B

抽象类和接口的区别

在这里我们只说一下抽象类和接口在语法上的区别。
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

        抽象类是半抽象的。
        接口是完全抽象的。

        抽象类中有构造方法。
        接口中没有构造方法。

        接口和接口之间支持多继承。
        类和类之间只能单继承。

        一个类可以同时实现多个接口。
        一个抽象类只能继承一个类（单继承）。

        接口中只允许出现常量和抽象方法。
       
        以后接口使用的比抽象类多。一般抽象类使用的还是少。
        接口一般都是对“行为”的抽象。

最后

以上就是无奈发卡为你收集整理的JAVA——接口的全部内容，希望文章能够帮你解决JAVA——接口所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。