java IO
常见IO类有哪些
涉及到哪些设计模式
设计模式:单例模式,观察者模式,使用场景?
观察者模式如何实现
装饰者模式,他问装饰者模式是什么原理
写个工厂模式
适配器模式
用过什么设计模式;单例模式怎么实现的;怎么保证是单一的;
饿汉模式;懒汉模式;线程安全的写法;
知道什么设计模式
单例设计模式有几种哪种不安全
设计模式(手写饿汉懒汉单例模式)
学习过哪些设计模式,用过哪些设计模式
- 生产者消费者模式讲一讲
- 了解什么设计模式呢,说一下代理设计模式 --> 我说了动态代理的Proxy和CGLib的两种代理实现方式
- Java的I/O使用到了什么设计模式(有装饰者模式,FilterInputStream聚合了InputStream)
常见设计模式
装饰者,模板方法,策略,工厂,状态
设计模式,动态代理
- 设计模式分类
- 设计模式原则:
开闭原则:对扩展开放,对修改关闭,当对程序进行扩展时,不能修改代码
迪米特原则:一个实体尽量不和其他实体相互作用,使模块隔离
接口隔离原则:尽量使用多个接口,而不是单个接口
依赖倒转原则:高层次模块不应该依赖于低层次模块,他们都应该依赖于抽象,另外,抽象不应该依赖于具体实现,具体实现应该依赖于抽象。
合成复用原则:尽量使用合成的方式,少使用依赖
里氏代换原则:任何基类出现的地方,子类都可以出现 - 单例模式:
单例模式主要有三种,懒汉式加载、饿汉式加载和双检锁模式
懒汉式加载:
package designmodle;
//懒汉式加载:懒汉式加载的特点是类加载时不会对单例实例化,只有第一次调用getInstance()时才会实例化单例。
public class lazySingleton {
private static volatile lazySingleton instance = null; //采用volatile的目的是为了保证多线程环境下的同步
private lazySingleton(){} //采用private的目的是为了防止类在外部被实例化
public static synchronized lazySingleton getInstance(){ //采用synchronize的目的是为了多线程环境下同步
if(instance == null){
System.out.println("the lazy singleton is not created");
instance = new lazySingleton();
}
System.out.println("the lazy singleton is created");
return instance;
}
public static void main(String[] args) {
new lazySingleton().getInstance();
new lazySingleton().getInstance();
}
}
饿汉式加载:
package designmodle;
//饿汉式单例:饿汉式单例模式的特点是类加载的时候实例化单例对象,在调用getInstance()之前单例对象就已经存在。
public class hungrySingleton {
private static final hungrySingleton Instance = new hungrySingleton();
private hungrySingleton(){
}
public static hungrySingleton getInstance() {
System.out.println("This hungry singleton is created.");
return Instance;
}
public static void main(String[] args) {
new hungrySingleton().getInstance();
new hungrySingleton().getInstance();
}
}
双检锁模式:
package designmodle;
import javax.management.InstanceAlreadyExistsException;
public class doubleCheckSingleton {
private static volatile doubleCheckSingleton Instance;
private doubleCheckSingleton(){}
public static doubleCheckSingleton getInstance() {
if(Instance == null)
{
synchronized (doubleCheckSingleton.class){
if(Instance == null){
System.out.println("the doubleCheck singleton is not created");
Instance = new doubleCheckSingleton();
}
}
}
System.out.println("the doubleCheck singleton is created");
return Instance;
}
public static void main(String[] args) {
new doubleCheckSingleton().getInstance();
new doubleCheckSingleton().getInstance();
}
}
- 模板方法模式:
在抽象类中的模板方法中定义一个操作的结构或者执行步骤;将一些子类相同的基本方法放在抽象类中定义,不同的子类对抽象类中的抽象方法进行不同的实现。模板方法的好处是可以将基本方法放在抽象类中,去除了子类中重复的代码,缺点是对不同的实现需要定义不同的子类,可能造成类太多,更加抽象。
示例如下:
public abstract class AbstractClass {
protected abstract void doAnything();
protected abstract void doSomething();
public final void templateMethod(){
/*
* 调用基本方法,完成相关的逻辑
*/
this.doAnything();
this.doSomething();
}
}
public class ConcreteClass1 extends AbstractClass {
@Override
protected void doAnything() {
// TODO Auto-generated method stub
//子类实现具体
}
@Override
protected void doSomething() {
// TODO Auto-generated method stub
}
}
public class ConcreteClass2 extends AbstractClass {
@Override
protected void doAnything() {
// TODO Auto-generated method stub
//子类实现具体
}
@Override
protected void doSomething() {
// TODO Auto-generated method stub
}
}
-
观察者模式:
观察者模式是指多个对象之间存在一对多的关系,当一个对象发生变化时,其他依赖于它的对象会受到事件通知,进行各自的更新,所以这种模式也叫发布-订阅模式
观察者模式中有抽象目标类、具体目标类、抽象观察者和具体观察者,其中目标类负责增加和删除观察者对象,并实现对通知观察者的方法,观察者负责实现更新自己的方法,当收到目标类的事件通知后调用更新方法进行更新。
观察者模式属于行为型模式。
zookeeper中采用了这种模式。
reference1
reference2 -
装饰者模式:
对原有对象的功能进行动态的扩展和加强,相比继承,更具弹性,无须通过继承增加子类就能扩展对象的新功能。采用继承,可能会出现子类爆炸的情况。
装饰着模式中有:抽象组件、具体组件、装饰角色和具体装饰角色
具体组件和抽象装饰者有相同的接口,装饰对象中拥有被装饰对象的引用。
装饰着的典型应用:IO流中:inputStream作为抽象组件,fileinputStream是具体组件,filterInputStream是装饰角色,而buffedInputStream是具体装饰角色。
继承会出现类爆炸的情况, 比如一个顶级接口有5个具体的实现组件,同时每一个组件都需要三种不同的装饰 如果是继承去实现 就是 5*3 = 15 个类 而装饰者模式则是 5+3=8个类。
reference1 -
工厂模式
特点:工厂方法让类把实例化推迟到子类,让子类决定要实例化的类是哪个类。
工厂模式可以通过使用一个共同的接口来指向新创建的对象,我们只需要将想要创建的不同参数传入工厂,就可以实例化出不同的对象。
在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
reference1