「java源码例子」java编程源码

今天给各位分享java源码例子的知识，其中也会对java编程源码进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java中的单例模式的代码怎么写
• 2、帮忙给一个java菜单栏例子的源代码
• 3、用java编写的有输入输出流源代码
• 4、求一个简单又经典的JAVA数据库连接的例子,要有源代码哦!

java中的单例模式的代码怎么写

我从我的博客里把我的文章粘贴过来吧，对于单例模式模式应该有比较清楚的解释：

单例模式在我们日常的项目中十分常见，当我们在项目中需要一个这样的一个对象，这个对象在内存中只能有一个实例，这时我们就需要用到单例。

一般说来，单例模式通常有以下几种：

1.饥汉式单例

public class Singleton {

private Singleton(){};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

}

这是最简单的单例，这种单例最常见，也很可靠！它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时，单例就会被加载到内存中。

在这里我们可以做个这样的测试：

将上述代码修改为：

public class Singleton {

private Singleton(){

System.out.println("createSingleton");

};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

而我们在另外一个测试类中对它进行测试（本例所有测试都通过Junit进行测试）

public class TestSingleton {

@Test

public void test(){

Singleton.testSingleton();

}

}

输出结果：

createSingleton

CreateString

我们可以注意到，在这个单例中，即使我们没有使用单例类，它还是被创建出来了，这当然是我们所不愿意看到的，所以也就有了以下一种单例。

2.懒汉式单例

public class Singleton1 {

private Singleton1(){

System.out.println("createSingleton");

}

private static Singleton1 instance = null;

public static synchronized Singleton1 getInstance(){

return instance==null?new Singleton1():instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

上面的单例获取实例时，是需要加上同步的，如果不加上同步，在多线程的环境中，当线程1完成新建单例操作，而在完成赋值操作之前，线程2就可能判

断instance为空，此时，线程2也将启动新建单例的操作，那么多个就出现了多个实例被新建，也就违反了我们使用单例模式的初衷了。

我们在这里也通过一个测试类，对它进行测试，最后面输出是

CreateString

可以看出，在未使用到单例类时，单例类并不会加载到内存中，只有我们需要使用到他的时候，才会进行实例化。

这种单例解决了单例的延迟加载，但是由于引入了同步的关键字，因此在多线程的环境下，所需的消耗的时间要远远大于第一种单例。我们可以通过一段测试代码来说明这个问题。

public class TestSingleton {

@Test

public void test(){

long beginTime1 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton.getInstance();

}

System.out.println("单例1花费时间："+(System.currentTimeMillis()-beginTime1));

long beginTime2 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton1.getInstance();

}

System.out.println("单例2花费时间："+(System.currentTimeMillis()-beginTime2));

}

}

最后输出的是：

单例1花费时间：0

单例2花费时间：10

可以看到，使用第一种单例耗时0ms，第二种单例耗时10ms，性能上存在明显的差异。为了使用延迟加载的功能，而导致单例的性能上存在明显差异，

是不是会得不偿失呢？是否可以找到一种更好的解决的办法呢？既可以解决延迟加载，又不至于性能损耗过多，所以，也就有了第三种单例：

3.内部类托管单例

public class Singleton2 {

private Singleton2(){}

private static class SingletonHolder{

private static Singleton2 instance=new Singleton2();

}

private static Singleton2 getInstance(){

return SingletonHolder.instance;

}

}

在这个单例中，我们通过静态内部类来托管单例，当这个单例被加载时，不会初始化单例类，只有当getInstance方法被调用的时候，才会去加载

SingletonHolder，从而才会去初始化instance。并且，单例的加载是在内部类的加载的时候完成的，所以天生对线程友好，而且也不需要

synchnoized关键字，可以说是兼具了以上的两个优点。

4.总结

一般来说，上述的单例已经基本可以保证在一个系统中只会存在一个实例了，但是，仍然可能会有其他的情况，导致系统生成多个单例，请看以下情况：

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

}

通过一段代码来测试：

@Test

