锐客网

  1. 首页 > 生活百科 > it技术 > >

java设计模式代码题 java设计模式视频教程

IT技术public

java 中关于 单例设计模式的问题，大神，大侠呢，来分析分析错误吧！给你改了一下,
1.Verify没有 默认的构造方法.因为你定义了一个带参数的构造方法.
2.传参,不是nb(args) 这个写法,看过,但肯定不是java的.
3.CheckUser,最后一个return不需要.
import java.util.Date;
public class LoginDemo {
public static void main(String[] args) {
Verify nb = Verify.kl(args);
// 单例设计模式 传字符串的时候遇到了困然 ， 还没想明白 ， 是不是跟siatic 有关 导致 javac 后 static 与后来 java 的
// 参数 矛盾 导致的
if (nb.login()) {
System.out.println("登陆成功");
} else {
System.out.println("登录失败");
}
}
}
class Verify {
private String[] args;
// 单例设计模式
private static Verify instance = new Verify();
private Verify() {
}
private Verify(String[] args) {
this.args = args;
}
public static Verify kl(String[] args) {
instance.args = args;
return instance;
}
// 输入信息核实字符串
private void Check() {
System.out.println("登陆时间："new Date());
if (args.length != 3) {
System.out
.println("如果您下次仍然输入错误信息，系统内置炸弹将在60秒后自动引爆?。ㄓ亚樘崾荆盒彰?年龄 性别 xxx xx x）");
System.exit(-1);
}
}
// 核实字符串内容
private boolean CheckUser() {
String useName = args[0];
String age = args[1];
String sex = args[2];
if (useName.equals("kobe")age.equals(33)sex.equals("man")) {
return true;
} else {
return false;
}
// return false;
}
// 调用两个核实方法
public boolean login() {
Check();
return CheckUser();
}
}
Java设计模式的问题~~~~我不知道桥梁模式 。但你说的音符和乐器的关系还能明白 。
音符是数据 。乐器是代码 。音乐是结果 。
要的是音乐结果 。没有音符肯定没音乐 。有了音符还得看乐器 。
急求java设计模式,要求用到两种设计模式 求详细代码.饿汉式单例类
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
//私有的默认构造子
private Singleton1() {}
//已经自行实例化
private static final Singleton1 single = new Singleton1();
//静态工厂方法
public static Singleton1 getInstance() {
return single;
}
}
2.懒汉式单例类
//懒汉式单例类.在第一次调用的时候实例化
public class Singleton2 {
//私有的默认构造子
private Singleton2() {}
//注意，这里没有final
private static Singleton2 single=null;
//静态工厂方法
public synchronizedstatic Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
//对懒汉式单例的改进(错误的改进)
//实际上，只有在第一次创建对象的时候需要加锁，之后就不需要了，这样可以提升性能
public synchronizedstatic Singleton2 getInstance() {
if (instance == null) {
synchronized(instance){ //锁住当前实例对象
if(instance == null){
instance = new Singleton2();
}
}
}
return instance;
}
错误原因：
aA、B线程同时进入了第一个if判断
bA首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
c由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块 。
dB进入synchronized块，由于instance此时不是null ， 因此它马上离开了synchronized块并将结果返回给调用该方法的程序 。
e此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了 。
正确改进（使用内部类）：
JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的，JVM能够帮我们保证instance只被创建一次，
并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题 。
同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题
public?class?Singleton?{??
??
/*?私有构造方法，防止被实例化?*/??
private?Singleton(){
}
/*?此处使用一个内部类来维护单例?*/??
private?static?class?SingletonFactory?{??
private?static?Singleton?instance?=?new?Singleton();??
}
/*?获取实例?*/??
public?static?Singleton?getInstance()?{??
return?SingletonFactory.instance;??
}
/*?如果该对象被用于序列化 ， 可以保证对象在序列化前后保持一致?*/??
public?Object?readResolve()?{??
return?getInstance();??
}
}
其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错？？？？
第二种改进：
因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，
单独为创建加synchronized关键字，也是可以的
public class Singleton{
private static Singletoninstance=null;
private Singleton(){}
privatestatic synchronized void Init(){
if(instance==null)
instance=new Singletion();
}
public static Singleton getInstance(){
if(instance==null){
Init();
}
return instance;
}
}
3.登记式单例类
import java.util.HashMap;
import java.util.Map;
//登记式单例类.
//类似Spring里面的方法，将类名注册 ， 下次从里面直接获取 。
public class Singleton3 {
private static MapString,Singleton3 map = new HashMapString,Singleton3();
static{
Singleton3 single = new Singleton3();
map.put(single.getClass().getName(), single);
}
//保护的默认构造子
protected Singleton3(){}
//静态工厂方法,返还此类惟一的实例
public static Singleton3 getInstance(String name) {
if(name == null) {
name = Singleton3.class.getName();
System.out.println("name == null" "---name=" name);
}
if(map.get(name) == null) {
try {
map.put(name, (Singleton3) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return map.get(name);
}
//一个示意性的商业方法
public String about() {
return "Hello, I am RegSingleton.";
}
public static void main(String[] args) {
Singleton3 single3 = Singleton3.getInstance(null);
System.out.println(single3.about());
}
}
Java设计模式,需要用到两种设计模式 ， 急需！工厂模式：
Product代码：
public interface Work {
void doWork();
}
ConcreteProduct代码：
public class StudentWork implements Work {
public void doWork() {
System.out.println("学生做作业!");
}
}
public class TeacherWork implements Work {
public void doWork() {
System.out.println("老师审批作业!");
}
}
Creator代码：
public interface IWorkFactory {
Work getWork();
}
ConcreteCreator代码：
public class StudentWorkFactory implements IWorkFactory {
public Work getWork() {
return new StudentWork();
}
}
public class TeacherWorkFactory implements IWorkFactory {
public Work getWork() {
return new TeacherWork();
}
}
Test代码：
public class Test {
public static void main(String[] args) {
IWorkFactory studentWorkFactory = new StudentWorkFactory();
studentWorkFactory.getWork().doWork();
IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}
}
追问一下，给你写第二个 。
java设计模式大作业第一java设计模式代码题：抽象工厂模式
第二：单列模式
上述2中可以用于实现 ：类java设计模式代码题的实列化 。
第三：开放-封闭
主要一些实体类bean，dto什么的
还有，购物系统可以查询物流，根据订单内部状态太决定查询哪个物流：可以使用状态模式
最后 ， 说真的，网页框架很多用了很多模式，java设计模式代码题你自己写，基本上都是MVC模式 ， 基本上写action ， server，dao就完事了，用不上什么模式来着
JAVA 采用单例设计模式设计日志处理类 ， 并写出代码import java.util.Date;
public class Logger {
private static Logger instance;
private static Class clazz;
private Logger() {
}
private Logger(Class clazz) {
this.instance = new Logger();
this.clazz = clazz;
}
public static Logger getLogger(Class clazz) {
if (instance == null) {
synchronized (Logger.class) {
if (instance == null) {
instance = new Logger(clazz);
}
}
}
return instance;
}
public void info(String msg) {
System.out.println(clazz.getName()"["new Date().toLocaleString()
"][info]:"msg);
}
public void error(String msg) {
System.out.println(clazz.getName()"["new Date().toLocaleString()
"][error]:"msg);
}
public void warn(String msg) {
System.out.println(clazz.getName()"["new Date().toLocaleString()
"][warn]:"msg);
}
public void log(String msg) {
System.out.println(clazz.getName()"["new Date().toLocaleString()
"][log]:"msg);
}
public static void main(String args[]) {
Logger s = Logger.getLogger(String.class);
s.info("普通消息");
}
}
【java设计模式代码题 java设计模式视频教程】关于java设计模式代码题和java设计模式视频教程的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息 ， 记得收藏关注本站 。

    推荐阅读


    上一篇：redis的nx redis程序变量区别

    下一篇：如何查找U8服务器？ 怎么找到u8的服务器