接口-13

接口（核心）
基本概念：在之前讲解的类结构都包含有：普通属性，常量（全局常量），构造方法，抽象方法，但是如果说设计一个类的时候发现这个类的内部只存有全局常量和抽象方法的话，则这个类就能将其定义为接口
接口就是全局常量和抽象方法的集合，在java里面使用interface关键字可以进行接口的定义
范例：定义接口
interface A{//定义的是接口
public static String MSG="HELLO WORLD";
public abstract void fun();
}
定义的关键字是有区别，但是其它的常量和抽象方法与之前没有区别，但是对于接口也可以发现，里面包含有抽象方法，所以一定无法直接使用关键字new进行接口对象的实例化，那么接口的使用原则如下：
接口必须有子类，子类使用用implements进行接口实现，一个子类可以同时实现多个接口
接口的子类（如果不是抽象类），则一定要重写接口之中的全部抽象方法；
接口对象可以利用子类的向上转型，进行实例化操作
范例：使用接口
package polymorphic;
interface Aaa{//定义的是接口
public static String MSG="HELLO WORLD";
public abstract void fun();//抽象方法
}
interface Bbb{
public abstract void print();
}
class Xxx implements Aaa,Bbb{//X类同时实现了A,B两个接口
public void fun() {
System.out.println("HELLO");
}
public void print() {
System.out.println(MSG);
}
}
public class Interface {
public static void main(String[] args) {
// TODO Auto-generated method stub
Aaa a=new Xxx();//子类为父接口实例化
Bbb b=new Xxx();//子类为父接口实例化
a.fun();
b.print();
}
}
现在已经学习了普通类，抽象类，接口，三个概念，那么一定要记住的是，如果说现在一个类既要继承抽象类又要实现接口的话，则应该先继承（extends）父类，后实现（implements）接口
范例：让子类继承抽象类和实现接口
package polymorphic;
interface Aaa{//定义的是接口
public static String MSG="HELLO WORLD";
public abstract void fun();//抽象方法
}
interface Bbb{
public abstract void print();
}
abstract class C{//抽象类
public abstract void get();//抽象方法
}
class Xxx extends C implements Aaa,Bbb{//X类同时实现了A,B两个接口
public void get() {
System.out.println("你好");
}
public void fun() {
System.out.println("HELLO");
}
public void print() {
System.out.println(MSG);
}
}
public class Interface {
public static void main(String[] args) {
// TODO Auto-generated method stub
Aaa a=new Xxx();//子类为父接口实例化
Bbb b=new Xxx();//子类为父接口实例化
C c=new Xxx();//子类为父抽象类实例化
a.fun();
b.print();
c.get();
}


}
需要有几个说明
说明一：接口之中全部方法访问权限都是public，不管写与不写都一样，在以后工作之中，大部分的方法规范都是由接口规定的，所以这才有了只要是方法大部分都使用public定义的原因。
说明二：
在接口里面既然全部都是由抽象方法和全局常量组成，所以在定义的时候以下两种定义方式都是一样的
interface A{//定义的是接口 interface A{//定义的是接口
public static String MSG="HELLO WORLD"; String MSG="HELLO WORLD";
public abstract void fun();//抽象方法   void fun();//抽象方法  
} }
说明三：一般在定义接口的时候定义方法是比较多的，而定义全局常量相对少一些。
说明四：一个抽象类可以使用implements实现接口
范例：抽象类实现接口
interface Aaa{//定义的是接口
public static String MSG="HELLO WORLD";
public abstract void fun();//抽象方法
}
interface Bbb{
public abstract void print();
}
abstract class C implements Aaa,Bbb{//抽象类
public abstract void get();//抽象方法
}
class Xxx extends C {//X类同时实现了A,B两个接口
public void get() {
System.out.println("你好");
}
public void fun() {
System.out.println("HELLO");
}
public void print() {
System.out.println(MSG);
}
}
但是一个接口却不能够继承一个抽象类，可是一个接口却可以使用extends关键字继承多个父接口
范例：接口多继承
interface D{
public void printA();
}
interface E{
public void printB();
}
interface F extends D,E{//F继承D,E两个接口
public void printC();
}
class XA implements F{//XA要重写三个抽象方法
public void printA() {}
public void printB() {}
public void printC() {}
}
说明五：任何内部的结构实际上都不受定义的限制，所以在一个接口里面也可以继续定义内部接口或内部抽象类，而且用static定义的内部接口就是一个外部接口
package polymorphic;
interface D{
static interface B{//内部接口加上static等于外部接口
public void fun();
}
}
class Xa implements D.B{//实现内部接口
public void fun() {
System.out.println("hello world");
}
}
public class Interfacea {


public static void main(String[] args) {
// TODO Auto-generated method stub
D.B d=new Xa();
d.fun();
}


}
接口有三个核心功能
使用接口定义规范标准
接口表示一种能力
将服务器的远程视图暴露给客户端。




