java如何编程

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java如何编程相关的知识，希望对你有一定的参考价值。

java的编程

呵呵 问题很有意思！你要是懂编程就知道java是如何编程的了！！！！ 编程 ：　　　　简单的说，编程就是为了借助于计算机来达到某一目的或解决某个问题，而使用某种程序设计语言编写程序代码，并最终得到结果的过程。
　　计算机虽然功能十分强大。可以供你上网、打游戏、管理公司人事关系等等，但是没有程序，它就等于是一堆废铁，不会理会我们对它下达的“命令”。于是，我们要驯服它，只有通过一种方式——程序，这也是我们和计算机沟通比较特殊的方式。 [编辑本段]编程原理　　程序也就是指令的集合，它告诉计算机如何执行特殊的任务。打个比方说，它好比指导你烹调菜品的菜谱或指挥行驶一路到达目的地的交警（或者交通路标）。没有这些特殊的指令，就不能执行预期的任务。计算机也一样，当你想让计算机为你做一件事情的时候，计算机本身并不能主动为我们工作，因此我们必须对它下达指令，而它根本不会也不可能听懂人类自然语言对事情的描述，因此我们必须使用程序来告诉计算机做什么事情以及如何去做？甚至对最简单的任务也需要指令，例如如何取得击键，怎样在屏幕上放一个字母，怎样在磁盘中保存文件等等。
　　上面讲到的计算机本身不会主动的做任何事情。因此我们要通过程序的方式来让计算机为我们“效劳”。而这个过程就是我们“编”出来的。编程可以使用某一种程序设计语言来实现，按照这种语言的语法来描述让计算机要做的事情。
　　我们这里所讲的语法和外语中的语法完全两码事，这里讲的语法只是读你的程序书写做出一些规定而已。写出程序后，再由特殊的软件将你的程序解释或翻译成计算机能够识别的“计算机语言”，然后计算机就可以“听得懂”你的话了，并会按照你的吩咐去做事了。因此，编程实际上也就是“人给计算机出规则”这么一个过程。 常见的编程语言：　　　　* CSS Cascading Style Sheets 层叠样式表
　　* .NET 是微软2002年,为开发应用程序创建的一个富有革命性的新平台
　　* ActionScript ActionScript是Flash的脚本语言,与javascript相似，ActionScript是一种面向对象编程语言。
　　* APL、A＋和J
　　* Ada Ada是一种表现能力很强的通用程序设计语言
　　* 汇编语言 汇编语言(Assembly Language)是面向机器的程序设计语言
　　*易语言是全中文语言编程中最为强大的一个编程语言
　　* AWK AWK是一种优良的文本处理工具
　　* Basic 是一种设计给初学者使用的程序设计语言
　　o QBasic QBASIC是BASIC（Beginner's All-purpose Symbolic Instruction Code，初学者通用指令代码）语言的一个变种，由美国微软公司开发
　　o Visual Basic Visual Basic（VB）是一种由微软公司开发的包含协助开发环境的事件驱动编程语言
　　* VBScript VBScript是Visual Basic Script的简称，即 Visual Basic 脚本语言
　　* Brainfuck Brainfuck是一种极小化的计算机语言
　　* C、C++ 、C# C语言是一种面向过程的计算机程序设计语言 ; C++是一种静态数据类型检查的，支持多重编程范式的通用程序设计语言。它支持过程化程序设计、数据抽象、面向对象程序设计、制作图标等等泛型程序设计等多种程序设计风格。C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。
　　o Objective-C 通常写作ObjC和较少用的Objective C或Obj-C，是扩充C的面向对象编程语言
　　* Clipper Clipper芯片主要用于商业活动的计算机通信网
　　* COBOL 一种适合于商业及数据处理的类似英语的程序设计语言
　　* dBase dBASE是第一个在微型计算机上被广泛使用的数据库管理系统（DBMS
　　* PASCAL、Delphi Pascal是一种计算机通用的高级程序设计语言 ;Delphi是全新的可视化编程环境，是一种方便、快捷的Windows应用程序开发工具
　　* Forth 由Charles H. Moore发展出来在天文台使用的电脑自动控制系统及程序设计语言，允许使用者很容易组合系统已有的简单指令，定义成为功能较复杂的高阶指令。
　　* Fortran 译为“公式翻译器”，它是世界上最早出现的计算机高级程序设计语言，广泛应用于科学和工程计算领域。
　　* FoxPro 是由美国Fox Software公司于1988年推出的数据库产品
　　* F＃ F#是由微软发展的为微软.NET语言提供运行环境的程序设计语言
　　* Fava Fava语言是一个小型的解释语言，它主要面向于系统测试领域及小型嵌入式设备。
　　* IDL IDL 是一种数据分析和图像化应用程序及编程语言
　　* Java Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言
　　* JavaScript Javascript是一种由Netscape的LiveScript发展而来的脚本语言
　　* J# Visual J# 是一种工具，供 Java 语言程序员用于构建在 .NET Framework 上运行的应用程序和服务
　　* LISP 一种基于λ演算的函数式编程语言。
　　* Lua Lua 是一个小巧的脚本语言
　　* LOGO 是一种早期的编程语言，也是一种与自然语言非常接近的编程语言，它通过“绘图”的方式来学习编程
　　* Module 在软件工程中，指较高一级程序或模块使用的一个单元或模块
　　* Nuva Nuva语言是一种面向对象的动态脚本语言 Nuva语言的设计目的是用于基于模板的代码生成
　　* Perl Perl 一般被称为“实用报表提取语言”（PracticalExtraction andReportLanguage），也做“病态折中垃圾列表器”(PathologicallyEclectic Rubbish Lister
　　* php PHP 是一种 html 内嵌式的语言
　　* PL/I PL/I是Programming Language One的简写。当中的“I”其实是罗马数字的“一”。它是一只IBM公司在1950年代发明的第三代高级编程语言
　　* Prolog Prolog（Programming in Logic的缩写）是一种逻辑编程语言
　　* Python 是一种面向对象的解释性的计算机程序设计语言，也是一种功能强大而完善的通用型语言
　　* R R是用于统计分析、绘图的语言和操作环境
　　* Ruby Ruby，一种为简单快捷面向对象编程（面向对象程序设计）而创的脚本语言
　　* Scheme Scheme，一种系统设计语言，由LISP语言发展而来,属于lisp的一种方言。与其他lisp不同的是，scheme是可以编译成机器码的。Scheme的一个主要特性是可以像操作数据一样操作函数调用
　　* Smalltalk 一种面向对象的程序设计语言 一种程序设计环境 一个应用开发环境(ADE)
　　* Tcl/Tk 是一种 脚本语言
　　* Visual FoxPro Visual FoxPro原名FoxBase，是美国Fox Software公司推出的数据库产品 参考技术A Java是面向对象编程

新建java项目：总文件夹（java project）
在该项目下的src上new-》package（包，文件夹）
在该文件夹上new-》class

Java的数据类型：基本和引用

Java的编程思想：面向对象编程
Java的编程特点：
封装：
继承：
多态：

类：用class声明，有相同属性和行为的泛指！
属性：就是在类中函数体外定义的变量，称为类属性！有默认值：基本数据类型默认值：0，引用类型默认值全是null。

行为：函数！干什么事？Public 返回值数据类型 方法名()

对象：从类中实例化出来，一定拥有该类的属性和行为的具体一个物质！每个对象的属性值是不相同，属性值是属于每个对象自己的！每个对象调用函数，都是执行该函数体内容。

在main函数中：可以实例化对象，调用该对象的属性和行为！
实例化对象： 类名 对象名 = new 类名（）
调用类属性： 对象.属性
调用类行为： 对象.函数()

类之间可以相互调用！main函数不属于任何类！只是独立程序入口！

Public 返回值数据类型 函数名（）
函数的分类：
无返回值无参数方法
有返回值无参数方法
无返回值有参数方法
有返回值有参数方法

定义方法时，小括号的的内容是形参（可以是任意数据类型，可以是任意个）
调用方法时，小括号的内容是实参，实参和形参必须对应！（数据类型，个数，顺序）
实参自动传递给形参，形参相当于方法体内部的局部变量！

Void:无返回值
只要是有返回值的方法：在方法体最后必须写return 内容; 内容必须属于定义方法时的返回类型

有返回值：返回值数据类型可以写任意数据类型，有返回值的方法调用后，可以赋值给其他变量；把该方法中的一个局部变量传递给了调用的地方！

变量的作用域：
全局变量：类属性！在每一个自定义函数中都可以直接使用！注意该属性属于哪个对象！
在函数体中直接使用类属性；该属性是属于调用该函数的那个对象的属性！如果函数体中，有和类属性同名的变量，一定调用函数体中的局部变量！

局部变量：在方法体内部或者代码块中声明的变量！ 参考技术B 其实和C语言差不多，只是Java在写程序要先引入类和方法，然后再用一些C语言的知识就能编写了，(如下机是计算1—10之间的和是多少例子：)public class apublic static void main(String args[]) int i,sum=0;for(i=1;i<=10;i++) sum=sum+i;System.out.println("sum="+sum); 参考技术C 最好自己多找一些事例到电脑上运行下

Java并发编程：如何创建线程？

 

　　在前面一篇文章中已经讲述了在进程和线程的由来，今天就来讲一下在Java中如何创建线程，让线程去执行一个子任务。下面先讲述一下Java中的应用程序和进程相关的概念知识，然后再阐述如何创建线程以及如何创建进程。下面是本文的目录大纲：

　　一.Java中关于应用程序和进程相关的概念

　　二.Java中如何创建线程

　　三.Java中如何创建进程

　　若有不正之处，请多多谅解并欢迎批评指正。

　　请尊重作者劳动成果，转载请标明原文链接：

 　　http://www.cnblogs.com/dolphin0520/p/3913517.html

一.Java中关于应用程序和进程相关的概念

　　在Java中，一个应用程序对应着一个JVM实例（也有地方称为JVM进程），一般来说名字默认为java.exe或者javaw.exe（windows下可以通过任务管理器查看）。Java采用的是单线程编程模型，即在我们自己的程序中如果没有主动创建线程的话，只会创建一个线程，通常称为主线程。但是要注意，虽然只有一个线程来执行任务，不代表JVM中只有一个线程，JVM实例在创建的时候，同时会创建很多其他的线程（比如垃圾收集器线程）。

　　由于Java采用的是单线程编程模型，因此在进行UI编程时要注意将耗时的操作放在子线程中进行，以避免阻塞主线程（在UI编程时，主线程即UI线程，用来处理用户的交互事件）。

二.Java中如何创建线程

　　在java中如果要创建线程的话，一般有两种方式：1）继承Thread类；2）实现Runnable接口。

　　1.继承Thread类

　　继承Thread类的话，必须重写run方法，在run方法中定义需要执行的任务。

1
2
3
4
5
6
7
8
9
10
11
12
class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

 　　创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，不是调用run()方法启动线程，run方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Test {
    public static void main(String[] args)  {
        MyThread thread = new MyThread();
        thread.start();
    }
}
 
 
class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

 　　在上面代码中，通过调用start()方法，就会创建一个新的线程了。为了分清start()方法调用和run()方法调用的区别，请看下面一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID:"+Thread.currentThread().getId());
        MyThread thread1 = new MyThread("thread1");
        thread1.start();
        MyThread thread2 = new MyThread("thread2");
        thread2.run();
    }
}
 
 
class MyThread extends Thread{
    private String name;
     
