相信明天会更好 » java

java修改ip地址

sunny — Tue, 25 Aug 2009 01:31:16 +0000

首先写一个批处理文件，然后再java中调用即可。步骤如下：

假设批处理文件为changeip.bat,内容如下：

@echo off

netsh interface ip set address “本地连接” static 222.195.151.47 255.255.254.0

netsh interface ip set address name=“本地连接” gateway=222.195.151.254 gwmetric=0

netsh interface ip set dns name=“本地连接” source=static addr=211.64.142.6 register=PRIMARY

exit

然后我们在java程序里面调用即可，调用语句如下：

Java语言: Codee#5105

Process comm=Runtime.getRuntime().exec(“cmd /c start c:/changeip.bat”);

这样我们就可以实现更改本机ip了。

java获取系统时间并转化为”-”相连接的形式

sunny — Wed, 18 Feb 2009 12:12:53 +0000

Calendar c=Calendar.getInstance();

String s=c.get(Calendar.YEAR)+”-”+(c.get(Calendar.MONTH)+1)+”-”+c.get(Calendar.DATE)+”-”+c.get(Calendar.HOUR_OF_DAY)+”:”+c.get(Calendar.MINUTE+”:”+c.get(Calendar.SECOND));

java中的数据存储细节

sunny — Tue, 02 Dec 2008 06:53:50 +0000

计算机的物理内存在os和jvm中使用时分为堆内存和栈内存两种方式：

堆内存：（Heap Memory）由所有的应用程序公用，存储空间不连续，存储容量大。在堆内存中分配存储空间和进行存取操作速度慢。
栈内存（Stack Heap）由特定的应用程序专用，存储空间是连续的，以栈的方式（后进先出）进行管理，存储容量小，但是访问速度快。

java程序运行时，局部变量是保存在栈内存中，而对象及其成员变量保存在堆内存中。

java中的滚动条和菜单

sunny — Tue, 18 Nov 2008 14:04:54 +0000

滚动条（JScrollBar)

因为滚动条要实现能够左右,上下移动.所以就要有相应的监听器,所以在当图形界面中有滚动条时,不要忘了在程序开头加上import java.awt.event.*；JScrollBar对象会产生一个AdjustmentEvent事件，所以要在程序中继承接口AdjustmentListener其监听器方法是adjustmentValueChanged(AdjustmentEvent e).
其属性有：orientation指定滚动条的方向

jsbHort=new JScrollBar();
jsbVert=new JScrollBar();
jsbHort.setOrientation(Adjustable.HORIZONTAL);//设置为水平滚动条
jsbVert.setOrientation(Adjustable.VERTICAL);//为垂直滚动条

jsbHort.addAdjustmentListener(this);//加上监听器
jsbVert.addAdjustmentListener(this);//同上

double value=jsbVert.getValue();//获得滚动条的当前水平滚动值

double maximumValue=jsbVert.getMaximum();//获得滚动条水平滚动最大值

菜单（JMenu）

它要实现的监听器接口是ActionListener,监听器方法为actionPerformed(ActionEvent e)

Java语言: 创建菜单

JFrame frame=new JFrame();
JMenuBar jmb=new JMenuBar();//新建一个菜单栏
frame.setJMenuBar(jmb);//把菜单栏与框架产生关联
JMenu fileMenu=new JMenu(“File”);//新建一个一个菜单File
jmb.add(fileMenu);//把菜单项加到菜单栏中
fileMenu.add(new JMenuItem(“new”));//给File菜单添加菜单项
fileMenu.addSeperator();//添加一条分隔线

具体的可以查看相应的API

只言片语–java中的文件读写

sunny — Sun, 16 Nov 2008 14:19:25 +0000

在文件读写部分中,我们如果要读取格式化数据.可以使用DataInputStream,它是以俄国面向字节的I/O类,因此我们必须使用InputStream类,而不是Reader类,当然我们可以用InputStream以字节的形式读取任何数据(例如一个文件),不过.在这里我们用的是字符串,为了能将字符串转化成适用于ByteArrayInputStream的字节数组,String包含了一个可以将字符串转化为字节数组的getByte（）方法。所以我们就持有了一个可传递给DataInputStream的InputStream。

try{

DataInputStream in3=new DataInputStream(new ByteArrayInputStream(s2.getBytes()));//s2是String类型的

System.out.print((char) in3.readByte());

}cacth(EOFException e)

{System.out.println(“End of stream”);//此时我们是通过捕获异常来检测输入的末尾，但是使用异常进行流控制，被认为是对异常特性的错误使用

}

我们还可以通过available()方法查看还有多少可供存取的字符。例如

Java语言: available()判断文件是否是否到末尾

import java.io.*;
public class TestEOF{
public static void main(String[] args) throws IOException
{
DataInputStream in=new DateInputSteam(new BufferedInputStream(new FileInputStream(“TestEOF.java”)));
while(in.available()!=0)
{
System.out.print((char)in.readByte());
}
}
}