接口引用--定义规范标准
“接口”这一名词是到处可见，例如：插座，交流语言，USB
如：打印机，U盘都可以插在电脑的USB接口上使用，而使用的规则假设就只有两个：工作，退出。
两个无关的类之间的连接一定依靠接口完成，由接口定义出操作的标准
范例：定义接口标准
interface USB{
public void work();//USB设备工作
public void exit();//退出USB设备
}
范例：定义电脑
class Computer{
public void plugin(USB usb) {//接收USB设备
usb.work();//调用usb接口方法，这个方法是由子类实现的
usb.exit();//完事后退出
}
}
范例：定义USB设备
class Flash implements USB{
public void work() {
System.out.println("U盘开始实现拷贝操作");
}
public void exit() {
System.out.println("U盘结束操作");
}
}
class Print implements USB{
public void work() {
System.out.println("打印机开始进行文档打印");
}
public void exit() {
System.out.println("打印结束，结束工作");
}
}
范例：测试程序：
public class Interfaceb {
public static void main(String[] args) {
// TODO Auto-generated method stub
Computer com=new Computer();
com.plugin(new Flash());
com.plugin(new Print());
}
}
发现电脑和打印机还是两个彼此独立的类，没有直接的定义联系，但是有标准联系
这种的形式在生活中随处可见
如：高速上不允许非机动车行驶
如:本商城不允许宠物入内
接口（和抽象类）就是对类的再次抽象，但是以接口为主（抽象类具备单继承局限，而接口没有）


接口应用（工厂设计模式（Factory，背））
观察代码：：
package polymorphic;
interface Fruit{//水果
public void eat();//吃
}
class Apple implements Fruit{
public void eat() {
System.out.println("吃苹果");
}
}
class Orange implements Fruit{
public void eat() {
System.out.println("吃橘子");
}
}
public class Interfacec {
public static void main(String[] args) {
// TODO Auto-generated method stub
Fruit f=new Apple();
f.eat();
}
}
本程序在实际中不可能用，因为客户端（主方法）应该不可动，客户端直接用了关键字new实例化了接口的子类对象，那么就表示这个时候在客户端
，Fruit接口就与Apple子类绑定在一定，如果要更改子类，则需要修改客户端代码，最好就是客户端不要动。（加入第三个方）
修改代码
package polymorphic;
interface Fruit{//水果
public void eat();//吃
}
class Apple implements Fruit{
public void eat() {
System.out.println("吃苹果");
}
}
class Orange implements Fruit{
public void eat() {
System.out.println("吃橘子");
}
}
class Factory{
public static Fruit getInstance(String className)
{
if("apple".equals(className)) {
return new Apple;
}
if("orange".equals(className)) {
return new Orange;
}
return null;
}
}
public class Interfacec {
public static void main(String[] args) {
// TODO Auto-generated method stub
Fruit f=Factory.getInstance(args[0]);
f.eat();
}
}
接口定义--代理设计模式
实现程序
package polymorphic;
interface Network{//网络连接
public void browse(String url);
}
class RealNetwork implements Network{
public void browse(String url) {
System.out.println("访问站点"+url);
}
}
class ProxyNetwork implements Network{
private Network net;//保存真正的上网连接
// public ProxyNetwork(RealNetwork realNetwork) {
// TODO Auto-generated constructor stub
// }
public void browse(Network net) {
this.net=net;
}
public boolean check(String url) {
if(url.contains("whitehouse")) {
return false;
}
return true;
}
public void browse(String url) {
if(this.check(url)) {
this.net.browse(url);
}
}
public void record(String url) {
System.out.println("上网记录"+url);
}
}
public class Interfacec {
public static void main(String[] args) {
// TODO Auto-generated method stub
Network nw=new ProxyNetwork(new RealNetwork());
nw.browse("www.weibo.com");
nw.browse("www.whitehouse.com");
}
}


总结：抽象类与接口的区别（面试题）

No	区别	抽象类	接口
1	关键字	abstract class 类名称{}	interface 接口名称{}
2	组成	普通方法，构造方法，抽象方法，常量，变量	全局常量，抽象方法
3	权限	各类权限	只能是public权限
4	使用	子类使用extends只能够继承一个父类	子类使用implements可以实现多个接口
5	关系	抽象类可以实现多个接口 接口不能够继承抽象类，但是可以继承多个接口，实现接口多继承
6	设计模式	模板设计模式	工厂设计模式，代理设计模式
7	局限	单继承局限	无局限

通过以上分析可以发现，在项目之中是使用抽象类还是使用接口其实都一样，可是由于接口没有抽象类的单继承局限，那么在整个开发之中
如果发现抽象类和接口都可以使用时，优先使用接口，避免单继承局限


JAVA程序结构就讲解完整了，包含单元有：接口，抽象类，类，对象，继承，