    public MyThread(String name){
        this.name = name;
    }
     
    @Override
    public void run() {
        System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
    }
}

 　　运行结果：

　　从输出结果可以得出以下结论：

　　1）thread1和thread2的线程ID不同，thread2和主线程ID相同，说明通过run方法调用并不会创建新的线程，而是在主线程中直接运行run方法，跟普通的方法调用没有任何区别；

　　2）虽然thread1的start方法调用在thread2的run方法前面调用，但是先输出的是thread2的run方法调用的相关信息，说明新线程创建的过程不会阻塞主线程的后续执行。

　　2.实现Runnable接口

　　在Java中创建线程除了继承Thread类之外，还可以通过实现Runnable接口来实现类似的功能。实现Runnable接口必须重写其run方法。

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID："+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
 
 
class MyRunnable implements Runnable{
     
    public MyRunnable() {
         
    }
     
    @Override
    public void run() {
        System.out.println("子线程ID："+Thread.currentThread().getId());
    }
}

 　　Runnable的中文意思是“任务”，顾名思义，通过实现Runnable接口，我们定义了一个子任务，然后将子任务交由Thread去执行。注意，这种方式必须将Runnable作为Thread类的参数，然后通过Thread的start方法来创建一个新线程来执行该子任务。如果调用Runnable的run方法的话，是不会创建新线程的，这根普通的方法调用没有任何区别。

