一个JAVA初学者的迷茫，大伙来讨论

泡在csdn没用的哇！只会让你越来越迷失....
java基础打好了，就该上层建筑了啊。jsp肯定要看的啊。
建议找点项目做吧，这样知道自己该学什么

只是这个时候能做些什么项目呢？给点意见阿，CSDN里面的问题大都不明白，太菜了俄

java概念太多了
要学的东西太多le

java要学的东西很多
看你要用那方面的了

JAVA学习起来没有那么容易，东西多不懂哪一天，又搞新技术

我觉得多看别人写的程序，慢慢看更高级的...多看多练..把自己的思想加进去多练习也许会有新的发现.....声明：我刚学java才1天..这只是我自己的学习路线..有误区还请大家指出来..别让我进了误区了..`HOHo

不建议jsp原理一点都不懂就直接去做项目。弄不出来反倒影响积极情绪。
现在网络上流传的视频教学有张孝祥，孙鑫，翁恺三个版本。电驴里可能找的到。可以都下载下来看看。刚接触java看看张孝祥的，莫莫唧唧讲得挺细的。学了一遍再看看翁恺的。
jsp就是j2ee的。感觉java基础差不多就该去抠Java Server Page了

唉，今年刚好24岁，在一家公司维护ERP，感觉没劲，这才学JAVA编程，难道这玩意年龄大了玩不转吗/？可是没办法啊，谁叫咱都20岁才接触COMPUTER呢，不过我有信心，这次一定要搞明白，我想从J2EE发展，接下来该看些什么书呢？或者学些什么内容呢？我现在都使用editplus编的程序，又没有别的更利于开发的工具啊？现在都流行用什么呢？欢迎大伙多提提意见

对啊，java基础的东西学完了，然后怎么选？j2ee?j2me?j2se?

JSP？ struts 作个像样的小网站

不要等到"能"做了才去做,现在可以先弄下JSP-Servlet这样的小东西,往J2EE进军吧

建议先学JSP，SEVLETR的基本知识，再找一个有项目实例的书来练练手

把人看的郁闷啊！什么都不懂啊，也刚把JAVA基础学完，现在工作都找不到啊！

可以尝试做一下工程实践,提高解决实际问题的能力;如果是将来想在java应用程序编程方面发展,就深入学习J2SE,想在企业级平台上有所建树,就学习J2EE(JSP),如果对诸如开发手机游戏感兴趣,就学J2ME.

慢慢来,由易到难.建议强攻structs,用structs+hibernate做个简单网站.

感觉JAVA所涉及的东西太多了，都不知道什么是什么，有什么相关联的关系，不像VB，ASP 等，只有那个学习的目标，而现在范围太广了，反而不知道该如何下手了。迷茫。。

只要你掌握了java和数据库，就可以做项目了，在项目中学习吧，这样速度快，你也就知道学什么了。

建议
1 要学先选一个方向，因为Java也分很多类别的，如J2SE,J2EE,J2ME,EJB等等，还有各种框架：Struts, JSF,Spring, Hiberaate.
2. 要学就要学精些。
3. 要实践，只有在真正做项目的过程才能提高。

搞些java开源学,学下别人的精髓,提高更快.sourceforge.net上下载.

做一个Struts项目吧，不太难，可以帮你找到方向。

多做一些项目，了解java真正的思维才是王道

先Servlet再JSP再J2EE再......
总之学习学习再学习当然中途去做做项目是最好的了

其实你觉得自己的基础好了并不代表真的基础就好了,你看下你能不能把csdn里大部分的问题都解答出.如果不能的话请你还是去看看基础.corejava是本不错的书,看了吗?都懂了吗?

我以前也是你这样的。我自学JAVA基本两三个月就完了，给一段Java程序，能明白是什么意思，但叫自己写怎么也写不出来。
那是因为没有学到Java的精髓。后来找个培训机构考了SCJP，现在写JSP或者做J2EE基本没什么问题了。关键是基础。
加油啊，每一步要走塌实了~

你要是初学者的话找本JAVA书把里面的代码都自己打一遍基本差不多了呵呵笨办法哦

你应该接着学 HTML JSP SERVLET 数据库SQL JDBC
再考虑学些筐架。

HTML，早就了解了，以前做过静态的和ASP的网站开发，SERVLET是什么东东阿？主要是开发什么用的〉？还是一个开发工具如DREAMWEAR之类的？如果是的话那很简单啊，呵呵，JSP不知道难不难，J2EE是不是包括JSP，还是说JSP就是J2EE ？名词太多了，都不晓得什么是什么了？呵呵

JSP->SERVLET->M2模式->STRUTS->HIBERNATE->SPRING

强烈反对 genier200(我在说谎) 的说法学习是终身的事情，只要你有信心就一定行，我们应该鼓励楼主

学习jsp之前必须要学习servlet吗?是不是必要的?

现看一下比较好，因为jsp与servlet连接的非常紧，servlet一点都不会学jsp费劲

Jsp 到底是什么东东呀？偶是初学者，不懂呀？与java什么关系？

混CSDN吧.我也是才学了几个月JAVA,在我那破培训班里我感觉自己学的不错了,来这里才发现自己菜的连一道别人问的问题都不会,我就把游戏全删了,开始混这里了...学东西还是基础最重要了,我现在在学J2EE,学到jsp了.但是回头看论坛里关于J2SE的问题,还是都不会,还是从J2SE开始学吧.老师说J2SE是基础..

实践出真知,我大学根本没学过java,到一个公司里面,就开始让我们做项目,根本不会,后来被逼出来的,看代码学代码,真的很快,建议找别人做过的项目,自己拿过来重做,提高会很快的!

看看刘晓涛的servelt/jsp吧

你们好``我是JAVA的初学者，。。有网站是那些高手遍的程序吗？？请回答我。。

我也是初学者,对JAVA我也是感到力不从心.又些东西虽然有思路,但是用代码去实现的时候
却不知道怎样去些,该这么办啊.各位能推荐几本好书看看吗?

我也是初学者
看了这个
很有收获
希望对楼主有所帮助
http://daxing.bokee.com/2265541.html

不管做什么事都要坚持到底！！！
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
（转帖）：
J2ee学习流程在这里我谈谈我在学习j2ee流程，并谈到在此过程中领会的经验和教训。以便后来者少走弯路。
Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE。这三块相互补充，应用范围不同。
J2SE就是Java2的标准版，主要用于桌面应用软件的编程；
J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；
J2EE是Java2的企业版，主要用于分布式的网络程序的开发，如电子商务网站和ERP系统。 1)先学习j2se
要学习j2ee就要先学习j2se，刚开始学习j2se先建议不要使用IDE，然后渐渐的过渡到使用IDE开发，毕竟用它方便嘛。学习j2se推荐三本书，《java2核心技术一二卷》，《java编程思想》，《java模式》。其中《java编程思想》要研读，精读。这一段时间是基本功学习，时间会很长，也可能很短，这要看学习者自身水平而定。不要被IDE纠缠
在学习java和j2ee过程中，你会遇到五花八门的IDE，不要被他们迷惑，学JAVA的时候，要学语言本身的东西，不要太在意IDE的附加功能，JAVA编程在不同IDE之间的转换是很容易的，过于的在意IDE的功能反而容易耽误对语言本身的理解。目前流行的IDE有jbuilder，eclipse和eclipse的加强版WSAD。用好其中一个就可以了，推荐从eclipse入手j2ee。因为Jbuilder更适合于写j2se程序。 2)选择和学习服务器使用配置
当你有了j2se和IDE的经验时，可以开始j2ee的学习了，web服务器：tomcat，勿庸置疑，tomcat为学习web服务首选。而应用服务器目前主要有三个：jboss、weblogic、websphere。有很多项目开始采用jboss，并且有大量的公司开始做websphere或weblogic向jboss应用服务器的移植（节省成本），这里要说的是，学习tomcat和jboss我认为是首选，也是最容易上手的。学习服务器使用配置最好去询问有经验的人（有条件的话），因为他们或许一句话就能解决问题，你自己上网摸索可能要一两天（我就干过这种傻事），我们应该把主要时间放在学习原理和理论上，一项特定技术的使用永远代替不了一个人的知识和学问。 3)学习web知识
如果你是在做电子商务网站等时，你可能要充当几个角色，这是你还要学习：
html，可能要用到dreamwave等IDE。
Javascript，学会简单的数据校验，数据联动显示等等 4)J2eeAPI学习
学习j2eeAPI和学习服务器应该是一个迭代的过程。
先学习jsp和servlet编程，这方面的书很多，我建立看oreilly公司的两本《jsp设计》和《java servlet编程》，oreilly出的书总是那本优秀，不得不佩服。
学习jdbc数据库编程，j2ee项目大多都是MIS系统，访问数据库是核心。这本应属于j2se学习中，这里拿出来强调一下。
学习jndi api，它和学习ejb可以结合起来。
学习ejb api，推荐书《精通ejb》
经过上面的这些的学习，大概可以对付一般的应用了。
另外一种学习方法：跟着sun公司的《j2ee tutorial》一路学下来，j2ee-tutorial是很不错的入门教材。 5)学习ejb设计模式和看代码（最重要）
设计模式是练内功，其重要性可以这么说吧，如果你不会用设计模式的话，你将写出一堆使用了ejb的垃圾，有慢又是一堆bug，其结果不如不用ejb实现（ejb不等于j2ee）
无论学习什么语言，都应该看大量代码，你看的代码量不到一定数量，是学不好j2ee的,另外看代码也是一个学习别人良好编程习惯和规范的好方法，有时候你意识不到自己的代码写的有多烂,:) 目前有很多开源的工程可以作为教材：
jive论坛
petstore sun公司
dune sun公司
等等，研读一个，并把它用到自己的工程中来。 6)J2ee其他学习
当你渐渐对j2ee了解到一定深度时，你要开始关注当前领域中的一些技术变化，J2ee是一块百家争鸣的领域，大家都在这里提出自己的解决方案，例如struts，hibernate，ofbiz等等，学习这些东西要你的项目和目标而定，预先补充一下未尝不可，但不用涉及太深，毕竟学习原理和理论是最最重要的事。 7)利用网络资源
java手册 http://www.javaalmanac.com/ 极好的一个在线帮助
开源网站 http://www.sourceforge.net/
J2EE讨论 http://www.theserverside.com/
www.javaworld.com
www.java.sun.com 8)学习极限编程
J2EE项目是多人合作的项目，也是调试很困难的一类项目。如果没有良好的项目规划是不能
做好J2EE项目的，了解和项目开发管理相关的知识也有必要
项目管理：Ant,类似于C语言中make的作用
版本管理：CVS等，例如wincvs，tortoise cvs
单元测试：JUnit，摆脱插入main到类中进行调试的原始方法
压力测试：JMeter，开源工程，简单，易用
目前常见j2eeAPI
JavaServer Pages(JSP)技术1.2
Java Servlet技术2.3
JDBC API 2.0
Java XML处理API(JAXP)1.1
Enterprise JavaBeans技术2.0
Java消息服务(JMS)1.0
Java命名目录接口(JNDI)1.2
Java事务API(JTA) 1.0
JavaMail API 1.2
JavaBeans激活架构(JAF)1.0
J2EE连接器体系结构(JCA)1.0
Java认证和授权服务(JAAS)1.0
学习上面的某些API要以你的项目而定，了解所有他们总之是有好处的
上面印证了大家说的一句话，java语言本身不难学，但是技术太多，所以学java很费劲。回想一下，基本上每个初学者，在刚学习java的时候可能都会问别人这么一句话，你怎么知道的哪个方法(api)在哪个包里的？呵呵，无他，唯手熟尔。9)JAVA相关软件
* Jakarta - jakarta.apache.org
* Sourceforge - www.sourceforge.net
* Java Boutique - javaboutique.internet.com
* Giant Java Tree - www.git.org
* GUN java programs - www.gnu.org/software

刚刚把帖子认真的看了一遍,朋友们都好热情.我也是刚刚接触JAVA,而且没有其他语言的基础,虽然大家说的不一样,但是都是需要打好基础,我先看看JAVA基础,有什么不会的希望大家帮忙,谢谢各位了

我想下面的资料对你有用，标签中间是地址
[htm]http://www.juju365.com/news/index.asp?flag=1&newstag=JAVA&offset=0[/htm]

开始写代码吧．
如果觉得累好好考虑考虑自己是否喜欢java如果你只是喜欢java的名气　　很难有所成就的

我也很迷茫，现在也是刚学完JAVA，JSP学了点，在做项目，但是有很多的疑问，哎，不知道路在何方了

第一个版本会打印出标准错误，第二个则打印出我们的选择流程。若在Windows下工作，就不能重定向标准错误。因此，我们一般愿意使用第二个版本，并将结果送给System.out；这样一来，输出就可重定向到我们希望的任何路径。
除此以外，我们还可从Throwable的基础类Object（所有对象的基础类型）获得另外一些方法。对于违例控制来说，其中一个可能有用的是getClass()，它的作用是返回一个对象，用它代表这个对象的类。我们可依次用getName()或toString()查询这个Class类的名字。亦可对Class对象进行一些复杂的操作，尽管那些操作在违例控制中是不必要的。本章稍后还会详细讲述Class对象。
下面是一个特殊的例子，它展示了Exception方法的使用（若执行该程序遇到困难，请参考第3章3.1.2小节“赋值”）：
//: ExceptionMethods.java
// Demonstrating the Exception Methods
package c09;public class ExceptionMethods {
  public static void main(String[] args) {
    try {
      throw new Exception("Here's my Exception");
    } catch(Exception e) {
      System.out.println("Caught Exception");
      System.out.println(
        "e.getMessage(): " + e.getMessage());
      System.out.println(
        "e.toString(): " + e.toString());
      System.out.println("e.printStackTrace():");
      e.printStackTrace();
    }
  }
} ///:~该程序输出如下：Caught Exception
e.getMessage(): Here's my Exception
e.toString(): java.lang.Exception: Here's my Exception
e.printStackTrace():
java.lang.Exception: Here's my Exception
        at ExceptionMethods.main可以看到，该方法连续提供了大量信息——每类信息都是前一类信息的一个子集。
--------------
catch(Exception e) {
System.out.println("一个违例已经产生");
throw e;
}
------------
//: Rethrowing.java
// Demonstrating fillInStackTrace()public class Rethrowing {
  public static void f() throws Exception {
    System.out.println(
      "originating the exception in f()");
    throw new Exception("thrown from f()");
  }
  public static void g() throws Throwable {
    try {
      f();
    } catch(Exception e) {
      System.out.println(
        "Inside g(), e.printStackTrace()");
      e.printStackTrace();
      throw e; // 17
      // throw e.fillInStackTrace(); // 18
    }
  }
  public static void
  main(String[] args) throws Throwable {
    try {
      g();
    } catch(Exception e) {
      System.out.println(
        "Caught in main, e.printStackTrace()");
      e.printStackTrace();
    }
  }
} ///:~
---------------
originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.f(Rethrowing.java:8)
        at Rethrowing.g(Rethrowing.java:12)
        at Rethrowing.main(Rethrowing.java:24)
Caught in main, e.printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.f(Rethrowing.java:8)
        at Rethrowing.g(Rethrowing.java:12)
        at Rethrowing.main(Rethrowing.java:24)
--------------

若将第17行标注（变成注释行），而撤消对第18行的标注，就会换用fillInStackTrace()，结果如下：originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.f(Rethrowing.java:8)
        at Rethrowing.g(Rethrowing.java:12)
        at Rethrowing.main(Rethrowing.java:24)
Caught in main, e.printStackTrace()
java.lang.Exception: thrown from f()
        at Rethrowing.g(Rethrowing.java:18)
        at Rethrowing.main(Rethrowing.java:24)
------------------------
//: ThrowOut.java
public class ThrowOut {
  public static void
  main(String[] args) throws Throwable {
    try {
      throw new Throwable();
    } catch(Exception e) {
      System.out.println("Caught in main()");
    }
  }
} ///:~
----------------
//: RethrowNew.java
// Rethrow a different object from the one that
// was caughtpublic class RethrowNew {
  public static void f() throws Exception {
    System.out.println(
      "originating the exception in f()");
    throw new Exception("thrown from f()");
  }
  public static void main(String[] args) {
    try {
      f();
    } catch(Exception e) {
      System.out.println(
        "Caught in main, e.printStackTrace()");
      e.printStackTrace();
      throw new NullPointerException("from main");
    }
  }
} ///:~输出如下：originating the exception in f()
Caught in main, e.printStackTrace()
java.lang.Exception: thrown from f()
        at RethrowNew.f(RethrowNew.java:8)
        at RethrowNew.main(RethrowNew.java:13)
java.lang.NullPointerException: from main
        at RethrowNew.main(RethrowNew.java:18)
---------------
//: NeverCaught.java
// Ignoring RuntimeExceptionspublic class NeverCaught {
  static void f() {
    throw new RuntimeException("From f()");
  }
  static void g() {
    f();
  }
  public static void main(String[] args) {
    g();
  }
} ///:~大家已经看到，一个RuntimeException（或者从它继承的任何东西）属于一种特殊情况，因为编译器不要求为这些类型指定违例规范。
输出如下：java.lang.RuntimeException: From f()
at NeverCaught.f(NeverCaught.java:9)
at NeverCaught.g(NeverCaught.java:12)
at NeverCaught.main(NeverCaught.java:15)
----------
//: Inheriting.java
// Inheriting your own exceptionsclass MyException extends Exception {
  public MyException() {}
  public MyException(String msg) {
    super(msg);
  }
}public class Inheriting {
  public static void f() throws MyException {
    System.out.println(
      "Throwing MyException from f()");
    throw new MyException();
  }
  public static void g() throws MyException {
    System.out.println(
      "Throwing MyException from g()");
    throw new MyException("Originated in g()");
  }
  public static void main(String[] args) {
    try {
      f();
    } catch(MyException e) {
      e.printStackTrace();
    }
    try {
      g();
    } catch(MyException e) {
      e.printStackTrace();
    }
  }
} ///:~继承在创建新类时发生：class MyException extends Exception {
  public MyException() {}
  public MyException(String msg) {
    super(msg);
  }
}
---------------
Throwing MyException from f()
MyException
        at Inheriting.f(Inheriting.java:16)
        at Inheriting.main(Inheriting.java:24)
Throwing MyException from g()
MyException: Originated in g()
        at Inheriting.g(Inheriting.java:20)
        at Inheriting.main(Inheriting.java:29)
-----------
//: Inheriting2.java
// Inheriting your own exceptionsclass MyException2 extends Exception {
  public MyException2() {}
  public MyException2(String msg) {
    super(msg);
  }
  public MyException2(String msg, int x) {
    super(msg);
    i = x;
  }
  public int val() { return i; }
  private int i;
}public class Inheriting2 {
  public static void f() throws MyException2 {
    System.out.println(
      "Throwing MyException2 from f()");
    throw new MyException2();
  }
  public static void g() throws MyException2 {
    System.out.println(
      "Throwing MyException2 from g()");
    throw new MyException2("Originated in g()");
  }
  public static void h() throws MyException2 {
    System.out.println(
      "Throwing MyException2 from h()");
    throw new MyException2(
      "Originated in h()", 47);
  }
  public static void main(String[] args) {
    try {
      f();
    } catch(MyException2 e) {
      e.printStackTrace();
    }
    try {
      g();
    } catch(MyException2 e) {
      e.printStackTrace();
    }
    try {
      h();
    } catch(MyException2 e) {
      e.printStackTrace();
      System.out.println("e.val() = " + e.val());
    }
  }
} ///:~
------------------
Throwing MyException2 from f()
MyException2
        at Inheriting2.f(Inheriting2.java:22)
        at Inheriting2.main(Inheriting2.java:34)
Throwing MyException2 from g()
MyException2: Originated in g()
        at Inheriting2.g(Inheriting2.java:26)
        at Inheriting2.main(Inheriting2.java:39)
Throwing MyException2 from h()
MyException2: Originated in h()
        at Inheriting2.h(Inheriting2.java:30)
        at Inheriting2.main(Inheriting2.java:44)
e.val() = 47

try {
// 要保卫的区域：
// 可能“掷”出A,B,或C的危险情况
} catch (A a1) {
// 控制器 A
} catch (B b1) {
// 控制器 B
} catch (C c1) {
// 控制器 C
} finally {
// 每次都会发生的情况
}
---------
//: FinallyWorks.java
// The finally clause is always executedpublic class FinallyWorks {
  static int count = 0;
  public static void main(String[] args) {
    while(true) {
      try {
        // post-increment is zero first time:
        if(count++ == 0)
          throw new Exception();
        System.out.println("No exception");
      } catch(Exception e) {
        System.out.println("Exception thrown");
      } finally {
        System.out.println("in finally clause");
        if(count == 2) break; // out of "while"
      }
    }
  }
} ///:~
---------
Exception thrown
in finally clause
No exception
in finally clause
----------
//: OnOffSwitch.java
// Why use finally?class Switch {
  boolean state = false;
  boolean read() { return state; }
  void on() { state = true; }
  void off() { state = false; }
}public class OnOffSwitch {
  static Switch sw = new Switch();
  public static void main(String[] args) {
    try {
      sw.on();
      // Code that can throw exceptions...
      sw.off();
    } catch(NullPointerException e) {
      System.out.println("NullPointerException");
      sw.off();
    } catch(IllegalArgumentException e) {
      System.out.println("IOException");
      sw.off();
    }
  }
} ///:~
--------------
//: WithFinally.java
// Finally Guarantees cleanupclass Switch2 {
  boolean state = false;
  boolean read() { return state; }
  void on() { state = true; }
  void off() { state = false; }
}public class WithFinally {
  static Switch2 sw = new Switch2();
  public static void main(String[] args) {
    try {
      sw.on();
      // Code that can throw exceptions...
    } catch(NullPointerException e) {
      System.out.println("NullPointerException");
    } catch(IllegalArgumentException e) {
      System.out.println("IOException");
    } finally {
      sw.off();
    }
  }
} ///:~
-----------------------
//: AlwaysFinally.java
// Finally is always executedclass Ex extends Exception {}public class AlwaysFinally {
  public static void main(String[] args) {
    System.out.println(
      "Entering first try block");
    try {
      System.out.println(
        "Entering second try block");
      try {
        throw new Ex();
      } finally {
        System.out.println(
          "finally in 2nd try block");
      }
    } catch(Ex e) {
      System.out.println(
        "Caught Ex in first try block");
    } finally {
      System.out.println(
        "finally in 1st try block");
    }
  }
} ///:~
---------------
Entering first try block
Entering second try block
finally in 2nd try block
Caught Ex in first try block
finally in 1st try block
--------------
//: LostMessage.java
// How an exception can be lostclass VeryImportantException extends Exception {
  public String toString() {
    return "A very important exception!";
  }
}class HoHumException extends Exception {
  public String toString() {
    return "A trivial exception";
  }
}public class LostMessage {
  void f() throws VeryImportantException {
    throw new VeryImportantException();
  }
  void dispose() throws HoHumException {
    throw new HoHumException();
  }
  public static void main(String[] args)
      throws Exception {
    LostMessage lm = new LostMessage();
    try {
      lm.f();
    } finally {
      lm.dispose();
    }
  }
} ///:~输出如下：A trivial exception
        at LostMessage.dispose(LostMessage.java:21)
        at LostMessage.main(LostMessage.java:29)

今天第一次来Java这边论坛，我是做.net的,我同事30学的编程,今年35了,一样很强，每天也很快乐。学习编程年龄没有定律，只有你想，还是不想，支持楼主，认准了就坚持自己。

to FreeDom_lulu():
偶毕业三年多了。现在虚岁已经是27了。现在也喜欢JAVA。也在学。能不能介绍一下你的那位朋友的“事迹”呀。也许能从中找到些信心呢。
偶的email:[email protected]欢迎交流交流。

同在学习中，看了这个贴，感觉受益匪浅，发现CSDN的朋友们真的非常赞（从这个楼就可以看出），赞一下每位CSDNer。希望自己能够和楼主同勉！◎
现在就把魔兽给删了！

我觉得多看看例子程序，看到不懂的，查查API就行了啊！

我也是刚学java不久，感觉很迷茫，请各位多指点指点！先谢过了

我也是刚学java不久.先谢过了

年轻人``` 用点心~^_^~ !~!~! <)". ."(>
( (..) ) you 成功!

J2SE这么多软件包,你会了多少?朋友,路还早着呢.呵呵.加油!

调试易

一个JAVA初学者的迷茫，大伙来讨论

解决方案 »