【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】
java基础就是把java环境安装好，把基础程序构建起来。至少说让开发的同学来说有一点信心。从这一点来说，就算编写一个“Hello world”也是非常有必要的。
java编程准备主要有两点，第一，安装jdk软件，也就是编译开发环境；第二，就是选择一个IDE，这里面可以选择eclipse或者IDEA，当然选择notepad++纯编辑器也是可以的。
准备好编程环境之后，就开始了解一下需要掌握的内容。这个时候，可以画一个脑图来分析一下，
1、编写最简单的Hello world
编写Hello world非常重要。有的书籍，或者是教学视频，一上来说了很多历史，但是却不告诉同学怎么用起来，这非常不可取。
import java.io.*;
public class process {
public static void main(String args[])
{
System.out.println("Hello, world!");
}
}程序内容不复杂，这部分第一行import类似于c/c++中的include，相当于引用第三方库。紧接着定义了一个process类。在process类当中定义了一个main函数。函数中的内容也很简约，就是打印一个“Hello world”程序。
编译、执行，
相关操作也很简单。javac负责生成字节码。java负责启动虚拟机运行。
2、输入
有了上面的数据打印，下面可以看一下输入是怎么做的，
import java.io.*;
import java.util.Scanner;
public class process
{
public static void main(String []args)
{
Scanner input = new Scanner(System.in);
System.out.println("Please input an integer:");
int a = input.nextInt();
System.out.println("You input an integer:" + a);
}
}和输出相比较，输入多了一些新的内容。首先输出的数据是a，这个是整数。此外，a的获取来自于input，而input又是来自于Scanner的数据类型，这部分呢，又是在第二行的import中可以查看到。因此，有理由相信，这个整数的输入也是来自于第三方库Scanner。基本上了解到这些就可以了，
3、int/char/string/float/double数据类型的显示
每一种语言都有自己的数据表示方法。java也不例外，
import java.io.*;
public class process
{
public static void main(String []args)
{
int a = 10;
char b = 'a';
String c = "abc";
float d = 1.0f;
double e = 1.1234;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
}
}这部分内容没有什么难度，可以直接编译、运行，查看结果即可，
4、array数组
有了数据，肯定就有数组。数组本质上可以看成是一块内存。在这片内存里面存了很多相同类型的数据，
import java.io.*;
public class process
{
public static void main(String []args)
{
int a[] = new int[5];
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
a[4] = 4;
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);
}
}这里我们定义了一个长度为5的数组。数组中的数据类型是整数，数组的第一个数据是从0开始的，这部分和c语言是一样的，没有什么区别。接着就是编译、执行；
5、逻辑判断
5.1 if-else
逻辑判断的种类很多，这里可以一一说明。首先就从if-else开始。因为之前我们测试了输入，所以可以设计一个判断输入数据是否是偶数的测试demo，
import java.io.*;
import java.util.Scanner;
public class process
{
public static void main(String []args)
{
Scanner input = new Scanner(System.in);
System.out.println("Please input an integer:");
int a = input.nextInt();
if(a % 2 != 0)
{
System.out.println("You input an odd integer.");
}
else
{
System.out.println("You input an even integer.");
}
}
}为了验证代码是否正确，可以测试一下，
5.2 for循环
for循环是比较常见的一个循环。可以测试下，怎么用java编写1到100的数据计算，
import java.io.*;
public class process
{
public static void main(String []args)
{
int total = 0;
for(int i = 0; i < 100; i ++)
{
total += (i+1);
}
System.out.println("total = " + total);
}
}编译、运行，查看一下执行结果，
5.3 while循环
和for循环相比较，while循环只能把判断条件写在括号里面，初始化和自增的部分只能分别在循环外和循环里面来完成了。
import java.io.*;
public class process
{
public static void main(String []args)
{
int total = 0;
int i = 0;
while(i < 100)
{
total += (i+1);
i += 1;
}
System.out.println("total = " + total);
}
}继续编译执行，不出意外，结果应该是和for循环一样的，
5.4 switch语句
switch可以看成是多次的if-else比较，这里为了方便还是拿奇数、偶数来验证下，
import java.io.*;
import java.util.Scanner;
public class process
{
public static void main(String []args)
{
Scanner input = new Scanner(System.in);
System.out.println("Please input an integer:");
int a = input.nextInt();
int b = a % 2;
switch(b)
{
case 1:
System.out.println("You input an odd integer.");
break;
case 0:
System.out.println("You input an even integer.");
break;
default:
System.out.println("Exception happened.");
break;
}
}
}继续编译、运行来测试下，
6、类
类是java里面很重要的一个属性。很多的特性，比如继承、封装、多态都是来自于这里。实际使用的时候，可以先从最常见的属性来进行学习。
6.1 构造函数
import java.io.*;
public class process
{
public process()
{
System.out.println("construct process class");
}
public static void main(String []args)
{
process p = new process();
}
}这里只是构建了一个最简单的process类，构造函数就是process()。在函数中有一个println打印。在main函数当中，可以看到声明了一个实例p，在声明的过程中调用到了process()这个构造函数，因此就会出现相应的打印。
6.2 overload
这个单词不太好翻译成中文。简单来说，就是类中的函数名可以重复，但是参数不可以相同，这样就可以用相同的函数名构建类似功能的不同函数，比如说构造函数。
import java.io.*;
public class process
{
public process()
{
System.out.println("construct process class");
}
public process(int data)
{
System.out.println("construct process class, input is " + data);
}
public static void main(String []args)
{
process p = new process();
process q = new process(10);
}
}继续编译、运行，查看结果，
6.3 继承
继承是比较通用的概念，这部分可以直接用示例来说明，
import java.io.*;
class parent
{
public parent()
{
System.out.println("construct parent class");
}
};
class child extends parent
{
public child()
{
System.out.println("construct child class");
}
};
public class process
{
public static void main(String []args)
{
child c = new child();
}
}这里有两种类。一种是parent，一种是child，在main函数中构建child类的时候，除了调用child的构造函数，还会继续调用parent构造函数，这就是继承。
6.4 多态
多态如果用c++中的概念来对应，那就是虚函数，这样就可以轻松对上了。
import java.io.*;
class parent
{
public parent()
{
return;
}
public void print()
{
System.out.println("print in parent class");
}
};
class child extends parent
{
public child()
{
return;
}
@Override
public void print()
{
System.out.println("print in child class");
}
};
public class process
{
public static void main(String []args)
{
parent p = new child();
p.print();
}
}这段代码最有意思的地方，就是把child的实例赋值给parent，然后调用parent中的print函数。结果打印出来的，不是parent.print的内容，而是child.print的内容，这就是多态的意义所在。注意这里面使用到了@Override这个注解。
6.5 接口
接口这个概念在c++里面好像不太好找，勉强对的上的就是虚类了。
import java.io.*;
interface run
{
public void print();
}
class parent implements run
{
public parent()
{
return;
}
public void print()
{
System.out.println("print in parent class");
}
};
public class process
{
public static void main(String []args)
{
run r = new parent();
r.print();
}
}这个run就是interface，可以看成是某个具体的动作。编译、测试，
6.6 静态函数
静态函数的概念比较简单，我们一开始使用的main函数就是静态函数。
import java.io.*;
public class process
{
public static void print()
{
System.out.println("static print function");
}
public static void main(String []args)
{
process.print();
}
}直接运行、测试，
7、package
package的概念其实就是c++里面namespace的概念。同一个package里面的java类可以相互调用，不同package里面的java代码必须添加import才可以。
假设有package1里面有文件process1.java和process2.java，其中process1.java内容如下所示，
package package1;
import java.io.*;
public class process1
{
public static void main(String []args)
{
process2 p = new process2();
}
}这个时候process2.java代码如下，
package package1;
import java.io.*;
public class process2
{
public process2()
{
System.out.println("construct process2 class");
}
}此时因为process1.java和process2.java在同一个目录下面，那么process1就可以实例化process2类。编译、测试一下，
8、import
之前在package测试中，我们说到了同一个目录下的java引用不需要什么额外操作。但是，如果是不同目录下的java呢，这个时候就需要import的参与了。
假设此时有一个其他目录的process3.java文件也想实例化process2，它应该怎么做呢？
package package2;
import java.io.*;
import package1.process2;
public class process3
{
public static void main(String []args)
{
process2 p = new process2();
}
}这里我们发现，在process3中除了package之外，多了一个import package1.process2的语句。这就告诉我们，第一，当前process3.java和对应的process2.java不在同一个目录；第二，如果要实例化对应的class，那么直接去那个目录下查找对应的class文件就好了。
测试结果也表明，这个想法是正确的。
注：
这篇文章几乎是目前写过的最长的blog，不过还没有把所有java的基本特性描述出来。只是对于新手来说，只要有了这个基础，其实是可以做一些小工具、小测试了，java也算是被我们真正用起来了。
900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
