输出错了！！！
第一个类的构造方法,请看
public tt(int b) {
b=x;
}
请问,你new出来tt这个类了,x有值了吧?
也就是说你今天这一节把x赋给了b,但是在第二个方法又无法用到b,也就是说,这个方法毫无用处
请将 b 和x的位置换换,同时,x为成员变量,不需要初始化给值的,是靠你传参数的.
第二,请看
public int cc(int b) {
return b;
你可以完全把这个方法里的传参去掉,应为你的x是成员变量,改为
public int cc() {
然后在另外一个类里new出来tt,请看,我帮你修改了
Scanner a =new Scanner(System.in);
int b = a.nextInt();
tt cd =new tt(b);
int sd= cd.cc();
System.out.println(sb);
其实还可以改,
tt cd =new tt(a.nextInt());
System.out.println(cd.cc());
不知道是否理解对了你的意思,大概写了一下：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.io.StringWriter;
public class FileReadAndWrite {
public static void main(String[] args) {
File file = new File("E:/workspace/FileIOTest/src/a.txt");
str = str.replace('d', 'f');
System.out.println("处理完毕");
/**
* 文本文件转换为指定编码的字符串
*
* @param file
* 文本文件
* @param encoding
* 编码类型
* @return 转换后的字符串
* @throws IOException
*/
InputStreamReader reader = null;
StringWriter writer = new StringWriter();
try {
if (encoding == null || "".equals(encoding.trim())) {
reader = new InputStreamReader(new FileInputStream(file),
encoding);
} else {
reader = new InputStreamReader(new FileInputStream(file));
// 将输入流写入输出流
char[] buffer = new char[DEFAULT_BUFFER_SIZE];
int n = 0;
while (-1 != (n = reader.read(buffer))) {
writer.write(buffer, 0, n);
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
if (reader != null)
reader.close();
} catch (IOException e) {
// 返回转换结果
if (writer != null)
return writer.toString();
else
* 将字符串写入指定文件(当指定的父路径中文件夹不存在时,会最大限度去创建,以保证保存成功！)
* @param res
* 原字符串
* @param filePath
* 文件路径
* @return 成功标记
boolean flag = true;
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
File distFile = new File(filePath);
if (!distFile.getParentFile().exists())
distFile.getParentFile().mkdirs();
bufferedReader = new BufferedReader(new StringReader(res));
bufferedWriter = new BufferedWriter(new FileWriter(distFile));
int len;
while ((len = bufferedReader.read(buf)) != -1) {
bufferedWriter.write(buf, 0, len);
bufferedWriter.flush();
bufferedReader.close();
bufferedWriter.close();
flag = false;
return flag;
if (bufferedReader != null) {
最简单的java代码肯定就是这个了,如下：
public class MyFirstApp
{
public static void main(String[] args)
System.out.print("Hello world");
具体如下：
连连看的小源码
package Lianliankan;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class lianliankan implements ActionListener
JFrame mainFrame; //主面板
Container thisContainer;
JPanel centerPanel,southPanel,northPanel; //子面板
JButton exitButton,resetButton,newlyButton; //退出,重列,重新开始按钮
JLabel fractionLable=new JLabel("0"); //分数标签
JButton firstButton,secondButton; //
static boolean pressInformation=false; //判断是否有按钮被选中
int x0=0,y0=0,x=0,y=0,fristMsg=0,secondMsg=0,validateLV; //游戏按钮的位置坐标
int i,j,k,n;//消除方法控制
代码（code）是程序员用开发工具所支持的语言写出来的源文件,是一组由字符、符号或信号码元以离散形式表示信息的明确的规则体系.
虽然用于表示 A 到 Z 拉丁字母表字符的位模式在所有的代码页中都相同,但用于表示重音字符（如"é"和"á"）的位模式在不同的代码页中却不同.如果在运行不同代码页的计算机间交换数据,必须将所有字符数据由发送计算机的代码页转换为接收计算机的代码页.如果源数据中的扩展字符在接收计算机的代码页中未定义,那么数据将丢失.
我从我的博客里把我的文章粘贴过来吧,对于单例模式模式应该有比较清楚的解释：
单例模式在我们日常的项目中十分常见,当我们在项目中需要一个这样的一个对象,这个对象在内存中只能有一个实例,这时我们就需要用到单例.
一般说来,单例模式通常有以下几种：
①饥汉式单例
public class Singleton {
private Singleton(){};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
这是最简单的单例,这种单例最常见,也很可靠！它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时,单例就会被加载到内存中.
今天这一节我们可以做个这样的测试：
将上述代码修改为：
private Singleton(){
System.out.println("createSingleton");
};
public static void testSingleton(){
System.out.println("CreateString");
而我们在另外一个测试类中对它进行测试（本例所有测试都通过Junit进行测试）
public class TestSingleton {
@Test
public void test(){
Singleton.testSingleton();
输出结果：
createSingleton
CreateString
我们可以注意到,在这个单例中,即使我们没有使用单例类,它还是被创建出来了,这当然是我们所不愿意看到的,所以也就有了以下一种单例.
public class Singleton1 {
private Singleton1(){
private static Singleton1 instance = null;
public static synchronized Singleton1 getInstance(){
return instance==null?new Singleton1():instance;
我们今天这一节也通过一个测试类,对它进行测试,最后面输出是
可以看出,在未使用到单例类时,单例类并不会加载到内存中,只有我们需要使用到他的时候,才会进行实例化.
这种单例解决了单例的延迟加载,但是由于引入了同步的关键字,所以呢在多线程的环境下,所需的消耗的时间要远远大于第一种单例.我们可以通过一段测试代码来说明这个问题.
long beginTime1 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton.getInstance();
System.out.println("单例1花费时间："+(System.currentTimeMillis()-beginTime1));
Singleton1.getInstance();
最后输出的是：
单例1花费时间：0
可以看到,使用第一种单例耗时0ms,第二种单例耗时10ms,性能上存在明显的差异.为了使用延迟加载的功能,而导致单例的性能上存在明显差异,
是不是会得不偿失呢?是否可以找到一种更好的解决的办法呢?既可以解决延迟加载,又不至于性能损耗过多,所以,也就有了第三种单例：
private static class SingletonHolder{
return SingletonHolder.instance;
在这个单例中,我们通过静态内部类来托管单例,当这个单例被加载时,不会初始化单例类,只有当getInstance方法被调用的时候,才会去加载
SingletonHolder,从而才会去初始化instance.并且,单例的加载是在内部类的加载的时候完成的,所以天生对线程友好,而且也不需要
synchnoized关键字,可以说是兼具了以上的两个优点.
一般来说,上述的单例已经基本可以保证在一个系统中只会存在一个实例了,但是,仍然可能会有其他的情况,导致系统生成多个单例,请看以下情况：
通过一段代码来测试：
public void test() throws Exception{
//1.将实例串行话到文件
FileOutputStream fos = new FileOutputStream("singleton.txt");
ObjectOutputStream oos =new ObjectOutputStream(fos);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("singleton.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
System.out.println("同一个实例");
}else{
System.out.println("不是同一个实例");
输出：
不是同一个实例
可以看到当我们把单例反序列化后,生成了多个不同的单例类,此时,我们必须在原来的代码中加入readResolve()函数,来阻止它生成新的单例
//阻止生成新的实例
public Object readResolve(){
再次测试时,就可以发现他们生成的是同一个实例了.