杂谈面向对象设计模式

最新推荐文章于 2024-10-01 22:09:33 发布
最新推荐文章于 2024-10-01 22:09:33 发布
阅读量945 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/koffuxu/article/details/44828415
版权
Interface in Java & 工厂模式

Java（或者说面向对象）语言几点规则
1，复用性强
2，高内聚，低耦合
3，开闭原则（对扩展开放；对修改封闭）
4，针对接口编程，不针对实现编程



高内聚、低耦合 的理念怎么说？
高内聚：是一个类专注做一件事，这样可以提高复用性；
低耦合：减少类与类之间的耦合性，这样可以避免后期维护使得；（比如《利用Java的反射与代理机制实现IOC》一文中提到的Chines类与American类就存在很强的耦合性）
其实，Java中很多设计模式就是为了实现这两个理念而产生的。

1，引出
Android中有很多接口，比较Watchdog.Monitor
Watchdog.java
    public interface Monitor {
        void monitor();
    }
注：这个接口还在Watchdog中，这里显然不是一种 规范，是一种 注入机制？
“反射是java根据类名创建类对象的一种机制，IOC是根据这种机制实现的，依赖注入是实现IOC的一种技术”

还有在Java的线程中有一个Runnable接口，类通过实现Ruunable接口来达到多线程机制
public class TestThread {
     public static void main(String[] args){
          Runnable1  r1 = new Runnable1();
          //阻塞式执行，先执行完run()方法 ，再向下执行
          //r1.run();          

          //在线程中执行，与main thread交替执行
          Thread t = new Thread( r1);
          t.start();

          for(int i=0; i<100; i++){
               System.out.println("Main Thread" + i);
          }
     }
}

class Runnable1 implements Runnable{
     public void run(){
          for(int i=0; i<100; i++){
               System.out.println("Runnable1" + i);
          }
     }
}

2，形象解释（来自zhihu）
接口的作用对于很多新手来说很不容易理解，我给大家举个例子。
接口只是一个规范，所以里面的方法都是空的。
假如我开了一个宠物粮店，声明所有宠物都可以来我这里买粮食，这就相当于一个接口，

public interface PetRestaurant {
public void buy();
}

当一只狗看到了，知道自己是宠物，所以它去实现这个接口
public class DogPet implements PetRestaurant {
@Override
public void buy() {
System.out.println("我是狗，我要买狗粮");
}
}
当一只猫看到了，知道自己也是宠物，所以也去实现这个接口
public class CatPet implements PetRestaurant {
@Override
public void buy() {
System.out.println("我是猫，我要买猫粮");
}

}
当狗和猫来我的店之前，我是不知道他们到底是什么，但是当他们来到我的店，我就知道一个要猫粮食，一个要狗粮食。因为他们都实现了 我这个接口，都可以买。下面这个类相当于一个接待顾客的类，即店小二，他接待所有实现了我这个宠物店接口的动物，传进来一个PetRestaurant 类型的宠物，注意，这个PetRestaurant 是接口
public class test {
public void buy(PetRestaurant pet)
{
pet.buy();
}
}

好了，这个时候我这个老板出现了，我可以给他们卖粮食了，相当于测试类
public class Tests {
public static void main(String[] args) {
PetRestaurant dog = new DogPet(); //实例化一个狗，相当于把狗顾客实例化
PetRestaurant cat = new CatPet();//实例化一个猫，相当于把猫顾客实例化

test t = new test(); //实例化一个店小二
t.buy(cat); //把猫交给店小二
t.buy(dog); //把狗交给店小二
}

}
这样运行的结果就是
我是猫，我要买猫粮
我是狗，我要买狗娘

