面向对象设计原则
在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则
- 设计原则
1.单一职责原则
2.开闭原则
3.里氏替换原则
4.依赖注入原则
5.接口分离原则
6.迪米特原则
1.单一职责原则
- 其实就是开发人员经常说的”高内聚,低耦合”
- 也就是说,每个类应该只有一个职责,对外只能提供一种功能,而引起类变化的原因应该只有一个。在设计模式中,所 有的设计模式都遵循这一原则
2.开闭原则
- 核心思想是:一个对象对扩展开放,对修改关闭。
- 其实开闭原则的意思就是:对类的改动是通过增加代码进行的,而不是修改现有代码。
- 也就是说软件开发人员一旦写出了可以运行的代码,就不应该去改动它,而是要保证它能一直运行下去,如何能够做到 这一点呢?这就需要借助于抽象和多态,即把可能变化的内容抽象出来,从而使抽象的部分是相对稳定的,而具体的实现则 是可以改变和扩展的。
3.里氏替换原则
- 核心思想:在任何父类出现的地方都可以用它的子类来替代。
- 其实就是说:同一个继承体系中的对象应该有共同的行为特征。
4.依赖注入原则
- 核心思想:要依赖于抽象,不要依赖于具体实现。
- 其实就是说:在应用程序中,所有的类如果使用或依赖于其他的类,则应该依赖这些其他类的抽象类,而不是这些其他 类的具体类。为了实现这一原则,就要求我们在编程的时候针对抽象类或者接口编程,而不是针对具体实现编程。
5.接口分离原则
- 核心思想:不应该强迫程序依赖它们不需要使用的方法。
- 其实就是说:一个接口不需要提供太多的行为,一个接口应该只提供一种对外的功能,不应该把所有的操作都封装到一 个接口中。
6.迪米特原则
- 核心思想:一个对象应当对其他对象尽可能少的了解
- 其实就是说:降低各个对象之间的耦合,提高系统的可维护性。在模块之间应该只通过接口编程,而不理会模块的内部 工作原理,它可以使各个模块耦合度降到最低,促进软件的复用
设计模式
概述
设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式 是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 设计模式不是一种方法和技术,而是一种思想 设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想,尽可能的面向接口编程,低耦合,高内聚,使设 计的程序可复用 学习设计模式能够促进对面向对象思想的理解,反之亦然。它们相辅相成
简单工厂模式
-
又叫静态工厂方法模式,它定义一个具体的工厂类负责创建一些类的实例
-
优点
客户端不需要在负责对象的创建,从而明确了各个类的职责 -
缺点
这个静态工厂类负责所有对象的创建,如果有新的对象增加,或者某些对象的创建方式不同,就需要不断的修改工厂 类,不利于后期的维护 -
前期准备:
需要提供一个工厂类: 构造方法是私有的,不能直接实例化
需要在工厂类中提供具体对象的创建—功能是一个静态的
通过:工厂类.静态方法名()-----创建某个对象
举个栗子
对象资源类
//动物类
public abstract class Animal {
public abstract void eat();
}
//猫类
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//狗类
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
工厂类
//动物的工厂类----负责创建动物类实例的
public class AnimalFactory {
//构造方法私有化
private AnimalFactory() {}
//定义静态功能:返回值是该动物类Animal
public static Animal createAnimal(String type) {
if("cat".equals(type)) {
//一只猫
return new Cat() ; //相当于Animal a = new Cat(); 多态
}else if("dog".equals(type)) {
return new Dog() ;
}else {
return null ;
}
}
}
测试类
public class DesiginPatternDemo {
public static void main(String[] args) {
//没有使用设计模式
//创建猫
Cat c = new Cat() ;
c.eat();
Dog d = new Dog() ;
d.eat();
System.out.println("------------------------------");
//加入动物工厂类之后:测试
//有新的类型增加:需要在工厂类继续提供该类具体对象的创建
Animal a = AnimalFactory.createAnimal("cat") ;
a.eat() ;
a = AnimalFactory.createAnimal("dog") ;
a.eat();
a = AnimalFactory.createAnimal("monkey") ;
if(a!=null) {
a.eat();
}else {
System.out.println("动物工厂类没有提供该类型");
}
}
}
工厂方法模式
-
工厂方法模式中抽象工厂类负责定义创建对象的接口,具体对象的创建工作由继承抽象工厂的具体类实现。
-
优点:
客户端不需要在负责对象的创建,从而明确了各个类的职责,如果有新的对象增加,只需要增加一个具体的类和具体的 工厂类即可,不影响已有的代码,后期维护容易,增强了系统的扩展性 -
缺点
需要额外的编写代码,增加了工作量 -
需要抽象类的子类对象的创建需要 对应的工厂类实现对象的创建过程!
举个栗子
动物资源类
//动物类
public abstract class Animal {
public abstract void eat();
}
//猫类
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//狗类
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
工厂接口
public interface Factory {
Animal createAnimal() ;//创建动物的方法
}
具体工厂类
public class CatFactory implements Factory {
@Override
public Animal createAnimal() {
return new Cat(); //相当于Animal a = new Cat() ;
}
}
public class DogFactory implements Factory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
测试类
public class DesignPatternDemo {
public static void main(String[] args) {
//创建一只猫
//接口多态
Factory f = new CatFactory() ;
Animal a = f.createAnimal() ;
a.eat();
System.out.println("----------------------------");
f = new DogFactory() ;
Animal a2 = f.createAnimal() ;
a2.eat();
}
}