急求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 synchronized static Singleton2 getInstance() {

if (single == null) {

single = new Singleton2();

}

return single;

}

}

//对懒汉式单例的改进(错误的改进)

//实际上，只有在第一次创建对象的时候需要加锁，之后就不需要了 ，这样可以提升性能

public synchronized static 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 Singleton instance=null;

private Singleton(){}

private static 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源代码，详细点，说明这个程序的设计思路，还有比如运用了多线程的话运用了多线程的什么

import java.awt.*;

import java.awt.event.*;

import java.util.Random;

import javax.swing.Timer;

public class PinBall

{

private final int TABLE_WIDTH = 300;//桌面宽度

private final int TABLE_HEIGHT = 400;//桌面高度

private final int RACKET_Y = 340;//球拍的垂直位置

private final int RACKET_HEIGHT = 20;//球拍高度

private final int RACKET_WIDTH = 60;//球拍宽度

private final int BALL_SIZE = 16;//球的大小

private Frame f = new Frame("弹球游戏");//实例化一个窗口

Random rand = new Random();//实例化一个随机数生成器

private int ySpeed = 10;//小球的纵向运动数度、

private double xyRate = rand.nextDouble() - 0.5;//返回一个-0.5到0.5之间的比率用控制小球运动方向

private int xSpeed = (int)(ySpeed*xyRate*2);//这个横向速度在-10到10之间，产生左右摆动运动效果

private int ballX = rand.nextInt(200)+20;//小球开始的横坐标位置，200表示产生0到100之间的随机数

private int ballY = rand.nextInt(10)+20;//小球开始的纵坐标位置

private int racketX = rand.nextInt(200);//球拍开始时的横坐标位置

private MyCanvas tableArea = new MyCanvas();//实力化一个画布工具，集成Canvas类

private String shape = "";//保存需要绘制图形的字符串属性

Timer timer;//声明一个时间变量

private boolean isLose = false;//表示游戏是否结束

public void init()

{

tableArea.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));//定义画布大小

f.add(tableArea);//添加画布到窗口

KeyAdapter keyProcessor = new KeyAdapter()//实例化一个键盘监听事件适配器

{

public void keyPressed(KeyEvent ke)//重写适配器里面的按下某键盘方法

{

if(ke.getKeyCode()==KeyEvent.VK_LEFT)//按下键盘左键时

{

if(racketX 0)//球拍左边框不能出画布的左边框

racketX -=10;//按一左键次向左移动10个像素

}

if(ke.getKeyCode()==KeyEvent.VK_RIGHT)//按下键盘右键时

{

if(racketX TABLE_WIDTH - RACKET_WIDTH)//球拍右边框不能出画布的右边框

racketX +=10;//按一次右键移动向右移动10个像素

}

}

};

f.addKeyListener(keyProcessor);//给窗口添加键盘监听器

tableArea.addKeyListener(keyProcessor);//给画布添加键盘监听器

ActionListener taskPerformer = new ActionListener()//这里是实例化了一个监听接口，这个接口里面只有一个方法

{

public void actionPerformed(ActionEvent evt)//重写这个接口里面的方法，判断小球的位置

{

if(ballX=0 || ballX=TABLE_WIDTH-BALL_SIZE)//保证小球横向上在画布之内运动

{

xSpeed = -xSpeed;//触发反方向运动

}

if(ballY=RACKET_Y-BALL_SIZE(ballXracketX||ballXracketX+RACKET_WIDTH))//出了球拍的可击打范围

{

timer.stop();//停止对监听器的触发

isLose=true;//将标志isLose变量置为true

tableArea.repaint();//调用画布的重绘方法

}

else if(ballY=0||(ballY=RACKET_Y-BALL_SIZEballYracketXballX=racketX+RACKET_WIDTH))//小球在球拍之内，而其到达球拍的高度

{

ySpeed=-ySpeed;//上下方向改变，小球反弹

}

ballY+=ySpeed;//小球的坐标在纵向上增加

ballX+=xSpeed;//小球的坐标在横向上的增加

tableArea.repaint();//调用画布的重绘方法3

}

};

timer = new Timer(100,taskPerformer);//每隔0.1秒运行一次监听器

timer.start();//计时器开始运行

f.addWindowListener(new MyListener());//关闭窗口事件

f.pack();//设置窗口最佳大小

f.setVisible(true);//显示窗口

}

class MyListener extends WindowAdapter//关闭窗口的类

{

public void windowClosing(WindowEvent e)

{

System.exit(0);

}

}

public static void main(String[] args)//程序入口