public void test() throws Exception{

Singleton3 s1 = null;

Singleton3 s2 = Singleton3.getInstance();

//1.将实例串行话到文件

FileOutputStream fos = new FileOutputStream("singleton.txt");

ObjectOutputStream oos =new ObjectOutputStream(fos);

oos.writeObject(s2);

oos.flush();

oos.close();

//2.从文件中读取出单例

FileInputStream fis = new FileInputStream("singleton.txt");

ObjectInputStream ois = new ObjectInputStream(fis);

s1 = (Singleton3) ois.readObject();

if(s1==s2){

System.out.println("同一个实例");

}else{

System.out.println("不是同一个实例");

}

}

输出：

不是同一个实例

可以看到当我们把单例反序列化后，生成了多个不同的单例类，此时，我们必须在原来的代码中加入readResolve()函数，来阻止它生成新的单例

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

//阻止生成新的实例

public Object readResolve(){

return SingletonHolder.instance;

}

}

再次测试时，就可以发现他们生成的是同一个实例了。

帮忙给一个java菜单栏例子的源代码

给你个小例子，已经添加注释了。自己运行下看看效果，满意的话记得结贴子！

import java.awt.BorderLayout;

import java.awt.CheckboxMenuItem;

import java.awt.Frame;

import java.awt.Menu;

import java.awt.MenuBar;

import java.awt.MenuItem;

import java.awt.TextArea;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

public class TestMenu extends Frame implements ActionListener{

TextArea ta; //文本区

MenuBar mb; //MenuBar 类封装绑定到框架的菜单栏的

Menu mnFile,mnEdit,mnFormat,mnHelp; //从菜单栏部署的下拉式菜单组件

MenuItem miNew,miOpen,miSave,miSaveAs,miExit,miFont; //菜单中的所有项必须属于类 MenuItem 或其子类之一

CheckboxMenuItem miBinary; //一个可包括在菜单中的复选框

public TestMenu(){

super("记事本"); //调用父类构造方法

ta = new TextArea("",20,20); //新建文本区，第一个参数是默认文本，第二个参数是行数，第三个是列数

/*

* BorderLayout边框布局

* 添加文本区到Frame，BorderLayout.CENTER是居中位置

* */

add(ta,BorderLayout.CENTER);

mb = new MenuBar(); //创建菜单栏对象

/*

* 创建菜单，指定菜单名

* */

mnFile= new Menu("文件");

mnEdit= new Menu("编辑");

mnFormat= new Menu("格式");

mnHelp= new Menu("帮助");

/*

* 创建子菜单，并指定名称

* */

miNew= new MenuItem("新建");

miOpen= new MenuItem("打开");

miSave= new MenuItem("保存");

miSaveAs= new MenuItem("另存为");

miExit= new MenuItem("退出");

miExit.addActionListener(this); //为退出菜单添加监听

/*

* 添加上面创建的子菜单到文件菜单下

* */

mnFile.add(miNew);

mnFile.add(miOpen);

mnFile.add(miSave);

mnFile.add(miSaveAs);

mnFile.addSeparator(); //将一个分隔线或连字符添加到菜单的当前位置

mnFile.add(miExit);

miBinary= new CheckboxMenuItem("二进制"); //创建在复选框的子菜单

miFont= new MenuItem("字体"); //创建子菜单

/*

* 添加miBinary、miFont两个子菜单到mnFormat（格式）下

* */

mnFormat.add(miBinary);

mnFormat.add(miFont);

/*

* 将文件、编辑、格式、帮助添加到菜单栏

* */

mb.add(mnFile);

mb.add(mnEdit);

mb.add(mnFormat);

mb.add(mnHelp);

setMenuBar(mb); //添加菜单栏到Frame

/*

* 关闭窗口时，关闭运行成语

* */

addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent e){

System.exit(0);

}

});

}

public static void main(String args[]){

TestMenu tm=new TestMenu();

tm.setSize(300,200); //设置窗体的宽、高

tm.setLocation(300,100); //将组件移到新位置Component类方法

tm.setVisible(true); //设置显示窗体，true为显示，false为隐藏

}

/**

* 监听事件，实现ActionListener接口的actionPerformed方法

*/

