关于设计模式（单例模式、工厂模式、代理模式、适配器模式、观察者设计模式）的理解
1）：单例模式
package designMode.singleton;
/**
* 单例模式形成的原因：
*
* 构造器私有---> 外界无法实例化，就在类内部创建一个实例对象，用static修饰，可以用类名直接调用---> 但是，类的一般用法都讲究封装，实例化对象封装
* ---> 创建getInstance()方法 ---> 由于instance是静态属性，所以方法需要static修饰
*
*/
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton(){
}
public static Singleton getInstance(){
return instance;
}
public void print(){
System.out.println("单例模式！");
}
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();//访问类中的静态方法，取得类中的静态实例
Singleton s2 = Singleton.getInstance();
Singleton s3 = Singleton.getInstance();
s1.print(); //输出信息
s2.print();
s3.print();
}
}
结果：
单例模式！
单例模式！
单例模式！
2）：工厂模式：
程序在接口和子类之间加入了一个过度端，通过此过度端取得接口的实例化对象，一般都会称这个过渡端为工厂类；
因为接口对象的实例是从工厂取得的，以后如果再有子类扩充，直接修改工厂类客户端既可以根据标记得到相应的实例，灵活性较高。
package designMode.factory;
/**
* 父接口
*
*/
public interface Fruit {
void eat();
}
package designMode.factory;
public class Apple implements Fruit {
@Override
public void eat() {
System.out.println("**吃苹果");
}
}
package designMode.factory;
public class Orange implements Fruit{
@Override
public void eat() {
System.out.println("**吃橘子");
}
}
package designMode.factory;
public class Factory {
public static Fruit getInstance(String fruitString){
Fruit fruit = null;
if(fruitString.equals("apple")){
fruit = new Apple();
}
if(fruitString.equals("orange")){
fruit = new Orange();
}
return fruit;
}
}
package designMode.factory;
/**
* 工厂模式
*
*/
public class FactoryDemo {
public static void main(String[] args) {
Fruit fruit = null;
fruit = Factory.getInstance("designMode.factory.Orange ");
fruit.eat();
}
}
结果：
**吃橘子
将反射应用在工厂模式上
package designMode.factory;
/**
* 工厂模式
*
*/
public class FactoryDemo {
public static void main(String[] args) {
Fruit fruit = null;
fruit = Factory.getInstance("orange");
fruit.eat();
}
}
结果；
**吃橘子对比：运用反射的好处，
无论增加多少个子类，子类增加多个个属性，工厂类不用做任何的修改。
3）：代理模式：
用户只关心上网，代理处理如何上网，
定义一个上网接口，用户和代理都实现该接口，分别做自己要做的事情，
package designMode.proxy;
public interface Network {
void browse();
}
package designMode.proxy;
public class Real implements Network{ //真实的上网操作。
@Override
public void browse() {
System.out.println("真实的上网操作");
}
}
package designMode.proxy;
public class Proxy implements Network {
private Network network;
public Proxy(Network network){
this.network = network;
}
public void check(){
System.out.println("代理检查用户是否合法");
}
@Override
public void browse() {
check();
network.browse();
}
}
package designMode.proxy;
/**
* 代理模式
*
*/
public class ProxyDemo {
public static void main(String[] args) {
new Proxy(new Real()).browse(); //有参构造，实例化代理，执行代理的方法。
}
}
结果：
代理检查用户是否合法
真实的上网操作
4）：适配器模式：
主接口有太多的方法，如果直接实现，就必须覆写全部的方法，如果我只想操作其中的几个，就需要是用适配器进行适配。
package designMode.adapter;
public interface Window {//定义接口，，定义了很多的方法，但是只需要使用其中个别的方法，就需要使用代理模式了
void open();
void close();
void activated();
void iconified();
void deiconified();
}
package designMode.adapter;
public abstract class WindowAdapter implements Window {//用抽象类实现接口，方法体为空
@Override
public void activated() {
// TODO Auto-generated method stub
}
@Override
public void close() {
// TODO Auto-generated method stub
}
@Override
public void deiconified() {
// TODO Auto-generated method stub
}
@Override
public void iconified() {
// TODO Auto-generated method stub
}
@Override
public void open() {
// TODO Auto-generated method stub
}
}
package designMode.adapter;
import java.awt.event.WindowAdapter;
public class WindowImpl extends WindowAdapter { //实例体继承 抽象类。重写需要的方法
public void open(){
System.out.println("窗口打开");
}
public void close(){
System.out.println("窗口关闭");
}
}
package designMode.adapter;
public class AdapterDemo {
public static void main(String[] args) { //调用接口父类，执行需要的方法，其他的方法没有结果，在公司的eclipse上运行成功了，可是我自己的却不行，不知道是什么原因
Window window = (Window) new WindowImpl();
window.open();
window.close();
window.activated();
System.out.println();
window.iconified();
System.out.println();
window.deiconified();
}
}
结果：
窗口打开
窗口关闭
5）：观察者设计模式
什么叫做观察者
举个例子，现在很多人买房，都在关注房价，如果价格变动，所有的购房者都可以观察到，（购房者就是观察者，这就叫观察者设计模式）java中使用Observable类和Observer接口，轻松实现上述功能。
package library.watch;
import java.util.Observable;
public class House extends Observable{
private float price;
public House(float price){
this.price = price;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
super.setChanged(); //设置变化点
super.notifyObservers(price); //通知所有观察者价格改变
this.price = price;
}
@Override
public String toString() {
return "房子价格为： price=" + price;
}
}
package library.watch;
import java.util.Observable;
import java.util.Observer;
public class HousePriceObserver implements Observer {
private String name;
public HousePriceObserver(String name) {
super();
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
if (arg instanceof Float) { //判断参数类型
System.out.print(this.name +"观察到价格更改为：");
System.out.println(((Float)arg).floatValue());
}
}
public static void main(String[] args) {
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
h.addObserver(hpo1); //加入观察者
h.addObserver(hpo2);
h.addObserver(hpo3);
System.out.println(h); //输出房子价格
h.setPrice(600000); //修改房子价格
System.out.println(h);
}
}
结果：
房子价格为： price=1000000.0
购房者C观察到价格更改为：600000.0
购房者B观察到价格更改为：600000.0
购房者A观察到价格更改为：600000.0
房子价格为： price=600000.0抽象类--->摸具（继承的子类都具有父类的全部特征）
接口 --->指定标准（子类需要全部执行这些标准）
JDK1.8开始，可以在接口中定义普通方法：
产生背景：如果一个接口已经产生了至少30万个子类，突然有一天需要增加接口功能，并且这些方法对于所有的子类实现都是相同的，难道要子类覆写30万次？
如此，1.8之后，放宽接口的定义要求，可以定义抽象方法和静态方法，并且这些方法可以根据子类继承的原则被所有的接口子类继承。