接口

接口：比抽象类更抽象的类，是一种规范标准。可以表示一种能力，定义不同层之间的操作标准。
在进行某些公共操作的时候一定要定义出接口
接口和类都是类型
如果没有继承关系，就要用接口(优先考虑)
★接口必须要有子类★
范例：
public interface A{
/*接口里面只能是抽象方法*/
public static final String MSG = "Hello";    //全局变量
public abstract void print();    //抽象方法
}
接口存在抽象方法，所以接口对象★★★不能new进行实例化★★★的操作

注意：
一个子类可以实现（implements）多个接口
◆一个接口可以extends多个接口◆
★类和接口之间  不能（extends），只能（implements）★
★类和类，接口和接口可以继承（extends）★
子类一定要实现（implements）接口的●所有●的方法【重写全部的抽象方法，向上转型】
范例：
/*接口A*/
public interface A {    //定义了接口
String MSG = "Hello";    //全局常量
void print();    //抽象方法，不写访问修饰符默认是public
}

/*接口B*/
public interface B {
public void get();    //这里是抽象方法，可以省略abstract
}

//X类实现了 A和B两个接口
public class X implements A,B{
public void print(){
System.out.println("A接口的抽象方法");
}

public void get(){
System.out.println("B接口的抽象方法");
}
}

public class TestX{
public static void main(String[] args) {
X x = new X();//接口A,B不能实例化    实例化子类对象
A a = x;
B b = x;
a.print();
b.get();
System.out.println(b instanceof A);    /*多个栈空间可以指向同一个堆空间*/
System.out.println(a instanceof B);    /*一个栈空间【不可以】指向多个堆空间*/
}
}

如果X不想实现print方法，就定义X为抽象类，print()为抽象方法，再写一个其非抽象类的子类实现即可
如果既有继承，又有实现，那么先写extends，再写implements，它们的所有抽象方法都要重写
接口里面可以定义普通内部类，抽象内部类，内部接口
如果内部类，内部接口有static，此时内部类称为外部类，或外部接口
范例：
public interface A {
public void fun1();

abstract class B{//内部类
abstract void fun2();
}
}
//看不到内部类B
class H implements A{

@Override
public void fun1() {
System.out.println("A的抽象方法");
}
}

//调用A所有的方法
class D extends A.B implements A{

@Override
public void fun1() {
System.out.println("A的抽象方法");
}

@Override
void fun2() {
System.out.println("B的抽象方法");
}
}

//调用内部类B
class E extends A.B{

@Override
void fun2() {
System.out.println("B的抽象方法");
}
}

应用：USB
/*定义USB接口*/
public interface UsbInterFace {
void start();
void stop();
}

/*要做的事情computer*/
public class Computer{
public void plugIn(UsbInterFace usbInterface) {
usbInterface.start();
usbInterface.stop();
}
}

/*USB的类型1,实现USB*/
public class UDisk implements UsbInterFace {
@Override
public void start() {
System.out.println("U盘开始工作了");
}

@Override
public void stop() {
System.out.println("U盘停止工作了");
}
}

/*USB的类型2,实现USB*/
public class UsbFan implements UsbInterFace{
@Override
public void start() {
System.out.println("电风扇开始工作了");
}

@Override
public void stop() {
System.out.println("电风扇停止工作了");
}
}

/*测试类*/
public class TestComputer {
public static void main(String[] args) {
Computer computer = new Computer();
computer.plugIn(new UsbFan());
computer.plugIn(new UDisk());
}
}

【工厂设计模式】
普通：在Factory类的方法中加if
高级：修改配置
范例1:
/*Fruit接口*/
public interface Fruit {
void eat();
}

/*实现子类1*/
public class Apple implements Fruit {
@Override
public void eat() {
System.out.println("吃苹果");
}
}

/*实现子类2*/
public class Orange implements Fruit {
@Override
public void eat() {
System.out.println("吃橘子");
}
}

/*工厂类，批量生产实现子类*/
public class Factory {
public static Fruit getInstance(String className){
//有多少子类就写多少子类
if ("apple".equalsIgnoreCase(className)) {
return new Apple();
} else if("orange".equalsIgnoreCase(className)){
return new Orange();
} else {
return null;
}
}
}

/*测试类*/
public class TestFruit {
public static void main(String[] args) {
Fruit f = Factory.getInstance("orange");【工厂类.（静态方法）getInstance（“用户输入的实现子类的名称”）】
f.eat();
}
}

范例2:
/**
* 墨盒类
*/
public interface Ink {
public String getColor();
/*接口内的抽象方法，可以有返回值，也可以没有返回值*/
}

/**
* 纸张类
*/
public interface Paper {
public String getSize();
}

public class MyColorInk implements Ink {
@Override
public String getColor() {
return "暗金色";
}
}

public class MyColorInkV3 extends MyColorInk {
@Override
public String getColor() {
return "暗红色";
}
}

public class LaojiuPaper implements Paper{
@Override
public String getSize() {
return "A6L";
}
}

public class LaojiuPaper implements Paper{
@Override
public String getSize() {
return "A6L";
}
}

import java.io.IOException;
import java.util.Properties;

/**
* 配置类
*/
public class Config {
public static Properties props = new Properties();
//静态块-生命周期在整个应用程序运行之前
static{
//加载配置文件
try {
props.load(Config.class.getClassLoader().
getResourceAsStream("MyConfig.properties")
);
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 根据传入的名称得到相应实现类的实例（使用反射技术）
* @param name
* @return
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public static Object getInstance(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
//根据接口名得到实现类的全称
String fullName = getProperty(name);
if(null == fullName) return null;
//得到实现类
Class objClass = Class.forName(fullName);
//返回实现类的实例
return objClass.newInstance();
}

/**
* 根据键得到配置文件中对应的值
* @param key
* @return
*/
public static String getProperty(String key){    //key == 对象
return props.getProperty(key);
}
}

★同一个java projiect中的MyConfig.properties记事本★（控制台输出的结果MyColorInk，LaojiuPaper）
ink=com.ljxy.kenny.printerdemo.MyColorInk
paper=com.ljxy.kenny.printerdemo.LaojiuPaper

【代理设计模式】
范例：
public interface Subject {  //整个操作的核心主题
public void make();     //整个主题的核心功能
}
/*实现子类1*/
public class RealSubject implements Subject {    //真正执行核心功能的人
public void make() {
System.out.println("皇帝陛下正在XX。");
}
}
/*实现子类2-代理*/
public class ProxySubject implements Subject {
private Subject subject;
/*代理的带参构造方法*/
public ProxySubject(Subject subject){
this.subject=subject;
}

@override
public void make() {
this.prepare();
this.subject.make();
this.destory();
}

public void prepare(){
System.out.println("为临幸做准备！");
}

public void destory(){
System.out.println("把娘娘搬走了，皇帝伺候睡觉了！");
}
}

public class TestDemo {
public static void main(String args[]){
Subject sub=new ProxySubject(new RealSubject());//实际实施临幸的RealSubject
sub.make();         //调用的是代理主题操作
}
}