你知道吗，整个过程我这个店主其实根本不知道来的到底是猫是狗还是其他什么，我只要有一个店小二，把这些来的不知什么动物都全部交给店小二，店小二就知道怎么去卖了，因为这些狗啊猫啊都实现了我这个宠物店的接口，而店小二就负责接待所有实现了我这个接口的动物。这就有一个好处，假如明天来了一头小猪，只要它实现了我这个接口，我只管交给店小二处理就OK了，我这个店小二根本不需要变化，我这个店主也只需要实例化一下这个动物就OK
你想，假如没有接口，会怎么办，来一个猫，我要去创造一个猫，还要实例化，来一只狗，我要创建一只狗，同样要实例化，还要配备专门的店小二去接待，就会相当麻烦


3，类图


4，接口与工厂模式

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦

工厂模式（把构造类交给工厂去生产，避免细节，方便）（不同皮肤，主题的实现就是使用工厂模式）

工厂模式分为
a:简单工厂模式（ 买宠物粮的例子，接口来抽象buy方法，不现的宠物来实现具体的buy。“工厂”就是店小二，）
宝马车才是好说明实例
         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

产品类：

abstract class BMW {
        public BMW(){
                
        }
}

public class BMW320 extends BMW {
        public BMW320() {
                System.out.println("制造-->BMW320");
        }
}
public class BMW523 extends BMW{
        public BMW523(){
                System.out.println("制造-->BMW523");
        }
}

工厂类：

public class Factory {
        public BMW createBMW(int type) {    
                switch (type) {
                
                case 320:
                        return new BMW320();

                case 523:
                        return new BMW523();

                default:
                        break;
                }
                return null;
        }
}


客户类：

public class Customer {
        public static void main(String[] args) {
                Factory factory = new Factory();
                BMW bmw320 = factory.createBMW(320);//有“父类引用指向子类对象”
                BMW bmw523 = factory.createBMW(523);
        }
}
 

产品类：

abstract class BMW {
        public BMW(){
                
        }
}
public class BMW320 extends BMW {
        public BMW320() {
                System.out.println("制造-->BMW320");
        }
}
public class BMW523 extends BMW{
        public BMW523(){
                System.out.println("制造-->BMW523");
        }
}


创建工厂类：

interface FactoryBMW {  //把工厂类也抽象了。
        BMW createBMW();
}

public class FactoryBMW320 implements FactoryBMW{

        @Override
        public BMW320 createBMW() {

                return new BMW320();
        }

}
public class FactoryBMW523 implements FactoryBMW {
        @Override
        public BMW523 createBMW() {

                return new BMW523();
        }
}


客户类：

public class Customer {
        public static void main(String[] args) {
                FactoryBMW320 factoryBMW320 = new FactoryBMW320();
                BMW320 bmw320 = factoryBMW320.createBMW();

                FactoryBMW523 factoryBMW523 = new FactoryBMW523();
                BMW523 bmw523 = factoryBMW523.createBMW();
        }
}



2.0排量两厢车和2.4排量两厢车属于同一个 等级结构
而2.0排量两厢车和2.0排量三厢车属于同一个 产品族
如果工厂的产品全部属于同一个等级结构，则属于工厂方法模式；
如果工厂的产品来自多个等级结构，则属于抽象工厂模式



抽象工厂模式代码

 产品类： 

 

//车子以及型号
abstract class BMW {
        public BMW(){
                
        }
}
public class BMW320 extends BMW {
        public BMW320() {
                System.out.println("制造-->BMW320");
        }
}
public class BMW523 extends BMW{
        public BMW523(){
                System.out.println("制造-->BMW523");
        }
}

//空调以及型号
public class Aircondition {
        public Aircondition(){
                
        }
}
public class AirconditionA extends Aircondition{
        public AirconditionA(){
                System.out.println("制造-->AirconditionA");
        }
}
public class AirconditionB extends Aircondition{
        public AirconditionB(){
                System.out.println("制造-->AirconditionB");
        }
}


创建工厂类：

//创建工厂的接口
public interface FactoryBMW {
        BMW createBMW_A();
        BMW createBMW_B();
        Aircondition createaAirconditionA();
        Aircondition createaAirconditionB();
}
//宝马320系列，生产配置A，B两种空调型号的320汽车
public class FactoryBWM320 implements FactoryBMW{
        
