版权声明:转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917
这篇我们来学习面向对象思想设计原则及常见的设计模式
在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则,那么都有哪些原则呢,我们就来了解一下
这些原则呢,我们在平时开发中可以用到,做一些大一点的项目,就要考虑用到这些思想,下面,我简单的介绍一下这些原则的核心思想,大家做以了解,如果要将这些原则运用到自己项目中,还要自己更加深入的学习、理解、运用。
设计模式在我们开发中还是经常用到的,那么,下面我们来学习一下
设计模式概述
- 设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
- 设计模式不是一种方法和技术,而是一种思想
- 设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想,尽可能的面向接口编程,低耦合,高内聚,使设计的程序可复用
- 学习设计模式能够促进对面向对象思想的理解,反之亦然。它们相辅相成
设计模式的几个要素:
设计模式的分类
创建型模式:简单工厂模式,工厂方法模式,抽象工厂模式,建造者模式,原型模式,单例模式。(6个)
结构型模式:外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)
行为型模式:模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)
设计模式的分类虽然很多,但是我们平时能用到的也就下面几种而已,所以不要被它这么多模式所吓倒。
下面我们就来学习我们常用的几种设计模式,让大家掌握,熟悉,并运用到自己的项目中,学会学以致用。
我们来写一个简单的例子来解释简单工厂模式
/*
* 抽象的动物类,里面有抽象的方法
*/
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() {
}
public static Animal createAnimal(String type) {
if ("dog".equals(type)) {
return new Dog();
} else if ("cat".equals(type)) {
return new Cat();
} else {
return null;
}
}
}
/*
* 测试类
*/
public class AnimalDemo {
public static void main(String[] args) {
// 工厂有了后,通过工厂给造
Animal a = AnimalFactory.createAnimal("dog");
a.eat();
a = AnimalFactory.createAnimal("cat");
a.eat();
// NullPointerException
a = AnimalFactory.createAnimal("pig");
if (a != null) {
a.eat();
} else {
System.out.println("对不起,暂时不提供这种动物");
}
}
}
以前我们在学代码的时候,不会去创建这个动物的工厂类,而是直接具体类的调用,比如:
Dog d = new Dog();
d.eat();
Cat c = new Cat();
c.eat();
现在我们运用了简单工厂模式后,就不用每次用的时候去new对象,而是直接去调用这个工厂类里面的具体方法,它会给我们返回一个已经new好的对象。那么这样做有什么有缺点呢,我们来总结一下。
当我们要用一个模式时,当这个模式的优点大于缺点的时候,我们就可以使用了,但是在简单工厂模式中我们可以看到它的缺点,当我们有新的对象增加时,就要不断的修改工厂类,所以不推荐大家用简单工厂模式,那么我们要用什么呢,这就引出了我们要学的下一个知识点工厂方法模式
我们就来用工厂方法模式对上面的那个例子进行改进
/*
* 抽象的动物类,里面有抽象的方法
*/
public abstract class Animal {
public abstract void eat();
}
/*
* 工厂类接口,里面有抽象的创造动物的方法
*/
public interface Factory {
public abstract Animal createAnimal();
}
/*
* 具体的猫类继承抽象动物类,重写抽象方法
*/
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
/*
* 猫工厂类实现工厂类并实现它的抽象方法,返回一个猫对象
*/
public class CatFactory implements Factory {
@Override
public Animal createAnimal() {
return new Cat();
}
}
/*
* 具体的狗类继承抽象动物类,重写抽象方法
*/
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
/*
* 狗工厂类实现工厂类并实现它的抽象方法,返回一个狗对象
*/
public class DogFactory implements Factory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
/*
* 测试类
*/
public class AnimalDemo {
public static void main(String[] args) {
// 需求:我要买只狗
Factory f = new DogFactory();
Animal a = f.createAnimal();
a.eat();
//需求:我要买只猫
f = new CatFactory();
a = f.createAnimal();
a.eat();
}
}
运行程序,控制台会输出,狗吃肉 猫吃鱼
我们仔细观察用工厂方法模式比比简单工厂模式多了几个类,但是当我们在需要一种动物猪时,我们就不用去修改工厂类里面的代码了,只需用创建一个猪类继承抽象动物类,重写抽象方法,再创建一个猪的工厂类实现工厂类并实现它的抽象方法,就可以了。代码具有很强的维护性和扩展性,那么我们来分析一下工厂方法模式的优缺点。
我们可以看到工厂方法模式的优点明显大于缺点,所以推荐大家使用。
如何实现类在内存中只有一个对象呢?
- 构造私有
- 本身提供一个对象
- 通过公共的方法让外界访问
那么我们就来学习单例模式中饿汉式和懒汉式 这两种模式,并做以比较
饿汉式:类一加载就创建对象
public class Student {
// 构造私有
private Student() {
}
// 自己造一个对象
// 静态方法只能访问静态成员变量,加静态
// 为了不让外界直接访问修改这个值,加private
private static Student s = new Student();
// 提供公共的访问方式
// 为了保证外界能够直接使用该方法,加静态
public static Student getStudent() {
return s;
}
}
public class StudentDemo {
public static void main(String[] args) {
// 通过单例得到对象
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1 == s2); //true
}
}
运行程序,控制台会输出true,说明我们用单例模式的饿汉式确保类在内存中只有一个对象,他的特点就是类一加载就创建对象,可以在代码中Student类中体现到。那么我们怎样才能在用这个对象的时候才去创建它呢,我们就要来看下懒汉式了。
懒汉式:用对象的时候,才去创建对象
public class Teacher {
private Teacher() {
}
private static Teacher t = null;
public static Teacher getTeacher() {
if (t == null) {
t = new Teacher();//当我们去用这个对象的时候才去创建它
}
return t;
}
}
public class TeacherDemo {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1 == t2); //true
}
}
单例模式的饿汉式和懒汉式是不是很容易理解呢,那么我们什么时候用饿汉式什么时候用懒汉式呢?
我们就来总结一下
饿汉式我们经常在开发中使用,因为饿汉式是不会出问题的单例模式
懒汉式我们在面试中回答用,因为懒汉式可能会出问题的单例模式。
面试主要面两个思想,分别是:
public synchronized static Teacher getTeacher() {
if (t == null) {
t = new Teacher();
}
return t;
}
我们在这里为什么要说Runtime类,因为它在java中的设计就是按照单例模式之饿汉式设计的,我们来看一段源码
class Runtime {
private Runtime() {}
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
}
我们来了解一下他的概述
应用程序不能创建自己的 Runtime 类实例。
Runtime类使用
public class RuntimeDemo {
public static void main(String[] args) throws IOException {
Runtime r = Runtime.getRuntime();
r.exec("notepad");
}
}
运行程序会帮我们打开记事本
r.exec("calc");//换成calc,会帮我们打开计算机
r.exec("shutdown -s -t 1000");
r.exec("shutdown -a");
下面我们来说说模版设计模式和装饰设计模式,这个大家作为了解,想要深入学习的话,可以在网上查阅相关的资料进行学习
我们可以在计算程序的运行时间中应用模版设计模式,在代码中我们只需用改变要计算的代码就可以了,把计算的时间设计成一个模版。
在IO流中的装饰模式应用
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter((new OutputStreamWriter(System.out)));
好了,我们设计模式就将这么多了,最后呢,我上传一本书《java与模式》有兴趣的你可以下载看看
欢迎有兴趣的同学加我朋友的QQ群:点击直接加群555974449 请备注:java基础再回首我们一起来玩吧。