　　事实上，查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

　　在Java中，这2种方式都可以用来创建线程去执行子任务，具体选择哪一种方式要看自己的需求。直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。

三.Java中如何创建进程

 　　在Java中，可以通过两种方式来创建进程，总共涉及到5个主要的类。

　　第一种方式是通过Runtime.exec()方法来创建一个进程，第二种方法是通过ProcessBuilder的start方法来创建进程。下面就来讲一讲这2种方式的区别和联系。

　　首先要讲的是Process类，Process类是一个抽象类，在它里面主要有几个抽象的方法，这个可以通过查看Process类的源代码得知：

　　位于java.lang.Process路径下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class Process
{
    
    abstract public OutputStream getOutputStream();   //获取进程的输出流
      
    abstract public InputStream getInputStream();    //获取进程的输入流
 
    abstract public InputStream getErrorStream();   //获取进程的错误流
 
    abstract public int waitFor() throws InterruptedException;   //让进程等待
  
    abstract public int exitValue();   //获取进程的退出标志
 
    abstract public void destroy();   //摧毁进程
}

　　1）通过ProcessBuilder创建进程

　　ProcessBuilder是一个final类，它有两个构造器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public final class ProcessBuilder
{
    private List<String> command;
    private File directory;
    private Map<String,String> environment;
    private boolean redirectErrorStream;
 
    public ProcessBuilder(List<String> command) {
    if (command == null)
        throw new NullPointerException();
    this.command = command;
    }
 
    public ProcessBuilder(String... command) {
    this.command = new ArrayList<String>(command.length);
    for (String arg : command)
        this.command.add(arg);
    }
....
}

 　　构造器中传递的是需要创建的进程的命令参数，第一个构造器是将命令参数放进List当中传进去，第二构造器是以不定长字符串的形式传进去。

