接口设计模式内部类的初步了解

Posted 2020-11-16 wuzhaoming

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了接口设计模式内部类的初步了解相关的知识，希望对你有一定的参考价值。

接口

可以理解为特殊的抽象类

关键字interface -->接口

接口的优点

接口是功能体的集合
是一个引用数据类型
能够解耦
规定开发规范

jdk在1.7之前

属性:

必须是公共的静态的常量 public static final

public staic final 可以选择性省略(默认)

方法:必须是公共的抽象的方法

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

public absract 可以选择性省略

注意:

接口的实现与类的继承非常像,但是不一样在:
1. 子类继承父类就可以直接使用父类的内容
2. 实现类实现接口,也拥有接口中的能力,但是需要实现列自己去实现这个功能
3. 接口实现的关键字是implement,继承的关键字是extends
类只能单继承,接口可以多实现,一个类需要继承父类后实现接口.
1. 如果先接口后继承,会造成系统无法判断接口的个数.
接口也不能实例化
接口的使用只能通过类去实现接口
1. 具体的实现类:重写了所有的抽象方法+按需新增
2. 抽象类的实现:按需重写了抽象方法+按需新增,具体的子类才能使用
  1. 在抽象类中,可以全部实现,也可以部分实现
  //抽象实现类
  
  abstract class Demo02 implements InterfaceDemo02{
  
  // @Override
  
  // public void demo2() {
  
  // // TODO Auto-generated method stub
  
  //
  
  // }
  
  }
继承和实现的几种情况
1. 接口和接口之间是可以继承的
2. 类和接口之间只能实现
3. 接口之间可以多继承
4. 类和接口之间可以多实现

 
//定义一个接口InterfaceDemo02
interface InterfaceDemo02{    public void demo1();}//定义一个接口InterfaceDemo03interface InterfaceDemo03{    public void demo2();}//定义一个接口InterfaceDemo04 并继承InterfaceDemo02及InterfaceDemo03interface InterfaceDemo04 extends InterfaceDemo02,InterfaceDemo03{}

实现了接口

 
public class Demo implements InterfaceDemo02, InterfaceDemo03 {//与只实现InterfaceDemo04作用相同
    @Override    public void demo2() {        System.out.println("实现了接口02");    }    @Override    public void demo1() {        System.err.println("实现了接口03");    }}

jdk1.8中新增的内容

在接口中可以定义方法体的方法

默认方法:default关键字修饰(必须是显式的)
1. 使用:通过实现类使用
静态方法
1. 使用:接口名使用

 
public interface InterfaceDemo05 {
    //默认方法    public default void moren(){        System.out.println("我是默认方法");    }    //静态方法    public static  void test(){        System.out.println("我是静态方法");    }}//实现类class Impl implements InterfaceDemo05{}

测试

 
public class Test {
    public static void main(String[] args) {        //默认方法通过类实现        Impl i=new Impl();        i.moren();        //静态方法通过接口名.方法调用        InterfaceDemo05.test();    }}

设计模型

单例模式

保证一个类只能有一个对象,这个特点形式的类成为单例模式,但是不影响类中原有功能.

实现

构造器私有化
私有的静态的该类引用,存储创建唯一的对象
公共的静态方法方式

两种方式

饿汉式

当第一次调用的时候才创建这个实例 ---线程不安全,效率较高

示例

 
//饿汉式
public class SingTon {//1.构造器私有化    private SingTon(){    }//2.私有的,静态的该类的引用,存储创建唯一的对象    //在类的第一次加载时候,创建一个唯一的实例    private static SingTon single=new SingTon();?//3.公共的 静态的方法方式//返回值:当前数据类型  参数:没有    private static SingTon newInstance(){        //将当前创建的实例返回出去        return single;    }}

懒汉式

在类的第一次加载完成之后,就创建这个实例 ---线程安全,效率较低

示例

 
//懒汉式
public class Single {    //1.私有的构造函数    private Single(){    }    //2.私有的 静态的 该类的引用,存储创建唯一的对象    //先创建一个对象的默认参数为null    private static Single single=null;    //3.公共的静态的该类的引用    public static Single newInstance(){        //先判断实例是不是为空,如果为空则新建        //如果不为空则返回上一次对象的地址        if(single==null){            Single single=new Single();        }            return single;
        }
}

代理模式

静态代理:

真实角色和代理角色实现相同的接口|继承相同的父类
代理角色持有真实角色的引用:成员属性进行维护
代理行为

注意:减少与真实角色的交流,降低耦合度,起到功能的扩展,方便后期维护

 
/*经理要通过人事招人,相当于  技术部经理 找了 人事当代理
真实角色:经理代理:人事  行为:招人(人事和经理都需要实现)代理模式就是把真实角色作为代理角色的一个成员变量*/public class StaticProxy {    public static void main(String[] args) {    }}//经理class Manager implements Hiring{    @Override    public void hiring() {        System.out.println("我是经理,我要招人");    }}//人事class Hr implements Hiring{    Manager manager;    //完全可以通过构造函数把真实角色引入到这个代理角色中    public Hr(Manager manager) {        super();        this.manager = manager;    }    @Override    public void hiring() {        System.out.println("我是人事,我要初试");        //重头戏 把真实角色当成代理模式的一个成员        this.manager.hiring();        System.out.println("成功录取");    }}//行为:招人interface Hiring{    void hiring();}//测试class Test{    public static void main(String[] args) {        Manager m=new Manager();        Hr h=new Hr(m);        h.hiring();    }?}

工厂模式

 
/*
 *需求:我们直接从工厂拿车,如果是两轮输出两轮 *      四轮输出四轮  *  */public class Factory {?    public static void main(String[] args) {        Car two=new TwoCar();        Car four=new FourCar();        Factory f=new Factory();        two.make();        f.factory(two);        two.run();        four.make();        f.factory(four);        four.run();    }    /*     有一家工厂可以造两个轮子也可以造四个轮子    一工厂是可以生产车的,这个是一个功能(方法)    结果:确定这个是方法    二工厂是可以生产不同的车的,可以创建不同的对象    结果:确定方法体的内容    三工厂无论生产哪种类型的车都是车,所以返回值一定是车    结果:确定返回值类型    四工厂生产车,需要给输入值    结果:确定参数    */    //看传入的是否是 TwoCar或ForCar的一个实例    public static Car factory(Car srt){        if(srt instanceof TwoCar){            System.out.println("在造两轮");        }        if(srt instanceof FourCar){            System.out.println("在造四轮");        }            return srt;    }}interface Car{    void make();    void run();}class TwoCar implements Car{?    @Override    public void make() {        System.out.println("我是造两轮的模板");    }?    @Override    public void run() {        System.out.println("乌龟");    }}class FourCar implements Car{?    @Override    public void make() {        System.out.println("我是造四轮的模板");    }?    @Override    public void run() {        System.out.println("飞一样的感觉");    }}