一 : interface关键字
接口是与类并行的一个概念
Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）
① 接口可以看做是一个特殊的抽象类,是常量与抽象方法的一个集合,不能够包含变量,一般的方法
interface AA{
//常量 : 所有的常量都用public static finial修饰 默认的,写不写都有
int I = 15;
// public static final int I = 12;
// public static final boolean FLAG = false;
/*抽象方法
*
* 抽象方法:所有的都用public abstract 修饰
写不写都有
* */
void method1();
void method2();
// public abstract void method1();
// public abstract void method2();
}
② 接口是没有构造器的
③接口定义的就是一种功能,此功能可以被类所实现(implements)
class CC implements AA{
public void method1() {
}
public void method2() {
}
}
④ 实现接口的类,必须要重写其中的所有抽象方法,方可实例化,若没有重写所有的抽象方法,则此类仍为一个抽象类
abstract class BB implements AA{
}
⑤ 在java中的继承是单继承的,但是类可以实现多个接口.
接口 TZ
interface TZ{
void method3();
}
类 CC 实现多个接口
class CC implements AA,TZ{
public void method1() {
}
public void method2() {
}
public void method3() {
}
}
⑥ 接口与接口之间也是继承的关系,而且可以实现多继承.
接口 MM 继承接口 TZ,AA
//java 中接口之间仍为继承关系!(多继承)
interface MM extends TZ,AA{
void method4();
}
二 : 接口与具体的实现类之间存在多态
定义功能接口
interface Runner{
void run();
}
interface Swimmer{
void swim();
}
interface Flier{
void fly();
}
定义接口的实现类
class Duck implements Runner,Swimmer,Flier{
public void run() {
System.out.println("跑啊");
}
@Override
public void swim() {
System.out.println("游泳啊");
}
@Override
public void fly() {
System.out.println("飞翔啊");
}
}
多态的使用
public class TestInterface {
public static void main(String[] args) {
Duck d = new Duck();
TestInterface.test1(d);//Runner r = new Duck();
TestInterface.test2(d);//Swimmer s = new Duck();
TestInterface.test3(d);//Flier f = new Duck();
}
//接口的多态性
public static void test1(Runner r) {
r.run();//虚拟方法调用
}
public static void test2(Swimmer s) {
s.swim();
}
public static void test3(Flier f) {
f.fly();
}
}
三 : 接口的应用
-
面向接口编程,定义一个USB接口,分别实现打印机,手机,相机,U盘的 USB接口功能实现
定义USB接口
interface USB {
// 功能设置为抽象方法
void start();
void stop();
}
实现接口类 :
打印机
class printer implements USB {
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("打印机开始工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("打印机停止工作");
}
}
U盘
class Flash implements USB {
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("U盘开始工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("停止工作");
}
}
电脑类
class Computer {
public void dowork(USB usb) {
usb.start();
System.out.println("---设备开始工作");
usb.stop();
}
}
进行连接实现
public class TestUSB {
public static void main(String[] args) {
Computer com = new Computer();
com.dowork(new printer());
Flash f = new Flash();
com.dowork(f);
}
实现接口匿名类对象
//实现接口的匿名类的对象
USB phone = new USB() {
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止连接");
}
};
System.out.println();
com.dowork(phone);
或者
//实现接口的匿名类的对象
com.dowork(new USB() {
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("手机开始工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("手机停止连接");
}
});
-
工厂设计模式
工厂模式的目的在于程序的可扩展性。而对于简单工厂模式来说，它是为了让程序有一个更好地封装，降低程序模块之间的耦合程度。
对于简单的工厂模式，其实也可以将其理解成为一个创建对象的工具类。
返回对象接口
//接口 返回一个对象
interface IWorkFactory{
Work getWork();
}
学生对象接口
class StudentWorkFactory implements IWorkFactory{
public Work getWork() {
return new Studentwork();
}
}
教师对象接口
class TeacherWorkFactory implements IWorkFactory{
public Work getWork() {
return new TeacherWork();
}
}
work接口
interface Work{
void dowork();
}
学生工作接口
class Studentwork implements Work{
public void dowork() {
System.out.println("学生写作业");
}
}
教师工作接口
class TeacherWork implements Work{
public void dowork() {
System.out.println("老师批改作业");
}
}
使用
public class TestFactoryMethod {
public static void main(String[] args) {
IWorkFactory i = new StudentWorkFactory();
i.getWork().dowork();;
IWorkFactory i1 = new TeacherWorkFactory();
i1.getWork().dowork();
}
}
-
代理设计模式
接口
interface Object{
void action();
}
被代理类
//被代理类
class objectImpl implements Object{
public void action() {
// TODO Auto-generated method stub
System.out.println("===被代理类开始执行");
System.out.println("===具体操作");
System.out.println("===被代理类执行完毕");
}
}
代理类
class ProxyObject implements Object{
Object obj;
public ProxyObject() {
System.out.println("代理类创建成功");
obj = new objectImpl();
}
@Override
public void action() {
// TODO Auto-generated method stub
System.out.println("代理类开始执行");
obj.action();
System.out.println("代理类执行结束");
}
}
调用
public class TestProxy {
public static void main(String[] args) {
Object obj = new ProxyObject();
obj.action();
}
}