关于文件输出：

首先创建与制定文件连接的FileWriter，但是为了显著增加I/O操作的性能，我们通常会用BufferedWriter将其包装起来用一缓冲输出，然后为了格式化，将它转化成PrintWriter。按照这种方式创建数据文件可作为普通文本文件读取。

标准I/O：

JAVA提供了System.out,System.in,System.err.其中System.out已经事先被包装成了printStream对象。System.err同样也是PrintStream对象。但是System.in却是一个没有包装过的未经加工的InputStream，这就意味着我们可以立即使用System.out和System.err,但是在读取System.in之前必须对其进行包装。

通常我们会用readLine()一次一行的读取输入，因此我们会将Sysetem.in包装成BufferReader来使用。所以我们必须用InputStreamReader把System.in转化成Reader

注：readLine()会抛出IOException所以要注意声明。

将System.out转化成PrintWriter

System.out是一个PrintStream而PrintStream是一个OutputStream。PrintWriter有一个可以接受OutputStream作为参数的构造器。

PrintWriter out=new PrintWriter(System.out,true);

java中的异常

sunny — Tue, 11 Nov 2008 12:46:09 +0000

在java中不要求在方法中显式的声明Error和RuntimeException,如果要抛出其他异常必须提前声明我们可以用throws来声明抛出的异常,当要抛出多个异常时,用逗号隔开.

注意: 一个方法是不能抛出一个没有声明的异常.

抛出异常: 在声明了异常的方法中.如果出现了异常,就可以抛出一个异常对象例如: throw new TheException();

等价于TheException ex=new TheException();

throw ex;

捕获异常：当调用一个显式声明的异常的方法时，必须使用try-catch块括住抛出异常的语句，如：

Java语言: 捕获异常

try
{
statements that may throw exceptions
}
catch(Exception1 e)
{
handle for exception1
}
cacth(Exception2 e)
{
handle for exception2
}
… …

如果try中抛出的异常没有被任何一个catch捕获则java就会退出这个方法,并将异常传递给调用该方法的方法,继续重复寻找时间处理器的过程,如果一直没有找到,程序就会终止,并在控制台打印出错误信息.

异常对象中包含异常的有用信息,可以利用java.lang.Throwable类中的下列实例方法获取异常：

public string getMessage()

返回此 Throwable或Exception 的详细消息字符串。

public string toString()

返回此 Throwable或Exception 的简短描述。

如果此 Throwable或Exception 对象是利用非空详细消息字符串创建的，则结果是三个字符串的串联：

1)此对象的实际类的名称

2)”: “（冒号和空格）

3)此对象的 getMessage() 方法的结果
如果此 Throwable或Exception 对象利用 null 详细消息字符串创建，则返回此对象的实际类的名称。

public void printStackTrace()

将此 throwable 及其追踪输出至标准错误流。
此方法将此 Throwable或Exception 对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
输出的第一行包含此对象的 toString() 方法的结果。剩余行表示以前由方法 fillInStackTrace() 记录的数据。

读取配置文件的参数–ResourceBundle

sunny — Fri, 31 Oct 2008 09:09:59 +0000

java中读取配置文件的参数可以使用ResourceBundle来实现：

connectDB.properties文件如下：

database.serverurl=jdbc:sqlserver://localhost:1433;databaseName=laberguarantee

datebase.username=sa
datebase.password=pimm

以下是连接数据库时读取参数的操作

ResourceBundle rb = ResourceBundle.getBundle(“connectDB“);//默认的connectDB.properties是放置在WEB-INF/classes下面的
url= rb.getString(database.serverurl);

usrname= rb.getString(database.username);

password=rb.getString(database.password);

类加载时初始化的顺序

sunny — Mon, 22 Sep 2008 01:43:24 +0000

在网上看了一个朋友的博客，里面介绍了关于静态变量的初始化问题，本来以为自己很明白了，可是自己写出结果以后发现与运行结果不同，于是上网搜了一些加载时初始化的顺序的例子，整理如下：

每个类加载的时候静态域先于非静态域，这与代码所在位置先后没有关系。
类加载时先初始化变量然后是函数/方法
无论new多少个对象，静态域只有一个，即只初始化一次，以后的new对象都不在执行静态域的代码。
当碰到继承的关系时，加载顺序是:父类静态成员，子类静态成员，父类静态成员，父类的成员变量，父类的构造方法，子类的成员变量，子类的构造方法。当再用这个类new一个对象的时候，静态的部分就不会再执行了，因为静态的部分时类中所有的实例所共享的，他在整个虚拟机的生命周期内只执行一次。

示例代码如下：

Java语言: 静态变量的初始化顺序

package com.bobbee;

