单例模式和装修模式、模版方法

关于单利设计模式
作用是保证类在内存的中的唯一性，只能有一个对象访问

1,将构造函数私有化
2，在本类中创建一个本类对象，并进行私有化
3，将提供一个对外访问的对象

只要加上这三部的话，就能实现一个在类中只能有一个对象访问

*/
//向我以往的操作是具体如下：

/*
class Student
{
 private int age;

 public void setAge(int age)
 {
    this.age=age;
 }
public int getAge()
 {
     return age;
}

}

class StudentDemo
{
  public static void main(String[] args)
 {
    Student s=new Student();
 Student s1=new Student();

 s.setAge(10);
 s1.setAge(100);
  System.out.println(s.getAge());
  System.out.println(s1.getAge());
 
 
  }

}
*/

//我有一个特殊学生，现在只能创建一个对象

class Student
{
 private Student(){}
 private static Student ss=new Student();
 public static Student getStudent()
 {
     return ss;
 }

 private int age;

 public void setAge(int age)
 {
    this.age=age;
 }
public int getAge()
 {
     return age;
}

}

class StudentDemo
{
  public static void main(String[] args)
 {
       Student s=Student.getStudent();
    Student s1=Student.getStudent();
    s.setAge(1000);
    System.out.println(s1.getAge());
 
 
  }

}

上面是可以创建多个对象， 进行赋值

 

下面是创建的对象只能是一个

/*
关于单例设计模式
作用是：在一个类在内存中只存在一个对象
不能创建多个对象
*/

//举个例子关于单例设计模式

//

class Student
{
  private Student(){}
  private static Student ss=new Student();
  public static Student getStudent()
 {
    return ss;
  }

  private String name;
  
  public void setName(String name)
 {
    this.name=name;
  }
  public String getName()
 {
    return name;
  }
}

class StudentDemo
{
  public static void main(String[] args)
 {
                Student s=Student.getStudent();
     Student s1=Student.getStudent();
    s.setName("yai");
    System.out.println(s.getName());
    System.out.println(s1.getName());
 
  }

}

/*写一个关于单例设计模式的延迟加载

懒汉式

当你的 对象调用方法的时候对象才初始化，也叫做延迟加载
当对象加载进内存的时候，对象不会出始话，要通过方法Instance调用对象，才进行初始化

*/

class Student
{
private Student(){}
private static Student ss=null;
public static Student getStudent()
 {
  if(ss==null)
  {
  synchronized(Student.class)   //使用双重判断，来处理掉安全隐患，提高效率
   {
        if(ss==null)
  ss=new Student();
   }
  }
  return ss;
  
 
 }
  

 private String name;
 private int age;
 public void setName(String name)
 {
    this.name=name;
 }
public String getName()
 {
 return name;
   }
public void setAge(int age)
 {
  this.age=age;

}
public int getAge()
 {
  return age;
}

}

class StudentDemo
{
public static void main(String[] args)
 {
 
                Student s=Student.getStudent();
    Student s1=Student.getStudent();
     s.setAge(50);
 System.out.println(s1.getAge());

 

 /*
 Student s=new Student();
 Student s1=new Student();
  s.setAge(30);
  s.setName("yao");
 System.out.println(s.getAge()+".."+s.getName());
*/
}

}

 

 装饰设计模式

/*
装饰设计模式：
当你想要对自已的对象进行功能增强时，可以定义类，将已有的对象传入，
基于已有的功能，并提供加强功能，
那么自已定义的类称为装饰类
装饰类通常会通过构造方法接收被装饰的对象并基于被装饰的对象的功能，
提供更强的功能

装饰类和继承很像，它们之间也有区别：
装饰类比继承要灵活，同时它避免了继承体系的臃肿，而且降低了类于类
之间的关系。
*/

class Person
{
 public void chifan()
 {
 System.out.println("吃饭");
 
 }
}

class SuperPerson
{
 private Person p ;      //定义一个对象
 SuperPerson(Person p)  //传入要修饰的对象
 {
    this.p=p;
 }
public void superchifan()
 {
 System.out.println("吃饭");
 System.out.println("开胃酒");
 System.out.println("甜点");
 }
}

 

class PersonDemo
{
public static void main(String[] args)
{

              Person p=new Person();

              SuperPerson sp=new SuperPerson(p);
               sp.superchifan();

 

}

}

 

 

abstract class Demo
{
  public final void getTime()      //被final修饰的无法被覆写
 {
           long start=System.currentTimeMillis();
               getXin();

    long end=System.currentTimeMillis();
    System.out.print("毫秒 "+(end-start));
    }
public abstract void getXin();    //抽象方法

}
class XinDemo extends Demo
{
public void getXin()
 {
for(int x=0;x<1000;x++)
  {
System.out.print(x);
}
}

}

class Demo1
{
 public static void main(String[] args)
 {
      XinDemo x=new XinDemo();
   x.getXin();

   //Demo d=new Demo();
   //d.getTime();
 
 
 }
}