        @Override
        public BMW320 createBMW_A() {
                // TODO Auto-generated method stub
                createaAirconditionA();
                return new BMW320();
        }
        @Override
        public BMW320 createBMW_B() {
                // TODO Auto-generated method stub
                createaAirconditionB();
                return new BMW320();
        }
        @Override
        public Aircondition createaAirconditionA() {
                // TODO Auto-generated method stub
                return new AirconditionA();
        }

        @Override
        public Aircondition createaAirconditionB() {
                // TODO Auto-generated method stub
                return new AirconditionB();
        }
}
//宝马523系列，生产配置A，B两种空调型号的523汽车
public class FactoryBWM523 implements FactoryBMW {

        @Override
        public BMW523 createBMW_A() {
                // TODO Auto-generated method stub
                createaAirconditionA();
                return new BMW523();
        }
        @Override
        public BMW523 createBMW_B() {
                // TODO Auto-generated method stub
                createaAirconditionB();
                return new BMW523();
        }
        @Override
        public Aircondition createaAirconditionA() {
                // TODO Auto-generated method stub
                return new AirconditionA();
        }

        @Override
        public Aircondition createaAirconditionB() {
                // TODO Auto-generated method stub
                return new AirconditionB();
        }

}


客户:

public class Customer {
        public static void main(String[] args){
                
                //想要A型空调宝马320
                FactoryBWM320 factoryBWM320_A = new FactoryBWM320();
                BMW320 bmw320_A = factoryBWM320_A.createBMW_A();
                
                //想要B型空调宝马320
                FactoryBWM320 factoryBWM320_B = new FactoryBWM320();
                BMW320 bmw320_B = factoryBWM320_B.createBMW_B();
                
                //想要A型空调宝马523
                FactoryBWM523 factoryBWM523_A = new FactoryBWM523();
                BMW523 bmw523_A = factoryBWM523_A.createBMW_A();
                
                //想要B型空调宝马523
                FactoryBWM523 factoryBWM523_B = new FactoryBWM523();
                BMW523 bmw523_B = factoryBWM523_B.createBMW_B();
        }
}



extend:
设计模式的6大原则
1，开闭原则：对扩展开放，对修改关闭
2，里氏代换原则:任何基类可以出现的地方,子类也可以出现
3，依赖倒转原则:：要依赖抽象,而不要依赖具体的实现.
4，合成/聚合复用原则（CARP）:要尽量使用合成/聚合原则,而不是继承关系达到软件复用的目的
5，迪米特法则:系统中的类,尽量不要与其他类互相作用,减少类之间的耦合度
6，接口隔离法则:这个法则与迪米特法则是相通的

