java上位机开发（java基础）

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;}@Overridepublic 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文件就好了。