下面小编给大家整理的java编程学习方法有哪些（共含12篇），希望大家喜欢!同时，但愿您也能像本文投稿人“www123456”一样，积极向本站投稿分享好文章。
Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。java编程学习方法有哪些呢?
一.初接触软件技术,先挑技术门槛低的技能方向入手。
如果你完全是个外行，只懂得电脑的一般操作和OFFICE的使用，就先从网页制作开始学习，学习DREAMWEAVER的使用。比如自己设定一个小目标：做个人主页，在纸上画框架，然后用DREAMWEAVER慢慢实现，不会使用，就上网搜教程，最好搜到视频、动画或者带图的教程，通俗易懂。用DREAMWEAVER做网页的同时要对照看代码，再找HTML、CSS、JAVASCRIPT的系统手册。这些手册不要一篇一篇的看，你刚开始只看一个大概，了解能实现什么样的效果，在具体项目中再通过手册查代码命令。
熟悉完前台制作后，要了解脚本语言，比如JSP、PHP、C#之类。自己再设定一个小目标;如留言簿。上网搜源码，下载到本地，一步一步的配置环境变量、启动TOMCAT服务器、部署JSP代码，设置好ACCESS数据库(数据库先从简单的ACCESS开始)。这样做的好处是从整体上了解搭建一个WEB运行环境需要的步骤和环节，利于后期的学习。
数据库软件可以从简单的MYSQL、MSSQL开始，了解一下如何建表结构，查看数据，权限机制就可以，更多的内容等接触实际项目的时候再学习也来得及。学习方式同样的是买一本大而全的教材，先大体翻一遍，或者请技术前辈勾划几个常用的重点内容，其他的使用整体了解一下。
以上学习教程针对WEB开发技术的，如果是做偏底层开发，就不适合了。
二.从实用角度出发来学习.
在学习每一个环节技术时，都要给自己设定一个小功能目标，以目标来驱动自己学习。如果盲目看书、各个技术环节都要去了解，就会对学习产生抵触，结果是什么都学不进去。
大部培训机构和大学里的教学方式就是这样，比如讲JAVA，对初学者讲大通的面向对象思想：继承、接口、抽象类，把JDK所有的包都详细讲一遍，IO流、socket编程、SWING等等，并不说这些不重要，只是对于初学者理解不了这些概念。我比较偏向于先从形象的，容易理解的学起，比如能基于关系型数据库做个单表的增删改查~~
三.找个技术前辈做指导
所谓技术前辈是做过几个实际项目的的开发人员，他们很清楚在实际项目中最常用的技术是哪些，哪些开源项目好用。
找到技术前辈并不是帮你解决几行代码调试不通的问题，关键是帮你介绍一两本入门的书、介绍一些网上好的资源网站、指导学习哪些常用类、遇到麻烦的技术难点用什么开源组件等等。
有个好师傅非常非常的重要!! 让你少走很多弯路。
四.脸皮要厚,不怕被人笑话
刚开始做技术，进入软件公司工作，就很不自信，总觉得自己这也不知道，那也不了解。其实，没关系，你要对自己树立信心，你要明白一点：所有的技术都没什么难度，都是熟能生巧的过程。 所以，一遇到问题就赶紧问老开发人员，平时上下班，吃饭时多跟他们聊;业务上不懂的就问项目经理和需求分析员，没什么关系的。
我再讲个极端一点的情况，我个人刚学技术时，头两家公司都是把我开掉的，为什么呢?因为我那时水平确实太差了。 但每一次公司工作的机会都让我进了一步。后来遇到几个同行，有好几个人也有同样被开除的经历。为了学习技术，就别担心面子的问题了。
在外打工，遇到的同事在你人生过程之中都是过客，没有人会把你某段代码不会写当成笑话记一辈子的。坦城、自信很重要!
五.在打工过程中多长心眼,除技术外,想积累人脉.技能.项目经验
我们不能做一辈子程序员，以后总要升级转行，做项目经理、做售前、或者是公司高管。但这些都需要前期的积累。你在打工过程中，除了挣钱，还要积累技术、积累人脉关系，包括与技术和销售同事之间(以后做项目，遇到技术难点得找人问;或者同事以后接到项目要找人合作说不准就想到你了)、与客户之间的(这个很重要)，积累项目经验，主要是学习各个行业的业务知识，象电信、金融、电力、ERP等。如果你进了某个行业，比如电信、电力，你再跳槽就最好别换行业了。
软件开发行业中最流行的开发语言就是Java语言，但是Java语言流行了十几年，从事Java开发行业的人也是最多的，现在学习Java开发还有前途吗?
Java开发行业前景
Java语言是一门很实用的语言，在互联网的应用十分广泛，目前采用JAVA语言开发的网站也越来越多，所以对Java开发人才的需求量也是倍增。虽然说现在新的开发语言在市场上越来越多，但是根据有关数据表明，在所有程序员中，Java开发程序员就占据20%的比例。这说明Java开发仍然是一个热潮，它强大的影响力已经证明了自己的王者风范。
一位软件开发行业的前辈讲到，不可否认Java开发语言本身的庞大，它是全球最流行的开发语言，给程序界带来很大的影响，势必继续影响着整个互联网。
从人才需求方面看，软件开发是当下的发展趋势，而我国的软件开发人才极为缺乏，其中java人才缺口最大，对java软件工程师的需求达到全部需求量的60%-70%，如今互联网的趋势是移动端，Java又是安卓开发的基础，所以人才的需求又增加一大波。
从薪资水平看，java软件工程师的薪资相比其他开发工程师高出许多，具备3-5年工作经验的开发人员年薪都可以达到20到30万元。
所以说java的发展前景还是非常可观的，如果可以真正学好java这门技能，那我们的发展前景也是不可估量。现在很多人选择参加培训机构，这不失为一个最佳的选择，当然最重要的还是靠自己的努力。
Java软件工程师的就业前景
java软件工程师就业前景如何是许多软件工程师都困惑的问题，他们有的时候甚至不知道自己选择的行业是否正确，为了帮助许多java软件工程师走出困境，下面就是专门针对java软件工程师就业前景进行详细的解析，在了解了相关的情况下，不知道你否还会坚持在软件工程师的行业中继续发展。
java软件工程师就业前景的好坏主要从Java的应用领域来看，Java语言的应用方向主要表现在以下三个方面：
首先是大中型的商业应用，包括我们常说的企业级应用(主要指复杂的大企业的软件系统)、各种类型的网站，Java的安全机制以及它的跨平台的优势，使它在分布式系统领域开发中有广泛应用;
其次是桌面应用，就是常说的C/S应用，主要用来开发运行于不同的操作系统上的桌面应用程序;
再次是移动领域应用，主要表现在消费和嵌入式领域，是指在各种小型设备上的应用，包括手机、PDA、机顶盒、汽车通信设备等。
近年来我国信息化发展越来越快，使得全国各地的信息化建设如火如荼，出现了大量的信息化人才尤其是Java软件人才的缺口，而我国信息化人才培养还处于发展阶段，导致社会实际需求人才基数远远大于信息化人才的培养基数，使得数以万计的中小企业急需全面系统掌握Java软件开发基础技能与知识的软件工程师。
根据11月TIOBE开发语言排行榜宣布的流行开发语言的排名结果，Java仍然高居榜首，在国内的软件开发企业中，Java语言的使用比例也排名第一。
我国目前对软件人才的需求已达20万，并且以每年20%左右的速度增长。在未来5年内，合格软件人才的需求将远大于供给。
根据IDC的统计数字，在所有软件开发类人才的需求中，对Java工程师的需求达到全部需求量的60%~70%。应该说Java软件工程师的就业机会和前景是非常大的。再加上Java软件工程师不仅IT专业企业需要，广大的非IT企业也需要。前景是非常乐观的。
同时，Java工程师的薪水相对较高。通常来说，具有3~5年开发经验的工程师，拥有年薪10万元是很正常的一个薪酬水平。但是，对Java人才需求旺盛的IT企业却很难招聘到合格的Java人员。
其中，最根本的原因就是许多计算机专业的毕业生在读期间没有掌握实用的技能与经验，距离企业的实际用人需求有较大的差距。因此，计算机专业的大学生欲成为Java工程师，最便捷的一条路就是参加以实战项目为主要教学方法的Java职业技能培训，从而有效地缩短同企业具体用人需求之间的差距。
要使用Java语言胜任企业工作并不容易。比如要成为一名Java架构师，必须精通设计、需求分析、各种开源工具、JavaEE的底层技术;熟悉工作流程、权限框架、门户框架等。而要成为一名Java普通程序员，必须具备基本的J2EE技术(JSP、Servlet、Java语言)，SSH(Struts、Spring、Hibernate)框架开发，一定的数据库设计能力和数据库使用经验，熟悉Web开发技术(比如html+css+Javascript，会ajax更好)。
当前世界各地持有JavaProgrammer证书的人员供需差距极大，迫使企业不得不用高薪聘请Java程序员。因此，JavaProgrammer的含金量比一般的技术人员要高出很大一块。在美国、加拿大、澳大利亚、新加坡等发达国家和中等发达国家，持有JavaProgrammer认证证书的人年薪均在4-10万美金，而在国JavaProgrammer认证的程序员也有极好的工作机会和很高的薪水。
java软件工程师就业前景其实不是一成不变的，而是随着人们的他的需要而变化的，当我们大量需要的时候往往java软件工程师就业前景就会比较明朗，相反的我们不需要了，那么java软件工程师就业前景还会好吗?我们要做的不是看前景的好坏，而是针对自己展开分析。
更多热门文章推荐：
1.Java就业前景如何
2.就业前景最好的十大专业
3.数控技术未来就业前景怎么样?
4.2016学习IT的就业前景分析
5.20信息管理与信息系统就业前景如何
6.2016年数控技术就业前景怎样?
7.软件工程师的就业前景
8.专业就业率前十的排名
9.数控技术专业毕业生就业前景怎么样?
10.JAVA工程师的就业前景分析
1. 读写原始数据，一般采用什么流?( )
A InputStream
B DataInputStream
C OutputStream
D BufferedInputStream
2. 为了提高读写性能，可以采用什么流?( )
A InputStream
B DataInputStream
C BufferedReader
D BufferedInputStream
E OutputStream
F BufferedOutputStream
3. 对各种基本数据类型和String类型的读写，采用什么流?( )
A DataInputStream
B BufferedReader
C PrintWriter
D DataOutputStream
E ObjectInputStream
F ObjectOutputStream
4. 能指定字符编码的I/O流类型是：( )
A Reader
B InputStreamReader
C BufferedReader
D Writer
E PrintWriter
F ObjectInputStream
G ObjectOutputStream
H OutputStreamWriter
5. File类型中定义了什么方法来判断一个文件是否存在?( )
A createNewFile
B renameTo
C
D exists
6. File类型中定义了什么方法来创建一级目录?( )
A createNewFile
B exists
C mkdirs
D mkdir
7. 对文本文件操作用什么I/O流?( )
A FileReader
B FileInputStream
C RandomAccessFile
D FileWriter
8. 在unix服务器www.openlab.com.cn上提供了基于TCP的时间服务应用，该应用使用port为13。创建连接到此服务器的语句是：( )
A Socket s = new Socket(“www.openlab.com.cn”, 13);
B Socket s = new Socket(“www.openlab.com.cn:13”);
C Socket s = accept(“www.openlab.com.cn”, 13);
9. 创建一个TCP客户程序的顺序是：( )
A 获得I/O流
B 关闭I/O流
C 对I/O流进行读写操作
D 建立socket
E 关闭socket
10. 创建一个TCP服务程序的顺序是：( )
A 创建一个服务线程处理新的连接
B 创建一个服务器socket
C 从服务器socket接受客户连接请求
D 在服务线程中，从socket中获得I/O流
E 对I/O流进行读写操作，完成与客户的交互
F 关闭socket
G 关闭I/O流
11. Java UDP编程主要用到的两个类型是：( )
A UDPSocket
B DatagramSocket
C UDPPacket
D DatagramPacket
12. TCP/IP是一种：( )
A 标准
B 协议
C 语言
D 算法
[java 网络编程 面试]
1.现在输入n个数字，以逗号，分开;然后可选择升或者降序排序;按提交键就在另一页面显示按什么排序，结果为，提供reset
import java.util.*;
public class bycomma{
public static String[] splitStringByComma(String source){
if(source==null||source.trim.equals(“”))
return null;
StringTokenizer commaToker = new StringTokenizer(source,“,”);
String[] result = new String[commaToker.countTokens()];
int i=0;
while(commaToker.hasMoreTokens()){
result[i] = commaToker.nextToken();
i++;
}
return result;
}
public static void main(String args[]){
String[] s = splitStringByComma(“5,8,7,4,3,9,1”);
int[] ii = new int[s.length];
for(int i = 0; i
ii[i] =Integer.parseInt(s[i]);
}
Arrays.sort(ii);
//asc
for(int i=0;i
System.out.println(ii[i]);
}
//desc
for(int i=(s.length-1);i>=0;i--){
System.out.println(ii[i]);
}
}
}
2.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半 个”。
代码：
public static boolean isLetter(char c){
int k=0X80;
return c/k==0?true:false;
}
public static int lengths(String strSrc){
if (strSrc==null){
return 0;
}
int len=0;
char[] strChar=strSrc.toCharArray();
for (int i=0;i
len++;
if (!isLetter(strChar[i])) len++;
}
return len;
}
public static String subString(String origin,int len){
if (origin==null || origin.equals(“”)|| len<1){
return “”;
}
if (len>lengths(origin)){
return origin;
}
byte[] strByte=new byte[len];
System.arraycopy(origin.getBytes(),0,strByte,0,len);
int count=0;
for (int i=0;i
int value=(int)strByte[i];
if (value<0) count++;
}
if (count % 2 !=0){
//len=(len==1)?++len:--len;
--len;
}
return new String(strByte,0,len);
}
public static void main(String[] args) {
System.out.println(“”+ subString(“我ABC汉DEF”,6));
}
3、排序都有哪几种方法?请列举。用JAVA实现一个快速排序。
排序的方法有：插入排序(直接插入排序、希尔排序)，交换排序(冒泡排序、快速排序)，选择排序(直接选择排序、堆排序)，归并排序，分配排序(箱排序、基数排序)
快速排序的伪代码。
/ /使用快速排序方法对a[ 0 :n- 1 ]排序从a[ 0 :n- 1 ]中选择一个元素作为m I d d l e，该元素为支点把余下的元素分割为两段left 和r I g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点递归地使用快速排序方法对left 进行排序递归地使用快速排序方法对right 进行排序所得结果为l e f t + m I d d l e + r I g h t
//以下为java程序实现的快速排序算法：
public static void sort(int[] data) {
quickSort(data,0,data.length-1);
}
public static void quickSort(int[] data,int low,int high){
int pivotIndex=(low+high)/2;
swap(data,pivotIndex,high);
int k=partition(data,low-1,high,data[high]);
swap(data,k,high);
if ((k-low)>1) partition(data,low,k-1);
if ((high-k)>1) partition(data,k+1,high);
}
public static int partition(int[] data int low,int high, int pivot ){
do {
while (data[++low]
while (high!=0 && data[--high]>pivot);
swap(data,low,high);
}
while (low
swap(data,low,high);
return low;
}
public static void swap(int[] data int low,int high){
int tmp=data[low];
data[low]=data[high];
data[high]=tmp;
}
public static void main(String[] args){
int[] data = new int[]{89,32,425,32,78,1,53,92};
sort(data);
}
4.试用递归的方法写一下计算菲波那契数列的通项f(n),已知f1=1,f2=1,以后每项都是前两项的和。
..............
public static long fibonacci(long m){
if (m==0 || m==1) return m;
else return fibonacci(m-1)+fibonacci(m-2);
}
5. 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的 getInstance方法获取对它的引用,继而调用其中的方法。
Public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪?
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率!
if (instance==null)
instance=new Singleton();
return instance;
}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
6、创建一个静态方法，给它传入一个对象，请循环的打印出该对象所在类的类名和所实现的方法名(华为笔试最后一道编程)
import java.lang.reflect.*;
public class Test{
public static void test(Object obj){
Class clazz=obj.getClass();
//System.out.println(“类名:”+clazz.getName());
Method[] ms=clazz.getDeclaredMethods();
long len=Array.getLength(ms);
for(int i=0;i
System.out.println(“类名:”+clazz.getName()+“方法名:”+ms[i].getName());
}
}
class A{
public void b(){}
public void c(){}
public void d(){}
public void e(){}
}
public static void main(String[] args){
Test t=new Test();
Test.A a=t.new A();
test(a);
}
}
7、假设字符串类似这样的aba和aab就相等，现在随便给你二组字符串，请编程比较他们看是否相等
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
StringTokenizer st = new StringTokenizer(s);
String s1 = st.nextToken();
String s2 = st.nextToken();
byte[] sa1 = s1.getBytes();
byte[] sb2 = s2.getBytes();
Arrays.sort(sa1);
Arrays.sort(sb2);
String ss1 = new String(sa1);
String ss2 = new String(sb2);
if(ss1.equals(ss2))
System.out.println(“equal”);
else
System.out.println(“not equal”);
8、给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：7842
用正规表达式：“iu7i8hy4jnb2”.replaceAll(“[^\d]”,“”);
9、给你一组字符串让你把它倒叙输出
public static String flashBack(String origin) {
String result = “”;
for (int i = origin.length(); i >0; i--) {
String tmp = origin.substring(i - 1, i);
result += tmp;
}
return result;
}
10、给你一组字符如{1，3，4，7，2，1，1，5，2}，让你输出里面出现次数最多且数值最大的一个，出现几次
public void fun4() {
int[] a = { 4, 1, 2, 4, 5, 1, 1, 1, 5, 1, 3, 4, 5 };
Arrays.sort(a);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + “ ”);
}
System.out.println();
int maxNumber = a[a.length - 1], maxCount = 1;
int curNumber = a[a.length - 1], curCount = 1;
for (int i = a.length - 1; i >0; i--) {
curNumber = a[i];
if (a[i] == a[i - 1]) {
curCount++;
} else {
System.out.println(“i=” + i + “,curCount=” + curCount+ “,maxCount=” + maxCount + “,maxNumber=” + maxNumber);
if (curCount >maxCount) {
maxCount = curCount;
maxNumber = curNumber;
}
curCount = 1;
}
}
if (curCount >maxCount) {
maxCount = curCount;
//maxNumber = curNumber;
}
System.out.println(“curCount=” + curCount + “,maxCount=” + maxCount + “,maxNumber=” + maxNumber);
}
11、求两个数的公约数，M，N
int divisor =1;
for (int i = 2; i <= b; i++) {
if(a%i==0 && b%i==0){
divisor = i;
}
}
System.out.println(a+“和”+b+“的最大公约数是:”+divisor);
}
12、实现数组复制
public void fun8(){
int[] a = {1,2,3,4,56,7,8};
int[] b = (int[])a.clone();
Conica.print(a);
Conica.print(b);
b[0]=100;
Conica.print(a);
Conica.print(b);
}
13、冒泡排序的实现
public void fun9(){
int[] a = {1,5,2,6,8,74,1,25,69,8};
Conica.print(a);
for(int i=0; i
for(int j=0; j
if(a[j]>a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
Conica.print(a);
}
14、编程显示某一文件目录下的文件名
public void fun10(){
File file = new File(“G:\03月份”);
if(file.exists()){
if(file.isDirectory()){
String[] files = file.list();
Conica.println(files);
}
}
}
15、从键盘输入4个十进制数字字符，将其转换为4位时间之数并显示出来
16、编程实现统计文本文件中某个单词的出现频率，并输出统计结果
用HashMap来解决
假设单词不存在跨行的,每个单词用,. ;分割
public static void countNum() throws IOException {
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(“c://file.txt”));
Map map = new HashMap();
for (String s = br.readLine(); s != null; s = br.readLine()) {
StringTokenizer st = new StringTokenizer(s, “,. ;”);
while (st.hasMoreTokens()) {
String temp = st.nextToken();
if (map.containsKey(temp)) {
map.put(temp, new Integer((Integer)map.get(temp) + 1));
} else {
map.put(temp, new Integer(1));
}
}
}
for (Iterator it = map.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
System.out.println(entry.getKey() + “-->” + entry.getValue()
+ “times”);
}
} finally {
br.close();
}
}
17、编程模仿DOS下的dir命令，列出某个目录下的内容
18、编程说明String和StringBuffer字符串的区别
19、编程计算N!的程序，一个使用递归方法，一个不用递归方法
递归 :
long fuction(int n){
if (n==0) return 1;
else
return n* fuction(n-1);
}
不递 :
long s=1;
for(int i=2;i<=n;i++)
{
s*=i;
}
20、编程实现ASCII码和Unicode码之间的转换
21.用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求： “4 ”不能在第三位， “3 ”与 “5 ”不能相连.
此题具体算法及程序可参考：
topic.csdn.net/u/0114/14/1170e023-e8f0-4331-8bd8-516c6f1e40da.html
22。一个字符串中可能包含a~z中的多个字符，如有重复，如String data=“aavzcadfdsfsdhshgWasdfasdf”，求出现次数最多的那个字母及次数，如有多个重复的则都求出。〔金山公司面试题〕
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;
public class FindRepeatChar {
public static void doString(String strInput) {
char[] chars = strInput.toCharArray();
ArrayList lists = new ArrayList();
TreeSet set = new TreeSet();
for (int i = 0; i < chars.length; i++) {
lists.add(String.valueOf(chars[i]));
set.add(String.valueOf(chars[i]));
}
System.out.println(set);
Collections.sort(lists);
System.out.println(lists);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < lists.size(); i++) {
sb.append(lists.get(i));
}
strInput = sb.toString();
System.out.println(strInput);
int max = 0;
String maxString = “”;
ArrayList maxList = new ArrayList();
for (Iterator its = set.iterator(); its.hasNext();) {
String s = (String) its.next();
int begin = strInput.indexOf(os);
int end = strInput.lastIndexOf(os);
int value = end - begin + 1;
if (value >max && value >1) {
max = value;
maxString = os;
maxList.add(os);
} else if (value == max) {
maxList.add(os);
}
}
int index = 0;
for (int i = 0; i < maxList.size(); i++) {
if (maxList.get(i).equals(maxString)) {
index = i;
break;
}
}
System.out.println(“出现最多的字符为：”);
for (int i = 0; i < maxList.size(); i++) {
System.out.println(maxList.get(i) + “”);
}
System.out.println();
System.out.println(“出现最多的次数为：” + max);
}
public static void main(String[] args) {
String strInput = new String(“aavzcadfdsfsdhshgWasdfasdf”);
doString(strInput);
}
}
23.金额转换，阿拉伯数字的金额转换成中国传统的形式如：(￥1011)->(一千零一拾一元整)输出。
package test.money;
import java.text.NumberFormat;
import java.util.HashMap;
public class SimpleMoneyFormat {
public static final String EMPTY = “”;
public static final String ZERO = “零”;
public static final String NE = “壹”;
public static final String TWO = “贰”;
public static final String THREE = “叁”;
public static final String FOUR = “肆”;
public static final String FIVE = “伍”;
public static final String SIX = “陆”;
public static final String SEVEN = “柒”;
public static final String EIGHT = “捌”;
public static final String NINE = “玖”;
public static final String TEN = “拾”;
public static final String HUNDRED = “佰”;
public static final String THOUSAND = “仟”;
public static final String TEN_THOUSAND = “万”;
public static final String HUNDRED_MILLION = “亿”;
public static final String YUAN = “元”;
public static final String JIAO = “角”;
public static final String FEN = “分”;
public static final String DOT = “.”;
private static SimpleMoneyFormat formatter = null;
private HashMap chineseNumberMap = new HashMap();
private HashMap chineseMoneyPattern = new HashMap();
private NumberFormat numberFormat = NumberFormat.getInstance();
private SimpleMoneyFormat() {
numberFormat.setMaximumFractionDigits(4);
numberFormat.setMinimumFractionDigits(2);
numberFormat.setGroupingUsed(false);
chineseNumberMap.put(“0”, ZERO);
chineseNumberMap.put(“1”, ONE);
chineseNumberMap.put(“2”, TWO);
chineseNumberMap.put(“3”, THREE);
chineseNumberMap.put(“4”, FOUR);
chineseNumberMap.put(“5”, FIVE);
chineseNumberMap.put(“6”, SIX);
chineseNumberMap.put(“7”, SEVEN);
chineseNumberMap.put(“8”, EIGHT);
chineseNumberMap.put(“9”, NINE);
chineseNumberMap.put(DOT, DOT);
chineseMoneyPattern.put(“1”, TEN);
chineseMoneyPattern.put(“2”, HUNDRED);
chineseMoneyPattern.put(“3”, THOUSAND);
chineseMoneyPattern.put(“4”, TEN_THOUSAND);
chineseMoneyPattern.put(“5”, TEN);
chineseMoneyPattern.put(“6”, HUNDRED);
chineseMoneyPattern.put(“7”, THOUSAND);
chineseMoneyPattern.put(“8”, HUNDRED_MILLION);
}
public synchronized static SimpleMoneyFormat getInstance() {
if (formatter == null)
formatter = new SimpleMoneyFormat();
return formatter;
}
public String format(String moneyStr) {
checkPrecision(moneyStr);
String result;
result = convertToChineseNumber(moneyStr);
result = addUnitsToChineseMoneyString(result);
return result;
}
public String format(double moneyDouble) {
return format(numberFormat.format(moneyDouble));
}
public String format(int moneyInt) {
return format(numberFormat.format(moneyInt));
}
public String format(long moneyLong) {
return format(numberFormat.format(moneyLong));
}
public String format(Number moneyNum) {
return format(numberFormat.format(moneyNum));
}
private String convertToChineseNumber(String moneyStr) {
String result;
StringBuffer cMoneyStringBuffer = new StringBuffer();
for (int i = 0; i < moneyStr.length(); i++) {//123363
cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(
i, i + 1)));
}
// 拾佰仟万亿等都是汉字里面才有的单位，加上它们
int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
int moneyPatternCursor = 1;
for (int i = indexOfDot - 1; i >0; i--) {
cMoneyStringBuffer.(i, chineseMoneyPattern.get(EMPTY
+ moneyPatternCursor));
moneyPatternCursor = moneyPatternCursor == 8 ? 1
: moneyPatternCursor + 1;
}
String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer
.indexOf(“.”));
cMoneyStringBuffer.(cMoneyStringBuffer.indexOf(“.”),
cMoneyStringBuffer.length());
while (cMoneyStringBuffer.indexOf(“零拾”) != -1) {//inclusive. exclusive.
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零拾”),
cMoneyStringBuffer.indexOf(“零拾”) + 2, ZERO);
}
while (cMoneyStringBuffer.indexOf(“零佰”) != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零佰”),
cMoneyStringBuffer.indexOf(“零佰”) + 2, ZERO);
}
while (cMoneyStringBuffer.indexOf(“零仟”) != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零仟”),
cMoneyStringBuffer.indexOf(“零仟”) + 2, ZERO);
}
while (cMoneyStringBuffer.indexOf(“零万”) != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零万”),
cMoneyStringBuffer.indexOf(“零万”) + 2, TEN_THOUSAND);
}
while (cMoneyStringBuffer.indexOf(“零亿”) != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零亿”),
cMoneyStringBuffer.indexOf(“零亿”) + 2, HUNDRED_MILLION);
}
while (cMoneyStringBuffer.indexOf(“零零”) != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零零”),
cMoneyStringBuffer.indexOf(“零零”) + 2, ZERO);
}
if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)
cMoneyStringBuffer.(cMoneyStringBuffer.length() - 1,
cMoneyStringBuffer.length());
cMoneyStringBuffer.append(fractionPart);
result = cMoneyStringBuffer.toString();
return result;
}
private String addUnitsToChineseMoneyString(String moneyStr) {
String result;
StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);
int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);
cMoneyStringBuffer.(cMoneyStringBuffer.length() - 1, JIAO);
cMoneyStringBuffer.(cMoneyStringBuffer.length(), FEN);
if (cMoneyStringBuffer.indexOf(“零角零分”) != -1)// 没有零头，加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零角零分”),
cMoneyStringBuffer.length(), “整”);
else if (cMoneyStringBuffer.indexOf(“零分”) != -1)// 没有零分，加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零分”),
cMoneyStringBuffer.length(), “整”);
else {
if (cMoneyStringBuffer.indexOf(“零角”) != -1)
cMoneyStringBuffer.(cMoneyStringBuffer.indexOf(“零角”),
cMoneyStringBuffer.indexOf(“零角”) + 2);
// tmpBuffer.append(“整”);
}
result = cMoneyStringBuffer.toString();
return result;
}
private void checkPrecision(String moneyStr) {//5336.53663 10-5-1
int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;
if (fractionDigits >2)
throw new RuntimeException(“金额” + moneyStr + “的小数位多于两位。”); // 精度不能比分低
}
public static void main(String[] args) {
System.out.println(getInstance().format(new Double(8951.11)));
}
}
[java面试编程题]
总结：
1) 建立Socket连接
2) 获得输入/输出流
3)读/写数据
4) 关闭输入/输出流
5) 关闭Socket
1. 编写一个网络应用程序，有客户端与服务器端，客户端向服务器端发送一个字符串，服务器收到该字符串后将其打印到命令行上，然后向客户端返回该字符串的长度，最后，客户端输出服务器端返回的该字符串的长度。
SockectServerTest
Java代码
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServerTest
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(9999);
Socket socket = ss.accept();
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
byte[] buffer = new byte[100];
int length = is.read(buffer);
String content = new String(buffer,0,length);
System.out.println(“read from client:” + content);
int strLength = content.length();
String str = String.valueOf(strLength);
os.write(str.getBytes());
is.close();
os.close();
socket.close();
}
}
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServerTest
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(9999);
Socket socket = ss.accept();
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
byte[] buffer = new byte[100];
int length = is.read(buffer);
String content = new String(buffer,0,length);
System.out.println(“read from client:” + content);
int strLength = content.length();
String str = String.valueOf(strLength);
os.write(str.getBytes());
is.close();
os.close();
socket.close();
}
}
ClientTest
Java代码
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class ClientTest
{
public static void main(String[] args) throws Exception
{
Socket socket = new Socket(“localhost”,9999);
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
String content = “This comes from client”;
os.write(content.getBytes());
byte[] b = new byte[100];
int length = is.read(b);
String str = new String(b,0,length);
System.out.println(“string's length:” + str);
is.close();
os.close();
socket.close();
}
}
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class ClientTest
{
public static void main(String[] args) throws Exception
{
Socket socket = new Socket(“localhost”,9999);
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
String content = “This comes from client”;
os.write(content.getBytes());
byte[] b = new byte[100];
int length = is.read(b);
String str = new String(b,0,length);
System.out.println(“string's length:” + str);
is.close();
os.close();
socket.close();
}
}
[java socket编程面试题]
对象具有状态,行为,标识.对象的五个基本特性:
万物皆对象,抽取待求解问题的任何概念化构件,将其表示为程序中的对象
程序是对象的集合,他们通过发送消息来告知彼此所要做的
每个对象都有自己的由其他对象所构成的存储,创建包含所有对象的包的方式来创建新类型的对象
每个对象都拥有其类型
某一特定类型的所有对象都可以接收同样的消息
1。java还有个“缺省”的访问权限，如果你没用public、protected、private的话，那就是指它了。通常把它称为package访问权限。因为同属这个package的类可以访问这个package中其它类的“缺省”权限的成员，但是出了这个package，它们就都是private的了。
2。多态性，处理类系的时候，通常你不用把它当作某个具体的类型，只要把它当作基类对象就可以了，即把泛型的基类当作派生类来用。非oop的编译器的做法是前绑定，即编译器会产生那个名字的函数调用，而连接器负责将这个调用解析成须执行的代码的绝对地址。oop的编译器用了后绑定，即当你向某个对象送了一个消息后，不到运行时，系统不能确定到底调用哪段代码。java用存储在对象中的信息来计算方法的地址，因此每个对象的运行都会不同。后绑定是java的缺省行为，c++中必须用virtual声明。
3。abstract关键词声明类为抽象类，编译器会阻止任何人创建abstract类的对象，而只是把其派生类的对象上传给它。abstract也可以声明方法，表示这个类所派生的所有类都有这个方法，但是它的实现不在这里。abstract方法只能存在于abstract类中。
4。interface关键词是对abstract类的概念的深化，它不允许你实现任何方法，只作为接口使用.可以继承多个接口，java中无类多重继承。
5。c++支持的变量有自动、静态、寄存器和堆，java只支持堆变量，每次创建对象的时候都要用new来动态分配堆内存。
6。容器和迭代器：容器：c++标准模板类库stl = java标准类库的容器类，迭代器：将基于不同数据结构的容器抽象为一个简单线性序列的类。
7。java是单根继承体系，object作为最终基类使所有对象都具有某些基本操作。单根继承和系统通过reference操控对象，使垃圾回收器可以释放堆内存。
8。java容器只持有object对象，单根继承使它能持有任何对象上传只要把对象的reference直接放入即可，取对象时，必须知道它原有的类型，从容器中取出对象的reference然后强制转换为原因类型(下传：由基类到其派生类)。
9。参数化类型：能够根据需要由编译器自动指派类型的类，c++的模板template即参数化类型。java暂不支持
10。异常是一种能从错误发生的地方被抛出的对象，并被能解决这类问题的异常处理程序所捕获，异常肯定能得到处理，并且能够从错误状态下恢复。java的异常处理是从底层开始的，而且还不能不用，否则就不能编译通过。
11。java语音内置了多线程支持，线程被表示为对象，java还有一定的资源锁定功能,可以通过synchronized关键字锁定对象内存。
12。持久性：java可以通过对象的序列化或java数据对象来实现把对象从磁盘中存储和提取。
13。传统w/s：浏览器上送web服务器的数据由web服务器上的通用网关接口程序CGI处理，常用语言perl、python、C++等。
14。客户端编程：插件：可以为浏览器添加新的功能，甚至创造新的客户端编程语言。脚本语言：把客户端的源代码直接嵌入到html页面中，html页面显示的时候自动激活插件解释这些程序。常用脚本语言javascript、vbscript、tcl/tk等。java：可以通过applet和java web start进行客户端编，applet是一个只能运行在web浏览器里的小程序，applet是被编译过的代码，作为web页面的一部分自动下载，在被激活的时候开始运行。java web start分发在web浏览器外运行的独立程序。Activex操作上不受限制。
15。servlet和jsp是使人们转向使用java开发网站的主要原因。
《Java编程思想》学习笔记
1――面向对象和JVM基础
1.java中的4种访问制权限：
(1).public：最大访问控制权限，对所有的类都可见。
(2).protect：同一包可见，不在同一个包的所有子类也可见。
(3).default：包访问权限，即同一个包中的类可以可见。默认不显式指定访问控制权限时就是default包访问控制权限。
(4).private：最严格俄访问控制权限，仅该类本身可见，对外一切类都不可以访问(反射机制可以访问)。
2.面向对象编程中两种对象组合方式――is-a 和 has-a：
(1).is-a组合：一个类继承具有相似功能的另一个类，根据需要在所继承的类基础上进行扩展。
优点：具有共同属性和方法的类可以将共享信息抽象到父类中，增强代码复用性，同时也是多态的基础。
缺点：子类中扩展的部分对父类不可见，另外如果共性比较少的时候使用继承会增加冗余代码。
(2).has-a组合：has-a组合是在一个类中引用另一个类作为其成员变量。 优点：可扩展性和灵活性高。在对象组合关系中应优先考虑has-a组合关系。 缺点：具有共性的类之间看不到派生关系。
3.多态：
在面向对象编程中，子类中拥有和父类相同方法签名的方法称为子类方法覆盖父类方法，当调用子类方法的某个操作时，不必明确知道子类的具体类型，只需要将子类类型看作是父类的引用调用其操作方法，在运行时，JVM会根据引用对象的具体子类类型而调用应该的方法，这就是多态。
多态的基础是java面向对象编程的晚绑定机制。编程中有如下两种绑定机制：
(1).早绑定：一般在非面向对象编程语言中使用，在程序编译时即计算出具体调用方法体的内存地址。
(2).晚绑定：面向对象编程语言中经常使用，在程序编译时无法计算出具体调用方法体的内存地址，只进行方法参数类型和返回值类型的校验，在运行时才能确定具体要调用方法体的内存地址。
4.java单继承的优点：
相比于C++的多继承，java只支持类的单继承，java中的所有类的共同基类是Object类，Object类java类树的唯一根节点，这种单继承有以下好处：
(1).单继承可以确保所有的对象拥有某种共同的特性，这样对于JVM虚拟机对所有的类进行系统级的操作将提供方便，所有的java对象可以方便地在内存堆栈中创建，传递参数也变的更加方便简单。
(2).java的单继承使得实现垃圾回收器功能更加容易，因为可以确保JVM知道所有对象的类型信息。
5.选择容器对象两个原则：
(1).容器所能提供不同的类型的接口和外部行为是否能够满足需求。
(2).不同容器针对不同的操作效率不同。
6.类型转换：
Java中有两种常见的类型转换：向上类型转换(upcast)和向下类型转换(downcast)：
(1).向上类型转换(upcast)：
向上类型转换是将子类对象强制类型转换为父类类型，经典用法是面向对象的多态特性。向上类型转换时，子类对象的特性将不可见，只有子类从父类继承的特性仍然保持可见，向上类型转换时编译器会自动检查是否类型兼容，通常是安全的。
(2).向下类型转换：
向下类型转换是将父类类型强制转换为子类类型，转换过后父类中不可见的子类特性又恢复可见性，向下类型转换时，编译器无法自动检测是否类型兼容，往往会产生类型转换错误的运行时异常，通常不安全。
7.java中5个存放数据的地方：
(1).寄存器(Registers)：位于CPU内部，是速度最快的存储区，但是数量和容量有限。在java中不能直接操作寄存器。
(2).栈(Stack)：栈位于通用随机访问存储器 (General random-access memory，RAM，内存) 中，通过处理器的栈指针访问，栈指针从栈顶向栈底分配内存，从栈底向栈顶释放内存。栈是仅次于寄存器的速度第二快的存储器，在java程序中，一般的8种 基本类型数据和对象的引用通常存放在栈内存中，不通过new关键字的字符串对象也是存放在栈的字符串池中。栈的优势是，存取速度比堆要快，仅次于寄存器， 栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
(3).堆(Heap)：也是位于通用随机访问存储器 (General random-access memory，RAM，内存) 中的共享内存池。Java的堆是一个运行时数据区，类的对象从中分配空间，凡是通过new关键字创建的对象都存放在堆内存中，它们不需要程序代码来显式的 释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器 会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
(4).常量存储器(Constant storage)：java中的常量是存放在系统内嵌的只读存储器中(read-only memory,ROM)的。
(5).非随机存储器(Non-RAM storage)：对于流对象和持久化对象，通常存放在程序外的存储器，如硬盘。
8.javadoc只处理public和protected访问控制权限的文档注释，private和default权限的稳定注释将被忽略。
9.java中赋值运算：
基本类型赋值是直接复制值，赋值操作后，相互不影响。
引用类型赋值是复制引用值，相当于给对象取一个别名，赋值之后两个引用指向同一个引用对象，相互之间有影响。
在Java中，向方法传递引用类型参数会改变参数的值，不让参数受到影响的解决方法：在方法内首先先将引用克隆一份，然后操作克隆的对象。
10.移位运算：
左移运算符<<：将比特位左移指定位数，右边部分补0，左移一位相当于乘2。
右移运算符>>：将比特位右移指定位数，如果是正数，左边第一位(符号位)补0，其余位补0，如果是负数，左边第一位补1，其余位补0。右移一位相当于除2。
无符号右移运算符>>>：将比特位右移指定位数，不论是正数或者负数，左边移除位统统补0。
11.java中，比int类型小的原始类型(char、byte、short)进行数学运算或者位运算时，数据类型首先转换成int类型，然后进行相应的运算。
12.方法重载(overloading)：方法同名，参数列表不同称为方法重载，注意方法的返回值类型不同不能作为方法重载。
13.java中的析构函数：
Java中没有像C/C++的析构函数，用来销毁不用的对象是否内存空间，只有以下三个方法用于通知垃圾回收器回收对象。
(1).finalize( )只是通知JVM的垃圾收集器当前的对象不再使用可以被回收了，但是垃圾回收器根据内存使用状况来决定是否回收。
finalize最有用的地方是在JNI调用本地方法时(C/C++方法)，调用本地方法的析构函数消耗对象释放函数。
(2). System.gc()是强制析构，显式通知垃圾回收器释放内存，但是垃圾回收器也不一定会立即执行，垃圾回收器根据当前内存使用状况和对象的生命周期自行决定是否回收。
(3).RunTime.getRunTime().gc()和System.gc()类似。
注意：这三个函数都不能保证垃圾回收器立即执行，推荐不要频繁使用。
14.垃圾回收器原理：
(1).引用计数(ReferenceCounting)垃圾回收算法：
一种简单但是速度较慢的垃圾回收算法，每个对象拥有一个引用计数器
(Reference Counter)，当每次引用附加到这个对象时，对象的引用计数器加1。当每次引用超出作用范围或者被设置为null时，对象的引用计数器减1。垃圾回收 器遍历整个对象列表，当发现一个对象的引用计数器为0时，将该对象移出内存释放。
引用计数算法的缺点是，当对象环状相互引用时，对象的引用计数器总不为0，要想回收这些对象需要额外的处理。
引用计数算法只是用来解释垃圾回收器的工作原理，没有JVM使用它实现垃圾回收器。
引用计数的改进算法：
任何存活的对象必须被在静态存储区或者栈(Stack)中的引用所引用，因此当遍历全部静态存储区或栈中的引用时，即可以确定所有存活的对象。每当 遍历一个引用时，检查该引用所指向的对象，同时检查该对象上的所有引用，没有引用指向的对象和相互自引用的对象将被垃圾回收器回收。
(2).暂停复制(stop-and-copy)算法：
垃圾回收器的收集机制基于：任何一个存活的对象必须要被一个存储在栈或者静态存储区的引用所引用。
暂停复制的算法是：程序在运行过程中首先暂停执行，把每个存活的对象从一个堆复制到另一个堆中，已经不再被使用的对象被回收而不再复制。 暂停复制算法有两个问题：
a.必须要同时维护分离的两个堆，需要程序运行所需两倍的内存空间。JVM的解决办法是在内存块中分配堆空间，复制时简单地从一个内存块复制到另一个内存块。
b.第二个问题是复制过程的本身处理，当程序运行稳定以后，只会产生很少的垃圾对象需要回收，如果垃圾回收器还是频繁地复制存活对象是非常低性能的。
JVM的解决方法是使用一种新的垃圾回收算法――标记清除(mark-and-sweep)。 一般来说标记清除算法在正常的使用场景中速度比较慢，但是当程序只产生很少的垃圾对象需要回收时，该算法就非常的高效。
(3).标记清除(mark-and-sweep)算法：
和暂停复制的逻辑类似，标记清除算法从栈和静态存储区开始追踪所有引用寻找存活的对象，当每次找到一个存活的对象时，对象被设置一个标记并且不被回收，当标记过程完成后，清除不用的死对象，释放内存空间。
标记清除算法不需要复制对象，所有的标记和清除工作在一个内存堆中完成。
[java编程思想读书笔记]
1、确定目标
学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到最后也无法确定自己的方向到底是什么，所以，在你开始前，最好先想清楚，你是想成为一名程序员，还是游戏开发者，还是机器人专家?
2、选择一种编程语言
初学者一定要从主流语言开始学习，比如中级语言C和C++。这两种语言是任何一名合格、专业的程序员都必须掌握的，因为它们称得上是软件开发界的主流。但是最好不要从高级语言开始学，如Java，因为这些语言对于初学者来说难度未免太高(高级语言可以以后再学，但是C语言和C++应该作为你的基础)。然而对于完完全全的门外汉的来说，可能C和C++都有点困难，那么你也可以从Python开始学，这种语言被大家广泛认为是适合初学者的。
此外，每一种语言都要学习至少一年。要熟悉编程范式，尤其是面向过程及面向对象这两种;要广泛阅读，多用编译器及IDE(网上有许多免费的)练习编程。
掌握一种语言后，先不要急着运用，而要去多买些数据结构方面的书来看，学习搜索、分类、二叉树及链表创建等概念。因为无论你是要制作游戏还是开发软件，数据结构都是必须要考虑的。
随后，你就可以开始学习更加高难度的语言，如Java。对于进阶学习者来说，可能还需要学习分而治之(Devide-and-conquer)、贪婪算法(Greedy Method)及回溯(Backtracking)等计算机算法，这又要花上至少一年的时间。
3、热爱数学
许多人都由于这样那样的原因而对数学颇不感冒，而作为一名优秀的程序员，却要整天与一箩筐的数学问题打交道。正如你所见，学编程真的是说起来容易做起来难，而它的难并不在于你对一种语言的了解程度，而在于这种语言牵扯到的数学问题。编程中的大多数问题都能在数学模型(如斐波那契数列、弗洛伊德算法、傅立叶级数等等)中找到端倪，更不用说数学公式在解决编程问题中的广泛应用了。所以，现在开始，去学习各种公式及其特性吧，还要仔细钻研算术及微积分，因为不懂数学，就好比巧妇难为无米之炊。
4、要保持内在的动力
记住，罗马建成非一日之功，所以不要在短时间里给自己填压太多知识。学习编程语言并不容易，因为这是一门需要时常调用逻辑思维的知识。你要做的，就是理解程序背后的逻辑，然后不断练习，直到熟能生巧为止。如果你只是死记硬背一些程序，那么你就错过了学习过程中的乐趣，而且一些概念你也未必真的理解。所以，学习编程需要不断地挑战自己，但也不要操之过急。
5、要有耐心
有时，即使是卓有成就的程序员也会被简单的小问题难住，所以，遇到问题时，一定要让自己放松下来。找张草稿纸，想想有什么现成的公式可用，或者自己想一个公式出来。你看，这就是你为什么要学习数据结构和数学。在成为熟练的程序员以前，一个人往往需要花费大把的时间来构思用于解决特定问题的程序。这一过程中，你可以去Project Euler或者Codecademy这样的网站上看看，上面有简单的编程作业及教程，可以用以练习并提高技能。
6、绝不轻言放弃
如果你在编程过程中经常粗心犯错，那么整个过程就会变成一场旷日持久的折磨，然而一旦问题解决，所有的沮丧都会烟消云散。在学习各种算法(傅立叶级数、向量、边界问题、线性代数、矩阵)的同时，也要注意休息。在解决特别复杂的问题时，要按时放松大脑，让困扰在心头的难题暂时转移到潜意识中。另外要有合理的工作计划，当你编程编到倦怠的时候，就可以小憩一会儿，或者出去散一会儿步，但是永远不要说放弃。
7、成为高手
学到这个阶段，你就可以试着去教教别人，并且向别人展示你制作的应用。如果你认识比你更厉害的人，就要与他分享你的想法和问题，这样会使你积累更多的经验;你也可以模仿诸如文本编辑器、windows软件等专业软件来进行自主开发;积极参加相关竞赛来挑战自我。
懂得一种编程语言是很赞的，但更赞的就是懂得多门语言，这不仅仅意味着你的“工具箱”里有了更多的“工具”，更是意味着你掌握了更多解决问题的方法。因为不论你惯用哪种语言，懂得其他语言总是能使你更好地了解常见的抽象概念及问题。所以，有条件的情况下，尽量多学几种语言，最好是学习两三种具有不同设计原理的语言，如Lisp、Java及Perl。但是每一种都要用心学。
8、广泛阅读
许多高水平的程序员阅读量也十分惊人，他们也往往会在输入第一行代码前深思熟虑一番。所以，你一定要多阅读、多思考。每周都要检查一次自己的作品(平时要养成保存代码的习惯，这样日后才能复查、反思);还要多买编程方面的好书。购买的书必须是最值得一看的，而并非是最畅销的。永远不要盲目地追随某一种资源，因为那样只会让你的眼界变得狭隘。一旦你掌握一种知识，就要仔细钻研其用途及改进的可能。
9、去培训中心参加培训
如果你觉得自学效果不理想，就去报名参加一些初级的编程班吧。但是报名前，一定要先向之前在里面学习过的人了解一番。
10、勤加练习
1 Determine your area of interest明确你的兴趣点.
你可以选择任意一门计算机语言起步，首先你要明确学习编程目的。这个可以帮助你确定编程语言的类型，是一个学习的好起点。
如果你的目标是网页开发，也有一大堆不同的语言(有别与计算机应用程序)。移动应用开发也需要一组技能，有别于机器编程。这些决定都将影响你的学习方向。
2 Consider starting with a “simpler” language考虑从简单的语言入门.
学管你们的初衷是什么，编程入门应该选择一个简单的高级语言。这些简单高级语言对初学者很重要，它们会让你明白基础的概念和流程。
最流行的是Python和Ruby。它们是面向对象的,支持Web应用程序 , 而且语法可读性好。
面向对象是指，这个语言是基于对象、数据的集合及数据的操纵来构建的程序的。面向对象的概念在诸如C++,Java, Objective-C, 和PHP广泛应用。
3 Read through some basic tutorials for a variety of languages.
阅读一些基础的教程
如果你还不能确认学习什么编程语言，首先阅读一些基础教程。如果感觉一门语言比另外的语言更有意思，可以尝试一下。网上这类教程很多。
Python - 这门语言是比较好的起步语言，功能非常强大。在编写Web应用程序，游戏应用广泛。
Java -适用于很多的程序，从游戏到Web应用，到ATM机等，都有它的身影。
HTML - 对Web开发者来说，这是必学的一门基础语言。对于开发各类Web应用程序，掌握它是非常必要的。
C - 历史悠久的一门计算机语言，也是一个功能强大的工具,对于学习C++,C#,Object-C来说，它是它们的基础。
1明确面向对象的范畴
我们必须明确一个大方向，也就是说现在面向对象的编程范畴。尽管人工智能曾经有所浪潮(看看Borland为什么有Turbo Prolog)，但未来5-工业界广泛承认并接受的将是面向对象式的编程。
工业界目前最流行的面向对象编程语言就是C++和Java。所以基本上锁定这两个方向就可以了。而且完全可以同时掌握。
2掌握Java的精华特性
掌握Java的精华特性的同时，一定要知道为什么。比如，Interface和multi-thread。用interface是更好的多继承的模型，而多线程则是设计到语言一级的重要特性。要完全理解interface是为什么，用多线程又有几种常用的编程模型。
3开始进行设计
理解了语言的特性是为什么了之后，就可以试着上升到设计这个层次，毕竟学习语言是要用的。目前比较好的开发模式是采用自定向下的面向对象的设计，加上MVC的模式(你可以看一下我介绍的关于MVC的内容)。首先要找出最顶层的对象(这往往是最难的)，然后一层一层往下递归，记住每次应符合7+/-2的原则，因为我们人的短记忆就是这样。一般有图形用户界面的应从界面开始设计。
4学习设计模式
有了基本设计模型后，可以学一些设计模式(Design Pattern)。这是目前证明很有效的。比如体系结构模式(Layering分层，Pipe/Filter管道或过滤器)，设计模式(有很多，比如对象池Object Pool、缓冲池Cache等)，编程模式(比如Copy-on-Write)。
懂了这些模式之后，就会对系统的整体结构有很好的把握，而学术上也有倾向一个系统完全可以由各种模式组合而成。前面提到的MT实际上就有好几种模式，掌握后就不用自己花很多时间去试了。另外一个很重要的领域就是并行和分布式计算领域，大概有20种左右。
5进行编程实践
接下来就不能纸上谈兵了，最好的方法其实是实践。一般教科书上的例子并不能算是实践，只能算是让你掌握语言特性用的。而提倡做实际的Project也不是太好，因为你还没有熟练的能力去综合各种技术，这样只能是你自己越来越迷糊。
我认为比较好的方法是找一些比较经典的例子，每个例子比较集中一种编程思想而设计的，比如在我的实践当中，我曾经学习过一个很经典的例子就是用Java实现的HotDraw(源自SmallTalk)，你可以用rolemodel或hotdraw在搜索引擎上找一下，我记不大清楚了。好象是个网站，上面有原代码和一些基本设计的文档。
另一个来源可以到是个不错的文档基地。从HotDraw上我学到了什么是Framework，以及如何用rolemodel的方式来构造，这样我就可以应用到其他的地方。顺便说一句，这个例子你绝对不会觉得小，只会觉得大，并且他还是真正的商用的Framework。
理解Java思想
Java是一门面向对象编程语言。向对象编程是Java最核心的思想，这也是区分和C等其他编程语言的一个显著特征。掌握面一门语言，首先得掌握它的思想，思想决定高度。这就和我们学习语文和英语一样，汉语学拼音，英语学音标。抓住了核心，学习起来就事半功倍。
弄清基本概念
作为一门语言，Java肯定有着丰富而又简单的概念。弄清这些基本概念也是必不可少的，死记硬背肯定是不行的，重在理解，理解它们之间的区别与联系，分别有那些应用。有些同学打开电脑就照着书本敲代码，根本没有想过这些代码中用到了哪些知识点，更谈不上理解了，这样是没有任何效果的。
多练习
只理解了Java的基本概念是远远不止的，还要知道怎么去使用。刚开始，你可能会觉得Java中那么多东西怎么也记不住，就连写一个小小的入门级程序都要涉及到好多东西。但是，当你亲手在键盘上敲了几遍之后，你就会觉得之前的那些问题都不是问题了。
学会帮助看文档与源代码
Java是一门开放源代码的编程语言。利用网络可以下载官方的帮助文档，当你不知道一个东西怎么用时，你可以打开帮助文档，你的问题一下就解决了。如果还不能解决的话，打开搜索引擎，输入你的问题，你一定会找到答案的。如果你想弄懂Java底层的原理的话，可以去网上下载对应的源代码。看了源代码之后，你会发现Java的世界是多么的奇妙，也会提高你Java编程的水平。
掌握一种好的而且适合自己的学习方法很重要。有些同学在学习Java的过程中会陷入误区，下面将给大家列出初学者容易进入的误区。
盲目追求速度，不重代码质量
速度很重要，但代码质量更重要。一个在追求速度而不注重代码质量的环境下完成的项目，肯定是会有很多问题的，后期要花更多的人力物力来弥补，得不偿失。
没有团队精神，过于自我
一个项目不可能由一个人来独立完成，而是由团队里不同角色的人来共同合作完成的。个人的力量是渺小的，团队的力量是无穷的。当你的队友遇到问题时，如果你能解决，你要不吝帮助。同样，你有问题时，你的队友也会及时帮助你。
没有开源精神
一门技术，如果它是开源的话，它就会变得越来越成熟。当你写了一段团队里都能通用的程序时，你可以告诉你的团队，节省开发的时间，也创造了别人给你提出问题的环境，让你的代码更加完善。
给你的代码写上必要的注释也是非常重要的，好多人写程序时都不愿意写注释，给的理由是没必要或者是时间太紧，试想一下，如果当你正在阅读或者修改一段没有注释的代码时候，你是不是会觉得弄懂它的意思很难，当然你可以花更多的时间去弄懂它，但如果你加了注释的话，就完全没有必要花费更多的时间了。
总之，Java是一门容易上手的编程语言，但想要融会贯通，除了掌握良好的学习方法之外，努力是必不可少的。学习java要对自己有充分的信心，调整学习方法和态度。
一、多收集程序范例、增加编程经验
在PLC的编程方法中，经验法一直受到许多从业者的青睐，并且在经验设计法中资料收集显得尤为重要。首先收集典型程序样例，程序最好有较完整的组成部分：控制任务、I/O分配、硬件接线图、完整的程序及注释。其次要读懂程序，从而分解出程序中用于完成不同任务的组成部分，对于各组成部分中独立完成某一特定功能的子程序或者中断程序应及时收藏到程序库。以便在以后的编程过程中碰到实现类似控制任务时，节约程序设计时间、提高程序调试成功率。再次还需要记录程序闪光点，诸如编程者巧妙的思路、程序结构、应用指令的使用。尤其是应用指令的使用，能够大大的缩短程序长度，减少内存容量，降低系统成本。最后对程序做功能扩展性的设计、调试，并对全过程加以详细记录、再加以总结。通过以上过程就能够有效消化这些程序范例，使其融入到自己以后的编程过程中。经过一段时间的资料收集、理解、消化后，逐步确立适合自己的编程方法。
二、熟练使用软件包
以学习三菱产品为例来介绍软件包的使用。三菱软件包由两个部分组成，编程软件GXDeveloperVersion8C和仿真软件GXSimulator6C。编程软件GXDeveloperVersion8C为设计者提供了编程环境。设计者应熟读编程手册、熟练程序的编辑技巧,使得自己的设计方案得以展现。设计好的程序能否满足控制任务，就必须进行调试,传统的调试方式离不开编程控制器CPU,必要时还需要另外准备输入输出模块、特殊功能模块和外部机器等。仿真软件GXSimulator可提供一个虚拟的实验平台。GXSimulator是在Windows上运行的软元件包，在安装有GXDeveloper的计算机内追加安装GXSimulator，就能够实现不在线时的调试。不在线调试功能内包括软元件的监视测试、外部机器的I/O的模拟操作等。对于个人学习来说，没有实验条件，仿真软件能够在个人计算机上进行顺控程序的开发和调试。使用者通过程序不断的仿真调试，慢慢领会程序设计心得，从而增加编程经验。
三、特殊功能模块
在学习过程中,大部分学生将学习的重心放在了软件编程上,而现代工业控制给PLC提出了许多新的课题,如果用通用I/O模块来解决，在硬件方面费用太高，在软件方面编程相当麻烦，某些控制任务甚至无法用通用I/O模块来完成。因此,学习PLC的特殊功能模块显得尤为重要。这些特殊功能模块有模拟量输入输出模块、高速计数模块和运动控制模块等。这些特殊功能模块PLC厂家都给出了详细的使用手册，用户可以通过仔细研读使用手册来完成特殊功能的实现，使得软件编程简化，降低了经济成本。
学习一门弱类型的编程语言，不要先学习那种具有强制类型的、面向对象的编程语言。严格而言，如果有人对你提到class(类)或继承，那么你就应该去选择其它的途径了。虽然我认同类和继承相关技术是软件开发中必不可少的，但是我强烈认为它们不应该是初学者的选择。
鉴于此，我认为JavaScript对初学者而言是最理想的编程语言，因为：(a)JS解释器在绝大部分浏览器上都可用，(b)它的面向对象特性并不是强制型的，(c)在工业界被广泛使用(是的，即使是web之外的客户端，即使是现在担任设备工程师的我也做嵌入JavaScript的工作。)
说得更具体点，我建议你学习用JavaScript如何去学习下面的事，特别是以这个顺序：
学习如何打印出一些东西，学习如何声明和定义变量，学习基本算术运算操作(包括余数操作)，学习循环(特别是for循环)，学习把抽象重复的代码写成函数，学习字符串和用循环操作字符串，学习数组和数组的循环方法(特别是foreach循环)，学习创建和操作对象数据集。
记住上面的这些并每天写一个程序来实践，直到这些都轻而易举地想起来。
学习Git的基本操作，学习通过命令行使用Git。这意味着要先学习四个Unix/Linux命令(ls,pwd,mkdir,cd)。当学习了这几个命令，也就学会了以“树型”或层次结构的呈现方式查询文件系统。
一旦你掌握了上面的几个Unix/Linux命令，并会从命令行进入文件系统，你就应该学几个基础的Git命令。主要是git init，git status，git add and git commit。
一旦你掌握了Git的基本操作，在学习下面的技术时将其集成到你的工作流中。
学习HTML基础，能够凭记忆创建简单的HTML页面。学习DOM和如何理解HTML作为指定的分层树结构。花点时间来思考它如何关系到你在前面步骤中学到的分层文件系统。
学习CSS选择器，了解它如何让你选定DOM的某些部分。了解DOM元素之间的关系。了解一个DOM元素作为另一个DOM元素的父元素或子元素的含义。理解这与后代和祖先之间的关系有什么不同。记住选择器可以让你通过这些关系来选定某些元素。
学了几年大学，基本对计算机有个感性认识，理性认识不是太多，虽然学了计算机基础，计算机组成原理，计算机体系结构，C语言，操作系统，编译原理，数据结构和算法，数据库，计算机网络，多媒体，软件工程，算法分析等课程，不过总的来说没什么大的收获，毕业设计用Delphi做了个管理系统，现在想想还算不错了，期间也学了学网页制作，Jsp等，当时不知道学计算机干啥，还学了PhotoShop，网页三剑客(DreamWeaver，Firework，Flash)，甚至学了CoreDrawl。
现在想来实在是搞笑，可以说大学生活一片迷茫。现在想来主要是当年网络不下今天这么发达，不知道干什么。以为大学就是走过程，到社会再学习努力的，有点茫然。对大学学的高等数学，线性代数，概率论和数理统计就更不知学了干啥了，但是工作多年后发现都有用!人生很神奇!
不过，不管怎么说，大学还是让我对计算机有个感性认识。这个在以后的工作中还是很重要的。至少知道整个知识脉络，不会的可以知道怎么补。现在回想如果大学可以重来一遍，我认为至少要学好如下课程，阅读如下图书：
计算机基础课程：就是教你如何开机，关机，打字，使用软件的基础课程，这些课程随着社会进步，目前可以说没什么问题了。不过大家使用的基本是微软公司出品的Windows系统，作为专业的计算机学生，强力建议使用基于Linux的系统或者和Linux类似的苹果笔记本(Mac)，苹果的东西是贵，但是值这个价。
有了计算机操作基础，可以学习编程了，推荐从C语言开始学习，使用这本书进行学习《C程序设计语言》，此书是C语言的作者编写就知道是多么的权威了，同时此书有英文版本《C程序设计语言(英文版)》，建议都买了学习，毕竟作为计算机学生，英文不好是不行的，很多国外的先进的东西都是英文的。另外也有一遍习题解答，也同时买了。里面的题目都做一遍，编程水平不会差。如果想继续提高C语言的水平，可以看看其他相关图书，比如C指针等一堆。
光会写简单的程序还是不行的，如何更好的编写程序就得学好数据结构了，大学一般使用的是严蔚敏的那本，好好学就行。我在大学的时候是一本书《数据结构和算法》，不过算法应该继续加强学习，推荐一本进阶图书《算法导论》，此书很难，想要好的发展的看看。数据结构和算法很重要，面试工作这个是核心。
数据库是工作中经常使用的基本工具之一，所以在学校里也要好好学习，不过总的来说，这门课程比较简单，多动手实践即可。推荐如下图书：《transact-sql权威指南》，印象中是很好的书，不过国内好像不出版了。另外考虑未来发展，建议学习mysql，这样官方文档就够用了。
计算机网络在学校里偏向理论，学好概念即可，有条件的可以报名培训CCNA，这样估计会有更好的理解，而且现在培训和考试也不是太贵，个人认为还是不错的。如果要深入学习的个人认为学习标准协议是个不错的选择，推荐图书：《TCP/IP详解卷1:协议》
软件工程学好学校的图书也差不多了，毕竟是学生，不是工人，没有项目环境很多东西也很难理解，即使是项目，其实每家公司管理的也不一样。如果想深入学习的，推荐一本图书：《敏捷软件开发(原则模式与实践)》
学习一种技术最好的方法就是练习，练习，练习。所有我知道的最优秀的程序员都深深的享受编程——编程是一件让他们干起来无由的高兴的事情。也因此他们大量的编程。经常，那是一种不健康的废寝忘食。
学习如何编程——以及如何编好程——并不需要你具有超人的能力。你只需要去按照自己的意愿动手去做，做出点什么东西。
做什么东西并不重要，重要的是你找到东西动手去做。我所认识的那些优秀的程序员，他们都有各自不同的最初学习编程的动机。
有些人学习编程是为了开发动画游戏。有些人是为了解决他们在使用计算机时遇到的问题，或让工作更有效率。有些人是为了开发产品来满足人们的需求。有些人(真正的程序员)学习编程只是他们为了深入了解计算机工作原理的步骤之一 ;他们希望能搞清楚这种机器。有些程序员编程只是因为他们享受解决难题的挑战。
让所有这些“优秀程序员”统一起来的唯一因素就是，他们全因为生活中的某些原因而为编程着迷，继而花大量的时间编程，做大量的，大量的用于练习的项目。
学习编程有以下的学习方法：
1.自学：寻找一个感兴趣的编程方向，了解相关基础知识，不断学习和练习。
2.学习环境：找专业的机构或者找志同道合的朋友一起学习，大家相互监督，相互鼓励。
3.编程语言：学习编程语言是成为程序员的前提。
4.实践能力：只有将学会的编程语言运用到实际中，才能更好地掌握它。
5.不断学习：编程领域的知识更新换代非常快，需要不断学习新知识。
6.寻找导师：寻找一个有经验的导师，能够更快速地掌握编程技能。
7.考取证书：考取相关证书证明自己的编程能力。
★ java个人简历
★ java年终总结
★ 编程学习计划
★ 数控编程技巧
★ 信息编程论文
★ java实习报告
★ Java面试技巧