{

new PinBall().init();//调用PinBall类里面的init()方法

}

class MyCanvas extends Canvas//建一个集成Canvas类的类

{

public void paint(Graphics g)//重写父类的绘图方法

{

if(isLose)//如果isLose为真，则在画布里打印“游戏已结束”

{

g.setColor(new Color(255,0,0));//当前颜色

g.setFont(new Font("黑体",Font.BOLD,30));//字体名称，样式，大小

g.drawString("游戏已结束！",50,200);//按坐标绘制文字图形

}

else//负责

{

g.setColor(new Color(240,240,80));//当前颜色

g.fillOval(ballX,ballY,BALL_SIZE,BALL_SIZE);//填充颜色，根据坐标和长宽填充圆形

g.setColor(new Color(80,80,200));//当前颜色

g.fillRect(racketX,RACKET_Y,RACKET_WIDTH,RACKET_HEIGHT);//填充颜色，根据坐标和长宽填充矩形

}

}

}

}

java通讯录管理系统设计代码怎么编译

java编写这个通讯录管理系统

java编写这个通讯录管理系统_Java如何实现通讯录管理系统

咕噜噜在芬兰

原创

关注

3点赞·2305人阅读

Java如何实现通讯录管理系统

发布时间：2020-07-28 09:39:42

来源：亿速云

阅读：65

作者：Leah

这篇文章将为大家详细讲解有关Java如何实现通讯录管理系统，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。

本文实例为大家分享了java实现通讯录管理系统的具体代码，供大家参考，具体内容如下

完成项目的流程：

1.根据需求，确定大体方向

2.功能模块分析

3.界面实现

4.功能模块设计

5.coding

6.代码测试

下面是源代码：import java.awt.Container;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Scanner;

import java.util.concurrent.SynchronousQueue;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.WindowConstants;

import javax.swing.text.html.HTMLDocument.Iterator;

class Infro{

public String id;

public String name;

public String sex;

public String address;

public String e_mail;

public String phoneNumber;

static int index = 0;

static ArrayList list = new ArrayList();

static int len = list.size();

//构造函数

public Infro(String id,String name,String sex,String address,String e_mail,String phoneNumber){

this.id = id;

this.name = name;

this.sex = sex;

this.address = address;

this.e_mail = e_mail;

this.phoneNumber = phoneNumber;

}

public String toString(){

return "编号："+id+" 姓名："+name+" 性别："+sex+" 通讯地址："+address+" 邮箱地址："+e_mail+" 电话："+phoneNumber;

}

/**

* 添加功能

**/

public static void addFunction(){//添加功能

Infro infro = new Infro("","","","","","");

System.out.println("请输入添加的数据：");

Scanner in = new Scanner(System.in);

System.out.println("输入编号：");

infro.id = in.next();

System.out.println("输入姓名：");

infro.name = in.next();

System.out.println("输入性别：");

infro.sex = in.next();

System.out.println("输入通讯地址：");

infro.address = in.next();

System.

out.println("输入邮箱地址：");

infro.e_mail = in.next();

System.out.println("输入电话：");

infro.phoneNumber = in.next();

list.add(index,infro);

index++;

if(list.isEmpty()){

System.out.println("数据添加失败啦");

}else{

System.out.println("数据添加成功啦");

len++;//list集合长度加一

// System.out.println(list.get(0).toString());

}

}

// public static void deleteFunction(){//删除功能

// System.out.println("输入要删除的联系人的编号");

// Scanner in_2 = new Scanner(System.in);

// String d1 = in_2.nextLine();

// for(int a= 0; a

// if(d1.equals(list.get(a).id)){

// list.remove(list.get(a));

// len --;

// }

// }

// }

/**

* 删除功能

**/

public static void deleteFunction(){

System.out.println("输入要删除的联系人的编号");

Scanner in_2 = new Scanner(System.in);

String d1 = in_2.nextLine();

java.util.Iterator it = list.iterator();

while (it.hasNext()){

Infro infro = it.next();

if (infro.id.equals(d1)){

it.remove();

--index;//一定要加这个，否则当做了删除操作再做添加操作的时候会出现异常(类似于指针，栈)

System.out.println("删除完毕"+"此时通讯录记录条数为：" + --len);

}

}

}

/**

* 修改功能

**/

public static void reditFunction(){

System.out.println("输入要修改的通讯录的Id");

Scanner in_r = new Scanner(System.in);

String r1 = in_r.nextLine();

for(int a = 0; a len;a++){

if(r1.equals(list.get(a).id)){

System.out.println("输入修改后的姓名：");

String name_1 = in_r.next();

list.get(a).name = name_1;

System.out.println("输入修改后的性别：");

String sex_1 = in_r.next();

list.get(a).sex = sex_1;

System.out.println("输入修改后的通讯地址：");

String address_1 = in_r.next();

list.get(a).address = address_1;

System.out.println("输入修改后的邮箱地址：");

String e_mail_1 = in_r.next();

list.get(a).e_mail = e_mail_1;

System.out.println("输入修改后的电话：");

String phoneNumber_1 = in_r.next();

list.get(a).phoneNumber = phoneNumber_1;

System.out.println("数据修改完毕");

}

}

}

/**

* 查询功能

**/

public static void searchFunction() throws Exception{//查询功能

System.out.println("请输入要查询的姓名：");

Scanner in_1 = new Scanner(System.in);

String s1=in_1.nextLine();

for(int a= 0; a

if(s1.equals(list.get(a).name)){

System.out.println(list.get(a).toString());

}

}

}

/**

* 显示功能

**/

public static void showFunction(){

for(int i = 0 ;i

System.out.println(list.get(i).toString());

}

}

/**

* 保存功能

**/

public static void writeFunction() throws IOException{

FileWriter writer = new FileWriter("通讯录管理.txt");

for(int i = 0 ;i

String []strwriter = new String[len];

strwriter[i]=list.get(i).toString();

writer.write(strwriter[i]);

writer.write("\r\n");

System.out.println("成功写入一行数据到 通讯录管理.txt 中");

}

writer.close();//关闭写入流，释放资源

}

/**

* 读取功能

**/

public static void readFunction() throws IOException{

FileReader reader = new FileReader("通讯录管理.txt");

BufferedReader br = new BufferedReader(reader);

String str;

while((str = br.readLine()) != null){//每次读取一行文本，判断是否到达文件尾

System.out.println(str);

}

br.close();

}

}