class Bowl
{
public Bowl(int marker)
{
System.out.println(“Bowl(“ + marker + “)”);
}
void f1(int marker)
{
System.out.println(“f1(“ + marker + “)”);
}
}

class Table

{
static Bowl bowl1 = new Bowl(1);//Table 里面还是先初始化这里，最先输出 Bowl(1)—1

public Table() //两个静态域初始化完成后，是构造函数了

{
System.out.println(“Table()”);//输出 Table()—3
bowl2.f1(1); //当然该这里了，bowl2已经有了，输出f1(1)—4
}
void f2(int marker)
{
System.out.println(“f2(“ + marker + “)”);
}

static Bowl bowl2 = new Bowl(2);//Bowl(1)完了，该这里了，初始化Bowl(2),输出 Bowl(2)—2

}

class Cupboard
{
Bowl bowl3 = new Bowl(3);//终于该我了，下面两个静态的，很牛嘛。输出 Bowl(3)，—7；从10又回来了，这下没下面两个什么事情了，因为，是静态的嘛，呵呵，照样输出 Bowl(3)，—11；懒得说了，—15

static Bowl bowl4 = new Bowl(4);//同样的，先初始化静态域，输出 Bowl(4)，上面的要等一等了，谁让你不是静态域呢？:)—5

public Cupboard()//7初始化完毕，构造函数开始…；从11又来了；

{
System.out.println(“Cupboard()”);//简简单单的输出，哪有你们上面的那么复杂—8；依旧简简单单的输出 —12；…—16
bowl4.f1(2);//bowl4 已经在了，调用它的f1()方法，输出f1(2)—9；从上面来的，bowl4 仍然在，继续输出f1(2)—13；…—17
}
void f3(int marker)
{
System.out.println(“f3(“ + marker + “)”);
}
static Bowl bowl5 = new Bowl(5);//bowl3，你还是再等等吧，我先来，我也是静态域，虽然我在下面，没办法~~~ —6
}

class StaticInitialization
{
public static void main(String[] args)//从这里开始~~，不过别急，先初始化下面的静态域 table 和 Cupboard。
{
System.out.println(“Creating new Cupboard() in main”);//从9开始才真正的到这里，虽然在 main 里，好惨~~ —10
new Cupboard(); // new 了一个对象
System.out.println(“Creating new Cupboard() in main”);//从13过来，又来~~你烦不烦~~，继续输出—14
new Cupboard(); //又 new 了一个对象，我为什么要说又..

table.f2(1);//从17回来，f2(1)—18
cupboard.f3(1);//f3(1)，—19完
}
static Table table = new Table();//所以说，实际上是从这里开始先加载 Table 类
static Cupboard cupboard = new Cupboard();//4完后，该这里了…
}

运行结果：
Bowl(1)

Bowl(2)

Table()

f1(1)

Bowl(4)

Bowl(5)

Bowl(3)

Cupboard()

f1(2)

Creating new Cupboard() in main

Bowl(3)

Cupboard()

f1(2)

Creating new Cupboard() in main

Bowl(3)

Cupboard()

f1(2)

f2(1)

f3(1)

关于有继承关系时的初始化示例如下：

Java语言: 继承关系存在时静态变量的初始化顺序

package test1;
public class Test4 {
private void testClassForName(String name) throws ClassNotFoundException{
Class c=Class.forName(name);
}
private void testNewInstance(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
Class c=Class.forName(name);
Object obj=c.newInstance();
System.out.println(obj);
}
public static void main(String[] args)throws Exception {
Test4 t=new Test4();
t.testClassForName(“test1.B”);
new B();
new B();
}
}
class A{
private int aj;
{
aj=20;
System.out.println(“A成员初始化块”);
}
private static int ai;
static {
ai=10;
System.out.println(“A静态初始化块”);
}
public A(){
System.out.println(“A构造函数”);
}
}
class B extends A{
private static int bi;
static {
bi=30;
System.out.println(“B静态初始化块”);
}
private int bj;
{
bj=40;
System.out.println(“B成员初始化块”);
}
public B(){
System.out.println(“B构造函数”);
}
}

结果如下：
A静态初始化块
B静态初始化块
A成员初始化块
A构造函数
B成员初始化块
B构造函数
A成员初始化块
A构造函数
B成员初始化块
B构造函数

关于编写jsp代码时常用到的一些代码

sunny — Mon, 14 Jul 2008 08:35:50 +0000

要想在jsp处理页面的最后给以人性化的提示，比如插入数据库成功、修改成功、等等来通知用户，我们可以在java代码中加入out.println(“alert(‘数据库修改成功！’)”)；

如果想要由当前的页面跳转到另一个jsp页面可以用out.println(“window.location=\”../log.jsp\”");

在js中如果要是超链接另一个js的话可以按照如下实现

newRow.cells[2].innerHTML = “删除”;