接口,工厂模式

接口(interface):

                概念:

                        相当于特殊的抽象类,定义方式,组成部分和抽象类相似,使用interface关键字定义接口

                特点:

                        没有构造方法,不能够创建对象

                        只能定义:公开静态常量,公开抽象方法       

jdk1.8之前基本使用

                主要两个功能:设置常量和抽象方法

    

public interface Up {
    //设置常量
    //public static final 可以省略
    //public static final String name = "接口";
    String name ="接口";


     //设置抽象方法
    //public abstract 可以省略
    //public abstract void say();
    void say();
}

    实现类

public class MyDisk implements USB {
    
    @Override
    public void work() {
        System.out.println("移动硬盘正在工作");
    }
}

       测试类:

public class Test002 {
    public static void main(String[] args) {
       Commputer commputer = new Commputer();
       commputer.setUsb1(new MyKeyboard());
       commputer.setUsb2(new MyDisk());
       commputer.work();
     }
}

和抽象类的区别:

     相同点:

          都可以被编译成字节码文件

           不能创建对象

           可以作为引用类型

           具有object类中定义的所有方法

    不同点:

         所有属性都是公开静态常量,隐藏了使用了public,static,final修饰

         所有方法都是公开抽象方法,隐藏使用了punlic,abstract修饰

          没有构造方法,动态代码块,静态代码块

          抽象类只能继承一个,但是接口能继承很多个

在jdk1.8之后新增了静态方法和默认方法

 修饰非抽象方法

          语法格式(必须添加default):

interface 接口名 { 
	修饰符 default 返回值类型 方法名() 
	{ 
		代码; 
	} 
}

         接口代码:

public interface MyInterface {
    public default void b(){
        System.out.println("默认的方法b");
    }
}

         实现类代码

class TestObject implements MyInterface{
    //可以重写b但是要把default去掉
    @Override
    public void b() {
        //super.b(); 不可以这样调用
        MyInterface.super.b(); //调用父类的b()方法
    }
}

静态方法:

        基本语法:

interface 接口名 { 
	修饰符 static 返回值类型 方法名() 
	{ 
		代码; 
	}
}

          接口代码

public interface MyInterface {

    public static void c(){
        System.out.println("接口的静态方法");
    }
}

静态方法的调用:

       

public static void main(String[] args) {
        MyInterface.c();
}

非抽象方法和静态方法的区别

        默认方法通过实例调用,静态方法通过接口名调用

        接口默认方法可以被继承,实现类可以直接使用接口默认方法,也可以重写接口默认方法

        静态方法不能被继承,实现类不能重写接口静态方法,只可以用接口名调用

接口的应用

        微观概念:接口是一种能力和约定

        接口的定义:代表某种能力

        方法的定义:代表能力的具体要求

                java单继承,当父类满足不了子类的需求时,可以用接口扩充子类的需求

                接口为多继承,可以为类扩充需求

                父亲作为方法的形参,传入具体的子类对象

                父类当作方法的返回值，返回的是具体的子类的对象

                接口当作方法的形参、传入具体的实现类的对象

                接口当作方法返回值，返回的是具体的实现类的对象

回调原理:

       接口回调,先有接口的使用者,再有接口的实现者

接口的好处:

      程序的耦合性降低了:

      更加自然的使用了多态

      设计和实现完全分离

      更容易搭建程序框架

      更容易更换具体实现

设计模式

       概念:

              一套被反复使用,多数人知晓的,经过分类编目的,代码经验总结.

              可以理解为一些特定的问题,的一套固定的解法

好处:

         使用设计模式是为了重用代码,让代码更容易让别人理解,保证代码的可靠性,重用性.

工厂设计模式

          开发中有一项特别重用的原则"开闭原则",对扩展开发,对修改封闭.

          工厂模式主要负责创建对象问题

          可以通过反射进行工厂模式的设计,完成创建动态对象的创建

案例:

     Usb类：

/**
 * 父类产品
 * @author wgy
 *
 */
public interface Usb {
	void service();
}

        Mouse类：

public class Mouse implements Usb{

	@Override
	public void service() {
		System.out.println("鼠标开始工作了.....");
	}

}

Fan类：

public class Fan implements Usb{

	@Override
	public void service() {
		System.out.println("风扇开始工作了...");
	}

}

KeyBoard类：

public class KeyBoard implements Usb{

	@Override
	public void service() {
		System.out.println("键盘开始工作了...");
	}

}

UsbFactory类：

public class UsbFactory {
	public static Usb createUsb(int type) {.
		Usb usb=null;
         switch(type){
             case 1:
                 usb = new Mouse();
                 break;
             case 2:
                 usb = new Fan();
                 break;
             case 3:
                 usb= new KeyBoard();
                 break;
         }
		
		return usb;
	}
}

TestUsb测试类：

public class TestUsb {
	public static void main(String[] args) throws Exception{
		System.out.println("=========请选择 1 鼠标  2风扇 3 u盘===========");
		Scanner input=new Scanner(System.in);
		int choice=input.nextInt();
		Usb usb=UsbFactory.createUsb(choice);
		if(usb!=null) {
			System.out.println("购买成功");
			usb.service();
		}else {
			System.out.println("购买失败，您要购买的产品不存在");
		}
	}
}