　　那么我们接着往下看，前面提到是通过ProcessBuilder的start方法来创建一个新进程的，我们看一下start方法中具体做了哪些事情。下面是start方法的具体实现源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public Process start() throws IOException {
// Must convert to array first -- a malicious user-supplied
// list might try to circumvent the security check.
String[] cmdarray = command.toArray(new String[command.size()]);
for (String arg : cmdarray)
    if (arg == null)
    throw new NullPointerException();
// Throws IndexOutOfBoundsException if command is empty
String prog = cmdarray[0];
 
SecurityManager security = System.getSecurityManager();
if (security != null)
    security.checkExec(prog);
 
String dir = directory == null ? null : directory.toString();
 
try {
    return ProcessImpl.start(cmdarray,
                 environment,
                 dir,
                 redirectErrorStream);
} catch (IOException e) {
    // It\'s much easier for us to create a high-quality error
    // message than the low-level C code which found the problem.
    throw new IOException(
    "Cannot run program \\"" + prog + "\\""
    + (dir == null ? "" : " (in directory \\"" + dir + "\\")")
    + ": " + e.getMessage(),
    e);
}
}

 　　该方法返回一个Process对象，该方法的前面部分相当于是根据命令参数以及设置的工作目录进行一些参数设定，最重要的是try语句块里面的一句：

1
2
3
4
return ProcessImpl.start(cmdarray,
                    environment,
                    dir,
                    redirectErrorStream);

 　　说明真正创建进程的是这一句，注意调用的是ProcessImpl类的start方法，此处可以知道start必然是一个静态方法。那么ProcessImpl又是什么类呢？该类同样位于java.lang.ProcessImpl路径下，看一下该类的具体实现：

