单例设计模式:实例化对象
只存在一个对象实例,只能new出来一个对象,再多也没有都是同一个。不会出现在main中new出很多个对象。
结果:只能实例化一个对象,
简单步骤:在类中自己new自己,设置为静态,在别的地方不能new,只能调用它静态的方法来实例对象
//第一种:饿汉:直接搞快点,直接先造了
public class Aa{
private Aa(){
}
private static Aa asd = new Aa();//自己new对象,结果是不调用方法就会加载对象
public static Aa bb(){
return asd;
//返回对象,在main中直接调用Aa qwe = Aa.bb();//造对象
}
}
//第二种:懒汉:不急,什么时候要,什么时候给你造
public class Aa{
private Aa(){
}
private static Aa asd = null;//先为null
public static Aa bb(){
if(asd == null){
asd = new Aa();//在方法中new对象,结果就是不调用方法,就不会直接加载一个对象,调方法时才会加载对象;
}
return asd;
//返回对象,在main中直接Aa qwe = Aa.bb();//造对象
}
}
//第三种
public class Aa{
private Aa(){
}
public static final Aa ads = new Aa();
//main中,Aa qwe = Aa.asd;没有什么其他的东西,没啥用。
}
模板方法设计模式:抽象类
抽象类作为多个子类的通用模板;
步骤在父类中写好,不好写的抽象出来给下面的子类来实现。
public class Java {
public static void main(String[] args) {
MoBan moBan= new GongNeng();
moBan.gongNeng();
}
}
/**
*
*
* @author 建一个模板
*
*/
abstract class MoBan{
//模版
public MoBan() {
super();
// TODO Auto-generated constructor stub
}
public void name() {
gongNeng();
//要执行的功能,具体是什么还不知道。
}
public abstract void gongNeng();
//方法抽象出来
}
/**
*
* @author 要实现的功能类
*
*/
class GongNeng extends MoBan{
public GongNeng() {
super();
// TODO Auto-generated constructor stub
}
@Override
public void gongNeng() {
//具体要的功能
System.out.println("123");
}
}
代理模式:接口
中介,经纪人
/*
* 定义接口
*/
interface JieKou{
public void gongJu();
}
/*
* 设置一个mignxing类,作为被代理
*/
class MingXing implements JieKou{
public void gongJu(){
System.out.println("mingxing");//重写。具体干什么。
}
}
/*
* 设置一个jingjiren类,作为代理
*/
class JingJiRen implements JieKou{
private JieKou jiekou;
public JingJiRen(JieKou jieKou) {
super();
this.jiekou = jieKou;
}
public void qiTaShi(){
System.out.println("jingjiren");//经纪人要干的事
}
public void gongJu(){
qiTaShi();//经纪人要干的事
jiekou.gongJu();//重写。具体干什么。
}
}
/*
*
* 入口
*/
public class Java{
public static void main(String[] args){
MingXing mingxing = new MingXing();
//mingxing给构造器
JingJiRen jingjiren = new JingJiRen(mingxing);
//用jingjiren代理操作mingxing
jingjiren.gongJu();
}
}