一.设计模式
1.设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
2.设计模式的分类:
1)创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式(Singleton)、建造者模式(Builder)、原型模式(Prototype)。
2)结构型模式,共七种:适配器模式(Adapter)、装饰器模式(Decorator)、代理模式(Proxy)、外观模式(Facade)、桥接模式(Bridge)、组合模式(Composite)、共享元模式(Flyweight)。
3)行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
3.静态工厂方法模式(简单工厂模式):
提供一个静态类:工厂类(制造一些需要的对象)
特点:构造方法私有化,外界不能直接创建它的对象
提供静态功能,每一种静态都会产生所需要的对象
缺点:不利于后期维护
如果添加新的对象,需要创建它的类,还需要在静态工厂类提供一些功能!
package simplefactory;
//动物抽象类
public abstract class Animal {
public abstract void eat();
}
package simplefactory;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("cat eat mouse...");
}
}
package simplefactory;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("dog eat meat...");
}
}
工厂类:
package simplefactory;
/**
* 动物工厂类
*
*2017年12月28日
*/
public class AnimalFactory {
private AnimalFactory(){
}
//提供静态工能:返回的是具体的类
public static Dog creatDog(){
return new Dog();
}
public static Cat creatCat(){
return new Cat();
}
}
测试类
package simplefactory;
public class AnimalDemo {
public static void main(String[] args) {
// 使用提供的静态工厂
Dog d = AnimalFactory.creatDog();
d.eat();
Cat c = AnimalFactory.creatCat();
c.eat();
}
}
对于上述工厂类进行改善
package org.westos_01;
/**
* 动物的工厂类
* @author Apple
*/
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 ;
}
}
}
package simplefactory;
public class AnimalDemo {
public static void main(String[] args) {
//使用改进的静态工厂
Animal a = AnimalFactory.creatAnimal("dog") ;
a.eat();
a = AnimalFactory.creatAnimal("cat");
a.eat();
a = AnimalFactory.creatAnimal("pig") ;
if(a!=null){
a.eat() ;//不判断直接输出,会出现NullPointerException
}else{
System.out.println("目前工厂类没有提供该动物...");
}
}
}
4.工厂方法模式:
特点:需要 提供一个抽象类,
工厂接口(该接口中的抽象方法的返回值是该抽象类)、
以及每个动物的具体类(重写该抽象类的方法)、
针对每个具体动物都提供一些对应的工厂类--->实现该接口--->返回值就是需要具体的动物对象
缺点:代码量多
package fatory_method;
//动物抽象类
public abstract class Animal {
public abstract void eat();
}
package fatory_method;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("dog eat meat...");
}
}
package simplefactory;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("cat eat mouse...");
}
}
工厂接口
package org.westos_02;
//工厂的接口
public interface Factory {
//就是用来提供常见具体动物的功能
public abstract Animal createAnimal() ;
}
package fatory_method;
public class DogFactory implements Factory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
package fatory_method;
public class CatFactory implements Factory {
@Override
public Animal createAnimal() {
return new Cat();
}
}
测试类
package fatory_method;
public class AnimalDemo {
public static void main(String[] args) {
// 需求:养一只狗
Factory f = new DogFactory();
Animal a = f.createAnimal(); //相当于 new Dog();
a.eat();
System.out.println("-----------");
//养一只猫
f = new CatFactory();
a = f.createAnimal(); //相当于new Cat();
a.eat();
}
}
5.单例模式
单例模式可以保证一个类在内存中只存在一个实例,即一个类只有一个对象实例
单例模式分为两种:饿汉式 、懒汉式
饿汉式
特点:当前某个类一加载就会创建一个对象
私有化该类的无参构造
成员变量位置创建该类的实例(static private 修饰)
提供公共的访问方法
package simpleexample;
public class SingleObject {
//创建SingleObject的一个对象
private static SingleObject instance = new SingleObject();
//构造函数为private,这样该类不会被实例化
private SingleObject(){
}
//获取唯一可用的对象
public static SingleObject getInstance(){
return instance;
}
}
package simpleexample;
public class SingletonPatternDemo {
public static void main(String[] args) {
// 不合法的构造函数
//编译时错误:构造函数SingleObject()是不可实现的
//SingleObject object = new SingleObject();
//获取唯一可用的对象
SingleObject object = SingleObject.getInstance();
//显示信息
object.showMessage();
}
}
懒汉式
特点:在调用取得实例方法的时候才会实例化对象
1)懒加载(延迟加载)
2)线程的安全问题
检验标准:是否是多线程环境;是否有共享数据;是否有多条语句对共享数据进行操作
解决方法:使用同步代码块进行解决
优点:第一次调用才初始化,避免内存浪费
缺点:必须加锁synchronized才能保证单例,但加锁会影响效率
package simpleexample;
public class Singleton {
private static Singleton instance;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
6.装饰者设计模式装饰器模式允许向一个现有的对象添加新的功能, 同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有
的类的一个包装。
适用环境:
1)在不影响其他对象的情况下,以动态、透明的方式给单个对象添加职责。
2)当不能采用生成子类的方法进行扩充时。一种情况是,可能有大量独立的扩展,为支持每一种组合将产生
大量的子类,使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏,或类定义不能用于生成子类。
参与者:
1.Component(被装饰对象的基类)
定义一个对象接口,可以给这些对象动态地添加职责。
2.ConcreteComponent(具体被装饰对象)
定义一个对象,可以给这个对象添加一些职责。
3.Decorator(装饰者抽象类)
维持一个指向Component实例的引用,并定义一个与Component接口一致的接口。
4.ConcreteDecorator(具体装饰者)
具体的装饰对象,给内部持有的具体被装饰对象,增加具体的职责。
Component
//Component 创建一个接口
//手机规则:打电话
public interface Phone {
public abstract void call() ;
}
ConcreteComponent
//ConcreteComponent
//具体的手机类(实现该接口)
public class IPhone implements Phone {
@Override
public void call() {
System.out.println("手机可以打电话了....");
}
}
Decorator
//Decorate
//创建实现Phone接口的抽象装饰类
public abstract class PhoneDecorate implements Phone {
private Phone p ;
public PhoneDecorate(Phone p){
this.p = p ;
}
@Override
public void call() {
this.p.call() ;
}
}
ConcreteDectrator
//ConcreteDectrator
//彩铃的修饰类
public class RingPhoneDecorate extends PhoneDecorate {
public RingPhoneDecorate(Phone p) {
super(p);
}
@Override
public void call() {
System.out.println("手机可以听彩铃了...");
super.call();
}
}
//ConcreteDectrator
//音乐的修饰类
public class MusicPhoneDecorate extends PhoneDecorate {
public MusicPhoneDecorate(Phone p) {
super(p);
}
@Override
public void call() {
super.call();
System.out.println("手机可以听音乐了....");
}
}
测试类
//测试类
public class PhoneDemo {
public static void main(String[] args) throws Exception {
//打电话
Phone p = new IPhone() ;
p.call() ;
System.out.println("--------------");
//打电话之前,听彩铃
PhoneDecorate pd = new RingPhoneDecorate(p) ;
pd.call() ;
System.out.println("-----------------");
//打完电话,听音乐...
pd = new MusicPhoneDecorate(p) ;
pd.call() ;
System.out.println("------------------");
//改进需求:先听彩铃-->打电话-->听音乐
//装饰者设计模式:抽象类:--->一些抽象的子类
//子类封装子类
pd = new RingPhoneDecorate(new MusicPhoneDecorate(p)) ;
pd.call() ;
}
}
二.枚举类型
枚举类型可以替代以往定义常量的方式,同时枚举类型还赋予程序在编译时进行检查的功能
以往设置常量,通常将常量放置在接口中,在程序中可以直接使用,并且该常量不能被修改,
常量的修饰符为final和static
在接口Constants中定义常量
public interface Constants{
public static final int Constants_A = 1;
public static final int Constants_B = 12;
}
枚举类型定义常量
public enum Constants{
Constants_A,
Constants_B,
Constants_C
}
程序中使用该常量,可以使用Constants.Constants_A来表示