　　ProcessImpl也是一个final类，它继承了Process类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final class ProcessImpl extends Process {
 
    // System-dependent portion of ProcessBuilder.start()
    static Process start(String cmdarray[],
             java.util.Map<String,String> environment,
             String dir,
             boolean redirectErrorStream)
    throws IOException
    {
    String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
    return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);
    }
 ....
}

 　　这是ProcessImpl类的start方法的具体实现，而事实上start方法中是通过这句来创建一个ProcessImpl对象的：

1
return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);

 　　而在ProcessImpl中对Process类中的几个抽象方法进行了具体实现。

　　说明事实上通过ProcessBuilder的start方法创建的是一个ProcessImpl对象。

　　下面看一下具体使用ProcessBuilder创建进程的例子，比如我要通过ProcessBuilder来启动一个进程打开cmd，并获取ip地址信息，那么可以这么写：

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String[] args) throws IOException  {
        ProcessBuilder pb = new ProcessBuilder("cmd","/c","ipconfig/all");
        Process process = pb.start();
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

 　　第一步是最关键的，就是将命令字符串传给ProcessBuilder的构造器，一般来说，是把字符串中的每个独立的命令作为一个单独的参数，不过也可以按照顺序放入List中传进去。

　　至于其他很多具体的用法不在此进行赘述，比如通过ProcessBuilder的environment方法和directory(File directory)设置进程的环境变量以及工作目录等，感兴趣的朋友可以查看相关API文档。

　　2）通过Runtime的exec方法来创建进程

　　首先还是来看一下Runtime类和exec方法的具体实现，Runtime，顾名思义，即运行时，表示当前进程所在的虚拟机实例。

　　由于任何进程只会运行于一个虚拟机实例当中，所以在Runtime中采用了单例模式，即只会产生一个虚拟机实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Runtime {
    private static Runtime currentRuntime = new Runtime();
 
    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
    return currentRuntime;
    }
 
    /** Don\'t let anyone else instantiate this class */
    private Runtime() {}
    ...
 }

 　　从这里可以看出，由于Runtime类的构造器是private的，所以只有通过getRuntime去获取Runtime的实例。接下来着重看一下exec方法 实现，在Runtime中有多个exec的不同重载实现，但真正最后执行的是这个版本的exec方法：

1
2
3
4
5
6
7
public Process exec(String[] cmdarray, String[] envp, File dir)
   throws IOException {
   return new ProcessBuilder(cmdarray)
       .environment(envp)
       .directory(dir)
       .start();
   }

 　　可以发现，事实上通过Runtime类的exec创建进程的话，最终还是通过ProcessBuilder类的start方法来创建的。

　　下面看一个例子，看一下通过Runtime的exec如何创建进程，还是前面的例子，调用cmd，获取ip地址信息：

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String[] args) throws IOException  {
        String cmd = "cmd "+"/c "+"ipconfig/all";
        Process process = Runtime.getRuntime().exec(cmd);
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

 　　要注意的是，exec方法不支持不定长参数（ProcessBuilder是支持不定长参数的），所以必须先把命令参数拼接好再传进去。

　　关于在Java中如何创建线程和进程的话，暂时就讲这么多了，感兴趣的朋友可以参考相关资料、

　　参考资料：

　　http://luckykapok918.blog.163.com/blog/static/205865043201210272168556/

　　http://www.cnblogs.com/ChrisWang/archive/2009/12/02/use-java-lang-process-and-processbuilder-to-create-native-application-process.html

　　http://lavasoft.blog.51cto.com/62575/15662/

　　《Java编程思想》

以上是关于java如何编程的主要内容，如果未能解决你的问题，请参考以下文章

java编程思想如何理解？

Java如何支持函数式编程？

[编程][JAVA]在JAVA中如何终止线程中socket.accpet() ? 端口一直被占用

Java 编程

如何更优雅的使用 Java 8 函数式编程？

java并发编程看啥书比较好