public class Demo extends JFrame {

/**

* 界面设计

**/

public Demo(){

Container c = getContentPane(); //定义一个顶级容器c

JPanel jp = new JPanel(); //新建JPanel面板--jp

JButton button1 = new JButton("新建联系人");

JButton button2 = new JButton("删除联系人");

JButton button3 = new JButton("编辑联系人");

JButton button4 = new JButton("查找联系人");

JButton button5 = new JButton("显示所有联系人");

JButton button6 = new JButton("保存联系人到本地");

JButton button7 = new JButton("读取本地联系人");

jp.setLayout(new GridLayout(2,4,5,5));//新建网格布局管理器(行数，列数，组件间的水平垂直间距)

jp.add(button1);

jp.add(button2);

jp.add(button3);

jp.add(button4);

jp.add(button5);

jp.add(button6);

jp.add(button7);

c.add(jp);//将JPanel面板jp添加到顶级容器c中

setSize(600,500);

setTitle("*通 讯 录 管 理 系 统*");

setVisible(true);

setResizable(false);//窗体大小由程序员决定，用户不能自由改变大小

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

/**

*按键响应

*

**/

button1.addActionListener(new ActionListener(){//添加功能实现

public void actionPerformed(ActionEvent arg0){

Infro.addFunction();

}

});

button2.addActionListener(new ActionListener(){//删除功能实现

public void actionPerformed(ActionEvent arg0){

Infro.deleteFunction();

}

});

button3.addActionListener(new ActionListener(){//修改功能实现

public void actionPerformed(ActionEvent arg0){

Infro.reditFunction();

}

});

button4.addActionListener(new ActionListener(){//查询功能实现

public void actionPerformed(ActionEvent arg0){

try {

Infro.searchFunction();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

});

button5.addActionListener(new ActionListener(){//显示功能实现

public void actionPerformed(ActionEvent arg0){

Infro.showFunction();

}

});

button6.addActionListener(new ActionListener(){//保存功能实现

public void actionPerformed(ActionEvent arg0){

try {

Infro.writeFunction();

} catch (IOException e) {

e.printStackTrace();

}

}

});

button7.addActionListener(new ActionListener(){//读取功能实现

public void actionPerformed(ActionEvent arg0){

try {

Infro.readFunction();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

});

}

public static void main(String[] args) {

// TODO Auto-generated method stub

new Demo();

Infro a = new Infro("", "", "", "", "", "");

}

}

关于Java如何实现通讯录管理系统就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。

分享文章：java代码详细设计 java代码示例
转载注明：http://azwzsj.com/article/dohjjhe.html