可夫小子
关注
专栏目录
面向对象设计（OOD）——设计指导编程，不要再半途而废啦
代码之狐的博客
04-19 1921
面向对象设计面向对象设计（OOD）一、面向对象设计过程二、面向对象设计原则三、具体的设计过程欢迎关注我、共勉:star: 面向对象设计（OOD） 一、面向对象设计过程 什么是软件工程的设计过程？ 之前以及分享了一部分面向对象分析的三大模型，接下来仅仅只有模型当然不能算作是一个完整的软件流程，接下来的就是面向对象设计：把模型（需求分析获得）转化为解决方案——主要分为两个部分： 总体设计（系统设计到结构设计） 系统=程序+数据库+人工过程+文档支撑 结构=模块+关系 详细设计（精确描述） 以变量命名+伪
面向对象编程思想杂谈
hebhljdx的博客
05-24 1066
面向对象编程（Object-Oriented Programming, OOP）自上世纪80年代兴起以来，便以其独特的理念和强大的抽象能力，成为软件工程领域的主流编程范式。面向对象编程通过引入类和对象的概念，提供了一种强大的抽象机制，使得软件设计能够更加贴近现实世界的逻辑结构，从而降低了软件的复杂性。然而，随着技术的发展和应用范围的扩大，OOP的一些核心原则在实践中逐渐遭遇挑战，引发了人们对这一编程范式的反思。
设计模式杂谈
最新发布
weixin_41733034的博客
10-01 1476
本文简要概述了23种设计模式的概念和分类标准并讨论了一些与之紧密相关的概念，但尚未涉及详细分析和具体实现，该部分内容请见同一专栏的其他 文章。
面向对象编程之设计模式的形意2
chenlinpsp的专栏
04-01 1554
增强目标对象的访问和控制：被代理的原逻辑的前后执行代理对象自己的业务。在代理方法中委托给目标方法的前后可增加代理自己的业务逻辑，而这些业务逻辑是一些控制对目标方法的访问和控制，或者为目标提供额外的功能（预处理，记录日志、缓存、安全控制、资源管理）等，但是不一定与目标方法有直接关联，也不是增强目标方法的核心业务功能。3、好好照顾自己，注重自己的身心健康，规律生活，不要焦虑，安排好自己的计划，每天完成就行啦，不要给与自己太多压力。4、暂时这么多了，生活是自己的，自己拥有的拥有是有限的，过好自己的每一天！
java面向对象编程杂谈
两只橙的博客
03-29 500
Java程序的发展经历了面向过程，面向对象两个阶段。什么是面向过程和面向对象呢？其实面向过程就是一种以“事件”为中心的编程思想。而面向对象是一种以“事物(即对象)” 为中心的编程思想。打个比喻，面向过程就是不用想去做什么样的盒子，随机取工具就开始制作。而面向对象就是先想好做一个什么样的盒子，再去找对应的工具去做。 在此我就重点谈下java的面向对象编程吧！首先我认为面向对象编程是相对于面向过
设计模式学习与使用杂谈之面向对象设计原则
chenzhen_it的博客
05-09 94
面向对象设计原则 1.SRP:单一职责原则 就一个类而言，其职责应该只有一个.(使类最小颗粒化)。   附件1中的结构，类Ractangle就违反了SRP，Ractangle中的方法draw()方法提供绘制图形的作用,供ComputationGeometryApplication使用,方法area()方法提供计算面积的作用,GraphicalApplication使用,对于Ractan...
《python 3 面向对象编程》读书笔记
Jack's blog
04-02 851
虽然python程序写了很多，还是决心系统的学习一下python面向对象的内容。 花了几周时间读了《python 3 面向对象编程》 ， 重点学习了python的一些设计模式。 装饰器模式：通过包装一个核心对象使得外部对象可以已不同方式于其交互 观察者模式：一个核心对象可以被观察者对象来监控，一旦核心对象的某个值发生变化，它会通知观察者。 策略模式：它实现了对不同对象采用不同解决方案 状态模...
php 面向对象区别,php面向对象和面向过程有什么区别
weixin_30420045的博客
03-16 282
面向过程和面向对象区别有：面向过程效率比面向对象高，面向对象的编程复杂度更高，但是后期面向对象比面向过程好维护。面向对象程序采用inno setup打包，支持静默安装，方便封装时调用，自行加参数即可。smtp模块这么多已定义的类中，我们最常用的的还是smtplib.smtp类，就具体看看该类的用法：smtp实例封装一个smtp连接，它支持所有的smtp和esmtp操作指令，如果host和port参...
设计模式 杂谈
Scalaaaaaa的博客
02-17 322
模式设计应该是在需求分析完了之后进入的一个阶段，这是一个把需求抽象成逻辑骨架的一个过程，在面向对象的世界中，怎么样倒腾对象、接口、成员变量，或者说怎样组合这些，更加有效地、优雅地解决需求。 设计模式中有个开放封闭原则，我的理解是，开放，和易扩展是一个意思，封闭的意思是职责单一，这个职责单一我觉得有很大的可以说道的，一个类的一个方法，到底做的事要多么得细枝末节才能算上职责单一呢？简单的，像
C++与UML：面向对象开发的视觉工具
C++之UML文档探讨了C++语言与统一建模语言(UML)之间的紧密联系，以及UML在软件开发设计中的重要性。UML作为一门面向对象的...在接下来的杂谈中，将会深入探讨设计模式，而这些都将建立在对UML基础理论的扎实理解之上。
程序设计经验杂谈
10-06
在实际开发中，模块化和面向对象设计是提高代码复用性和可维护性的重要手段。通过封装、继承和多态，我们可以创建出结构清晰、职责明确的代码。良好的设计模式如工厂模式、单例模式、观察者模式等，能够在不同的场景...
从开源框架理解设计模式系列#Bridge桥接模式
kimichen123的专栏
09-05 684
what什么是桥接模式 GOF定义：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 HeadFirst定义：不止改变你的实现，也改变你的抽象。 它是一种对象结构型模式，又称为柄体(Handle and Body)模式或接口(Interface)模式。 这里先拋个问题，为什么桥接模式看类图怎么和策略模式有点像，下面具体分析？ why为什么需要桥接模式 当一个类内部具备两种或多种变化维度时，使用桥接模式可以解耦这些变化的维度，使高层代码架构稳定。 在一...
【BlankFox学习笔记-设计模式】Factory工厂模式——更灵活的创建实例
代码之狐的博客
04-24 665
Factory——更灵活的创建实例 笔记版本：2.0 作者：BlankFox（CSDN主页) 归档：设计模式浅谈 写在前面： ps： 所谓 设计模式 就是前人总结的良好代码模板——想象一下：当在求职时被问到一个大概的需求时，能够清晰直接的对他说：“根据XXX设计模式的思想，可以设计如下几个角色…”——这种就好像英语等级考试的作文，恰好命中了你背的那篇模板，清晰的思路以及良好的扩展性和易于理解的结构，会让你爱上你的代码❤️ ps：Factory模式——创建方法的集合，帮助创建对象的”工具人” （能够让
怎样在github上协同开发
热门推荐
可夫小子的频道
09-02 2万+
How to co-work wither parter via github. Github不仅有很多开源的项目可以参考，同样也是协同开发的最佳工具，接下来的就模拟一下协同开发的过程。
Android libdvm.so 与 libart.so
可夫小子的频道
03-31 1万+
Android libdvm.so 与 libart.so 系统升级到5.1之后，发现system/lib/下面没有libdvm.so了，只剩下了libart.so。对于libart模式，从4.4就在Developer optins里面就可以手动选择，到5.1算是转正了。 1，什么是libdvm，libart。 Android KK里引入了ART虚拟机作为Dalvik虚拟机的
Android NDK tombstone分析工具
可夫小子的频道
07-19 8658
Android NDK tombstone分析工具 在Andoird Native库发生异常的时候，Linux会发生不同级别的sig，来结构相关进程的运行，同时会产生tombstone trace文件用于记录发生崩溃寄存器和堆栈的状态。 这里面的涉及的知识点很多，但该文主要是介绍一下这种情况debug的工具stack.py。 1，keypoint a,Android sig/进程间通
Android L日志系统1——logd
可夫小子的频道
12-27 7774
在介绍完Android M之前的日志系统的实现之后，我们现在来看看现在最新的Android L的日志机制。Android L与之前版本最大的变化，就是日志保存的位置由Kernel的Ringer Buffer（前一篇文章已经介绍过）改成用户层Buffer来存储，用户层的Buffer的读定存储设置管理，都由logd这个服务来实现，现在我们来一探究竟。分析完logd之后，再花一篇文章，简单的过一下上层写
Settings中的xml中的值与SettingsProvider中default.xml中的值的区别
可夫小子的频道
05-05 7381
最近在看Settings中的一个默认值的时候，发现有两个地方使用，有点疑问。 这两个defaultval有啥区别？ ./res/xml/sound_settings.xml:109 104     105             android:key="sound_effects" 106             android:title="@string/sound_
Android 关机（reboot）流程
可夫小子的频道
04-17 6149
Base On Android 4.2 recovery 和 reboot流程 part 1. reboot recovery流程。 1,RecoverySystem.java中     private static File RECOVERY_DIR = new File("/cache/recovery");     private static File COMM
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

可夫小子

感谢大佬！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值