java 模板 单例

java—–模板
模板设计模式重在思想
程序有确定的部分和不确定的部分组成
这是可以吧不确定的部分抽象出来 然后对外可以开放对外的访问模式
有使用的时候 可以由其子类继承父类
重写抽象方法 来完成不确定的部分
需求
计算一个程序的执行时间

public class Demo01 {

    public static void main(String[] args) {
        //GetTime gh = new GetTime();
        //gh.gettime();
        GetTime g = new sybtine();
        g.gettime();
    }
}
//class Gettime
 abstract  class GetTime{

    //获取系统当前时间
       public  void gettime() {
        //获取当前起始时间
        long startTime = System.currentTimeMillis();

        //调用抽取的方法
        fun();
        //写一个程序完毕，当前时间
        long endTime = System.currentTimeMillis();
        //执行时间
        System.out.println("程序执行："+(endTime-startTime)+"毫秒");

    }
       //把要执行的程序抽取方法
       //不知道怎么写实现不部分 可以不写
       //定义抽象方法 到子类写方法
      public  abstract  void fun();
       //public  void fun() ;//{
         //随便写一个程序 计算这个循环的执行时间
           //for(int i = 0; i<5000;i++) {
                System.out.println(i);
            //}
       }

//使用继承
class  sybtine extends GetTime{
    public  void fun() {
         for(int i = 0; i<10000;i++) {
                System.out.println(i);
            }
    }
}

赋值 ——一个类中有另一个类的

public class person {

    public static void main(String[] args) {
        // TODO Auto-generated method stub






    }

}
abstract class People{
    private String name;
    private String sex;
    public People() {};
    public People(String name,String sex) {
        this.name = name;
        this.sex = sex;
    };
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getSex() {
        return sex;
    }

    public abstract void eat();


}
class Man extends People implements Qian{
    //定义一个成员变量 是女人类的对象
    private WoMan gf;
    //构造方法
    public Man(String name,String sex) {
        super(name,sex);
    }
    //给gf写一对set get 方法
    public  void setMan(WoMan  gf) {
        this.gf = gf;
    }
    public WoMan getMan() {
        return gf;
    }
    public void sayhiao() {
        System.out.println("我是"+this.getName());
        System.out.println("我女朋友是"+gf.getName());
    }
    public void eat(){
        System.out.println("吃肉");
    }
    public void qi() {
        System.out.println("男人挣钱给女人花");
    }
    //从女人类中获取df
}

class WoMan extends People {
    private Man df;
    public WoMan(String name,String sex) {
        super(name,sex);
    }

    public  void setWoMan(Man  df) {
        this.df = df;
    }
    public Man getWoMan() {
        return df;
    }
    public void eat(){
        System.out.println("吃素");
    }

    public void saihiao() {
        System.out.println("我是"+this.getName());
        System.out.println("我男朋友是"+df.getName());
    }

    public void zhengrong(String body) {
        System.out.println(this.getName());
        //打印整容前介绍下自己
        saihiao();
        System.out.println("我要整容"+body);
    }


}

interface Qian{
    public abstract void qi();
}

单例设计模式—-（重点在于思想）
核心：在整个程序的执行期间。
不管你创建这个类的对象有多少个
有且 只有一个 该类的对象 （单例对象）

如何写一个单例出来
1 我不让外界来创建对象（构造方法私有化）
2 不让外面人来创建 自己来创建 （写个创建对象的自定义方法）
2 要开放对外的访问权限（把对象的访问方法暴露出去）
（只对外提供获取方法）

public class Demo01 {
 public static void main(String[] args) {
      Single s = Single.getInstence();
      Single s1 = Single.getInstence();
}

}
//单列类(饿汗式)
class Single{
    //创建单列对象
    private static Single single = new Single();
    //私有化构造方法
    private Single() {

    }
    //对外暴露访问的方法get方法
    public static Single getInstence() {
        return single;
    }

}

//单例 懒汉式 与 饿汗式写法不同
/**
 * 特点：延迟加载 懒加载
 * 只有你调用单例方法时 才回加载
 * 不想饿汉式随着类的加载而加载
 * 
 * 
 */
class SingleLan{
    //申明一个单例对象
    private static SingleLan singlelan = null;
    //私有化构造方法
    //对外开放访问的方法

    private SingleLan(){

    }//私有化构造方法
    //对外开放访问的方法(当用户调用GET方法时 在创建对象)
     public static SingleLan getInstence() {
         //当单例对象为空时会创建对象 一旦单例对象创建出来了，就不会为空
         //所以这个单例对象  只创建一次
         if(singlelan == null){
             singlelan = new SingleLan();
         }
         return singlelan;
     }
}