------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
###18.01_设计模式(单例模式概述和使用)
一个程序员对设计模式的理解:
“不懂”为什么要把很简单的东西搞的很复杂。后来随着软件开发经验的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在，我所理解的“简单”模式一把钥匙一把锁模式，目的仅仅是着眼于解决现在的问题，而设计模式的“复杂”就是在于它是要构造一个“万能钥匙”，目的是提出一种所有锁的开锁方式，在真正理解设计模式之前我一直在编写“简单”的代码.这个“简单”不是功能的简单，而是设计的简单，简单的设计意味着缺少灵活性，代码很钢硬，只在这个项目里有用，拿到其它的项目中就是垃圾，我将其称之为“一次性代码”“
<span style="font-size:14px;">public class Singleton {
private static Singleton s;
public static Singleton getInstance() {
if (s == null)
s = new Singleton();
return s;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1==s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
singletonTest运行结果是:
s1 is the same instance with s2</span>1.
逻辑代码独立到单独的方法中，注重封装性--易读，易复用。
不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。
2.
写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！
是否可以拿到其它同类事物中应该？是否可以拿到其它系统中应该？
3.
熟练运用继承的思想：
找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；
继承的思想，也方便将自己的逻辑建立于别人的成果之上。如ImageField extends JTextField；
熟练运用接口的思想：
找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
优点
在系统内存中只存在一个对象，因此可以节约系统资源，
对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
缺点
没有抽象层，因此扩展很难。
职责过重，在一定程序上违背了单一职责
单例设计模式有两种：
饿汉式
1: 创建一个类
2: 构造方法私有
3: 在当前类中， 创建一个当前类对象,并私有
4: 在当前类中，提供一个public方法，用来获取到创建好的对象
<span style="font-size:14px;">public class Single {
//构造方法私有
private Single(){}
//在当前类中， 创建一个当前类对象,并私有
private static Single s = new Single();
//在当前类中，提供一个public方法，用来获取到创建好的对象
public static Single getInstance(){
return s;
}
}
</span> 懒汉式
1: 创建一个类
2: 构造方法私有
3: 在当前类中，创建一个当前类对象的引用，不进行new操作
4: 在当前类中，提供一个public方法
判断，如果是第一次使用
是： 创建对象
否： 使用创建好的对象
面试题的考点：
1： 不是上来就new对象
2: 方法中的if判断
3: 多线程安全问题 (同步)
<span style="font-size:14px;">public class Single2 {
//构造方法私有
private Single2(){}
// 在当前类中，创建一个当前类对象的引用，不进行new操作
private static Single2 s = null;
//在当前类中，提供一个public方法
public synchronized static Single2 getInstance(){
//判断，如果是第一次使用
//t1,t2
if (s == null) {
//t1,t2
//是： 创建对象
s = new Single2();
}
return s;
}
}
</span>* 单例设计模式概述
单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
优点
在系统内存中只存在一个对象，因此可以节约系统资源，
对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
缺点
没有抽象层，因此扩展很难。
职责过重，在一定程序上违背了单一职责
<span style="font-size:14px;">public class Test {
public static void main(String[] args) {
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
System.out.println(s1 == s2);
Single2 s1 = Single2.getInstance();
Single2 s2 = Single2.getInstance();
System.out.println(s1 == s2);
new Thread(){
public void run() {
Single2 s = Single2.getInstance();
System.out.println(s);
};
}.start();
new Thread(){
public void run() {
Single2 s = Single2.getInstance();
System.out.println(s);
};
}.start();
}
}
</span>###18.02_设计模式(简单工厂模式概述和使用)
* A:简单工厂模式概述
* 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
我们对于简单工程模式用图表示：
* B:优点
* 客户端不需要在负责对象的创建，从而明确了各个类的职责
* C:缺点
* 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
* D:案例演示
* 动物抽象类：public abstract Animal { public abstract void eat(); }
* 具体狗类：public class Dog extends Animal {}
* 具体猫类：public class Cat extends Animal {}
* 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。
<span style="font-size:14px;"> public class AnimalFactory {
private AnimalFactory(){}
//public static Dog createDog() {return new Dog();}
//public static Cat createCat() {return new Cat();}
//改进
public static Animal createAnimal(String animalName) {
if(“dog”.equals(animalName)) {}
else if(“cat”.equals(animale)) {
}else {
return null;
}
}
}
</span>
###18.03_设计模式(工厂方法模式的概述和使用)
* A:工厂方法模式概述
* 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
* B:优点
* 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
* C:缺点
* 需要额外的编写代码，增加了工作量
* D:案例演示
<span style="font-size:14px;"> 动物抽象类：public abstract Animal { public abstract void eat(); }
工厂接口：public interface Factory {public abstract Animal createAnimal();}
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}
</span>开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
<span style="font-size:14px;">狗工厂：public class DogFactory implements Factory {
public Animal createAnimal() {…}
}
猫工厂：public class CatFactory implements Factory {
public Animal createAnimal() {…}
}
</span>其实设计模式非常多，大概有二十多种，我们这里 只对工厂模式和单例模式做一个介绍，后续会慢慢更新
扫一扫
1243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
