java中的接口知识（单例模式、静态代理、工厂模式）！

1. 接的定义
   接口是特殊的抽象类
   接口的优点：定义开发规范
   提高代码的复用性
   解耦
   多实现类只能单继承
   在jdk1.7及之前接口中只能存在公共的静态的常量+公共的抽象方法

•  公共的静态的常量:
  

•  	public static final 数据类型 变量名=赋值;
  

•  	修饰符可以省略,默认存在
  

•  公共的抽象的方法:
  

•  	public abstract 返回值类型  方法名();
  

•  	修饰符可以省略,默认存在
  

•  使用:类名.常量名 |实现类名.常量名|实现类对象.常量名
  

•  	实现类对象.方法名();
  

• 注意:

•  1.定义接口interface关键字
  

•  2.抽象方法必须重写
  

•  3.接口如何使用:
  

•  	具体的实现类去实现接口,重写里面的抽象方法 按需扩展
  

•  	抽象的实现类实现接口,重写部分抽象方法按需扩展
  

•  4.实现和继承很像,都能使用父类或者父接口中的功能
  

•  5.接口不能实例化
  

•  6.类只能继承类,继承只能单继承,类可以多实现接口,一个类可以实现多个接口
  

•  7.接口和接口之间只能继承不能实现,接口可以继承多个接口
  

•  8.避免实现的多个接口中存在同名方法
  

• jdk1.8新增:

•  1.default默认方法,是个具体的方法,只能通过实现类的对象使用
  

•  2.静态方法,只能在当前接口中使用,不能通过实现类使用
  

public abstract class InterfaceDemo01 {
public static int a=5;
}
//定义接口
interface MyInterface{
//公共的静态常量
int A=10;
//公共的抽象方法
public abstract void haha();
void hehe();
/默认方法
public default void test(){
System.out.println(“我是默认方法…”);
}
//静态方法
public static void testStatic(){
System.out.println(“我是静态方法…”);
}
}
//接口的实现类
class ZhaoKunPeng implements MyInterface{

@Override
public void haha() {
	System.out.println("赵鲲鹏在哈哈笑");
}
@Override
public void hehe() {
	System.out.println("赵鲲鹏在hehe笑");
}

}
//重写部分抽象方法的实现类 抽象子类|抽象实现类
abstract class LiuXiaoQiang implements MyInterface{

@Override
public void haha() {
	System.out.println("刘小强在哈哈哈哈笑");
}

}

class Demo extends LiuXiaoQiang{

@Override
public void hehe() {
}	
@Override
public void haha() {
	System.out.println("哈哈哈哈笑");
}
//新增方法
public void houhou() {
	System.out.println("houhou笑");
}

}
3.简单的工厂模式：
简单工厂模式:

• ① 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
  ② 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
  ③ 具体产品角色：工厂类所创建的对象就是此角色的实例。在 Java 中由一个具体类实
  现。
  public class Factory {
  public static void main(String[] args) {
  // QQ qq=new QQ();
  // qq.run();

  Car car=carFactory("Auto");
  car.run();
  

  }

  //工厂
  public static Car carFactory(String type){
  Car car=null;
  if(type.equals(“QQ”)){
  car=new QQ();
  }else{
  car=new Auto();
  }
  return car;
  }
  }
  //父接口
  interface Car{
  void run();
  }
  //实现类 QQ
  class QQ implements Car{

  @Override
  public void run() {
  System.out.println(“QQ在跑…”);
  }

}

//实现类 Auto
class Auto implements Car{

@Override
public void run() {
	System.out.println("Auto在跑...");
}

}
4.二十三中设计模式之一单例
单例模式:这个类只能有一个实例

• 饿汉式: 无论是否使用,在类加载的时候先创建一个对象 线程安全的 --效率低

• 懒汉式: 在使用的时候才创建对象,不适用不创建 线程不安全的–效率高,通过加锁控制

• 实现单例的步骤:

• 1.私有的构造器

• 2.私有的静态的该类引用

• 3.公共的静态的访问方式

• 实现饿汉式单例

• public class Single {
  //2.私有的静态的该类引用 存储创建的这个类的实例
  private static Single single=new Single();
  //1.私有的构造器
  private Single(){
  }
  //3.公共的静态的访问方式
  public static Single newInstance(){
  return single;
  }
  }

• 懒汉式单例
  */
  public class SingleTon {
  //2.私有的静态的该类的引用
  private static SingleTon singleTon=null;
  //1.构造器私有化
  private SingleTon(){}

  //3.公共的静态的访问方式
  public static SingleTon newInstance(){
  if(singleTon==null){
  singleTon=new SingleTon();
  }
  return singleTon;
  }
  }
  //测试
  public class Test {
  public static void main(String[] args) {
  //测试饿汉式单例
  Single sin=Single.newInstance();
  System.out.println(sin);
  System.out.println(Single.newInstance());
  //测试懒汉式
  System.out.println(SingleTon.newInstance());
  System.out.println(SingleTon.newInstance());
  }
  }

5.静态模式
1.代理角色,真实角色实现相同的接口|继承相同的父类

• 2.代理角色持有真是角色的引用
• 3.代理行为
• 解耦,提高的代码的服用性,便于代码的后期维护
• 代理角色:Hr
• 真实角色:项目经理
• 接口:录用人
• public class StaticProxy {
  public static void main(String[] args) {
  Manager manager=new Manager();
  Hr hr=new Hr(manager);
  hr.addUser();
  }
  }
  //录用人
  interface AddUser{
  void addUser();
  }
  //真实角色
  class Manager implements AddUser{
  @Override
  public void addUser() {
  System.out.println(“你被录用了”);
  }
  }
  //代理角色
  class Hr implements AddUser{
  //代理角色持有真是角色的引用–成员属性
  Manager manager=null;
  public Hr() {
  // TODO Auto-generated constructor stub
  }
  public Hr(Manager manager) {
  this.manager=manager;
  }
  @Override
  public void addUser() {
  System.out.println(“筛选简历”);
  manager.addUser();
  System.out.println(“谈薪资”);
  }
  }