⑴ 如何在java中实现单例模式
单例模式1：
public
class
singleton{
private
static
singleton
st
=
null;
private
singleton(){
}
public
static
singleton
getinstance(){
if(st
==
null){
st
=
new
singleton();
}
return
st;
}
}
单例模式2：
public
class
singleton{
private
static
singleton
st
=
new
singleton();
private
singleton(){
}
public
static
singleton
getinstance(){
return
st;
}
}
多线程1：
导入thread所在的包
public
class
mythread1
extends
thread{
public
void
run(){
xxxxx写自己的代码
}
}
多线程2
导入runnable所在的包
public
class
mythread2
implements
runnable{
public
void
run(){
xxxxx写自己的代码
}
}
另写一个测试类，在main方法中这样写：
thread
t
=
new
mythread1();
或者
runnable
r
=
new
mythread2();
thread
t
=
new
thread(r);
⑵ java 单例模式这个要怎么理解
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
介绍
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
应用实例：
1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景：
1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
⑶ java单例设计模式问题
这个类只有一个public权限的getInstance，因为是static方法，所以可以直接调用该方法，同时静态属性是属于类的，所以保证了该类只有这么一个属性INSTANCE，这个静态属性是通过private的构造函数构造出来的，private的构造函数外部不能通过new 来调用，所以就保证了Single类的构造函数只执行一次，Single类INSTANCE有且只有一个，这就是单例模式，如果实在理解不了 ，就记住一点，所有的属性和方法，构造函数 全部都是private的，同时实例属性是static静态的。最后提供一个public 的 get方法对外部开放。
⑷ 在Java中，单例设计模式是什么意思有什么优势
单例模式：保证一个类在使用过程中，只有一个实例。优势就是他的作用，这个类永远只有一个实例。
步骤：
1.
将该类的构造方式私有；
2.
在内部实例化一个该类的实例；
3.
提供接口给外部访问。
public
class
SingletonDemo
{
private
SingletonDemo
(){};
//
1.
private
static
SingletonDemo
mInstance
=
new
SingletonDemo();
//
2.
public
static
SingletonDemo
getInstance(){
//
3.
return
mInstance;
}
}
⑸ java中几种设计模式（单例模式，适配器模式
1、单例模式：也分饿汉式单例模式（创建对象）与懒汉式单例模式（未创建对象）
代码实现：
饿汉式单例模式：
懒汉式单例模式：
2、适配器模式：
接口：
实现接口的类：
⑹ Java常用的几种设计模式
下面给你介绍5种设计模式：
1.单例设计模式
所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：
(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。
(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。
(3) 定义一个静态方法返回该类的实例。
2.工厂设计模式
程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。
3.代理设计模式
指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。
4.观察者设计模式
所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。
java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。
5.适配器模式
如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。
⑺ 如何写一个标准的Java单例模式
java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
单例模式有一下特点：
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。
首先看一个经典的单例实现。
public class Singleton {
private static Singleton uniqueInstance = null;
private Singleton() {
// Exists only to defeat instantiation.
}
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
// Other methods...
}
Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）
但是以上实现没有考虑线程安全问题。所谓线程安全是指：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。或者说：一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。显然以上实现并不满足线程安全的要求，在并发环境下很可能出现多个Singleton实例。
//////////////////////////////////////////////////////////////////////
验证单例模式的示例
//////////////////////////////////////////////////////////////////////
public class TestStream {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 该类只能有一个实例
private TestStream() {
} // 私有无参构造方法
// 该类必须自行创建
// 有2种方式
private static TestStream ts1 = null;
// 这个类必须自动向整个系统提供这个实例对象
public static TestStream getTest() {
if (ts1 == null) {
ts1 = new TestStream();
}
return ts1;
}
public void getInfo() {
System.out.println("output message " + name);
}
public static void main(String[] args) {
TestStream s = TestStream.getTest();
s.setName("张孝祥 1");
System.out.println(s.getName());
TestStream s1 = TestStream.getTest();
s1.setName("张孝祥 2");
System.out.println(s1.getName());
s.getInfo();
s1.getInfo();
if (s == s1) {
System.out.println("创建的是同一个实例");
} else if (s != s1) {
System.out.println("创建的不是同一个实例");
} else {
System.out.println("application error");
}
}
}
////////////////////////////////////////////
⑻ Java单例模式是什么意思
Java单例模式是确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例，在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例的模式；
Java单例模式分三种：懒汉式单例、饿汉式单例、登记式单例。
⑼ java饿汉式单例设计模式
因为是静态变量 static Single s 所以类加载即被创建该变量s指向new Single() ，当调用getInstance时返回s对象。
因为该s对象属于静态成员变量存在方法区而不是在堆栈中。方法区存储的东西只有一份。所以即使String b=Single.getInstance().返回的仍然是方法区中的唯一的静态变量s。即单例模式只有一个静态变量s指向该对象。不管怎么调用都只有一个该对象。