public void actionPerformed(ActionEvent e){

String s = e.getActionCommand(); //获取选中菜单的名称

System.out.println(s);

if(s.equals("退出")){

System.exit(0); //停止运行程序

}

}

}

用java编写的有输入输出流源代码

/**

* 读写指定文件或者读写指定某一个文件夹下的全部文件(不包括文件夹)

* @throws Exception

*/

public static void moveFile() throws Exception {

Scanner scan = new Scanner(System.in);

System.out.println("请输入源路径：");//输入源文件地址，可以是文件夹，可以是具体某个文件

String uDisk = scan.nextLine();

File file = new File(uDisk);//获得读取文件

if ((file.exists())) {//当文件存在

System.out.println("请输入目标路径：");//文件复制目标路径

String targetFolder = scan.nextLine();

File target = new File(targetFolder);//获得写入文件

if (!target.exists()) {

if (!target.mkdir()) {

throw new Exception("创建目标目录失败");

}

} else if (!target.isDirectory()) {

throw new Exception("与目标目录同名的文件已经存在");

}

File[] temp = null;

if(file.listFiles()==null || file.listFiles().length=0){

temp=new File[]{file};//输入的源路径指定文件，将文件添加到文件数组中

}else{

temp = file.listFiles();//如果输入的源路径是文件夹，则获取文件夹下文件的个数

}

if ((temp != null) (temp.length 0)) {//文件数组temp有值

int i = 0;

for (int length = temp.length; i length; i++) {//循环文件数组

if (!temp[i].isDirectory()) {

String fileName = temp[i].getName();

File t = new File(targetFolder + File.separator

+ fileName);//创建输出文件

if (!t.createNewFile()) {

throw new Exception("创建输出文件失败");

}

FileOutputStream out = new FileOutputStream(t);//创建文件输出流

FileInputStream in = new FileInputStream(temp[i]);//创建文件输入流

byte[] buffer = new byte[256];

while (in.read(buffer) 0) {//循环输入流，直到输入流无数据

out.write(buffer);//写入文件

}

}

}

}

}

}

调用例子：

public static void main(String[] args) throws Exception {

moveFile();

}

求一个简单又经典的JAVA数据库连接的例子,要有源代码哦!

我就弄的用户登入的代码吧.这个挺简单的.

这是题目:

用户登陆验证：

1.创建数据库Test，并新建用户表users

字段包含：username varchar(20) not null

userpwd varchar(20) not null

在JBUILDER中编写Long类，实现登陆界面，并在用户输入用户名和密码后，

完成按纽的单击事件，对用户输入的数据进行验证，

（需要严整数据是否为空，密码长度必须是15位）,

并实现与数据库的连接，将用户输入的用户名密码与表中的记录比较，

若用户名正确且密码正确，弹出提示框告知登陆成功，否则登陆失败。

这是代码:

//连接数据库

boolean isLogin(String name,String pwd){

boolean flag=false;

Connection conn=null;

PreparedStatement pst=null;

ResultSet rs=null;

//加载驱动

try {

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

} catch (ClassNotFoundException ex) {

ex.printStackTrace();

}

//连接数据库

try {

conn=DriverManager.getConnection("jdbc:odbc:login");

String sql="select * from [user] where username=? and userpwd=?";

pst=conn.prepareStatement(sql);

pst.setString(1,name);

pst.setString(2,pwd);

rs=pst.executeQuery();

if(rs.next())

flag=true;

} catch (Exception ex) {

ex.printStackTrace();

}finally{

try {

conn.close();

} catch (Exception ex) {

ex.printStackTrace();

}

}

return flag;

}

//验证方法

public void jButton1_actionPerformed(ActionEvent e) {

String name=jTextField1.getText();

String pwd=jTextField2.getText();

//错误处理

if(name.equals("")||pwd.equals(""))

JOptionPane.showMessageDialog(this,"请输入完整的信息");

else {

if(isLogin(name,pwd))

JOptionPane.showMessageDialog(this,"登陆成功");

else

JOptionPane.showMessageDialog(this,"用户名或密码错误");

}

}

}

.....

.....

这是在事件里写的,

java源码例子的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java编程源码、java源码例子的信息别忘了在本站进行查找喔。