java详解第四章：接口与线程

1.接口

       1.1前言

       我们之前讲过继承，我们知道一个子类只能继承一个父类，正如一个儿子只有一个亲生父亲一样。那如果我们定义的几个子类中有除了他们继承的父类所有的属性和方法，还有别的共同的属性和方法，但是他们继承的父类并没有这些属性和方法，他们又不能继承多个父类，怎么办呢？这里就可以用接口。

       1.2接口的定义

       接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合。接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

       正如父类对子类就像父亲对儿子，接口就像是一张目录，它会告诉看它的人他有什么项目，但是项目内容它不会给你。目录不像父亲，一个人可以看很多张目录，也就是一个类可以接很多个接口。接口与类一样，都有属性和方法。但是由于接口是一个抽象的集合，所以它的属性必须是不可更改的静态属性，方法也是没有方法体的抽象方法。

       1.3接口的格式

       为了方便理解，这里我拿类的定义和接口的定义做个比较：

       ①. 类的定义：

       关键字：class

public class 类名{

       //属性

       权限修饰符      数据类型     属性名;

       //方法

       权限修饰符    返回值的数据类型   方法名(参数1,参数2,……){

              //方法体                         

       }

}

②. 接口的定义：

       关键字：interface

public interface 接口名{

       //属性

       [public static final]   数据类型     属性名= 初始值;

       //public static final 三个关键字都可以不写，但不能更改成其他的

       //方法

       [public abstract]    返回值的数据类型   方法名(参数1,参数2,……);

       // public abstract 两个关键字都可以不写，但不能更改成其他的

}

       1.4接口的使用

       接口本身不能创建对象。

       使用接口，则必须创建一个类，实现接口。实现接口，必须重写接口的所有方法。

       关键字： implements（注意和定义接口的关键字不一样）

       publicclass 类名 implements 接口名

2.线程

       2.1前言

       所谓的多任务，是指在同一时刻有多个程序在同时运行的能力。例如，可以在进行QQ聊天的同时，进行下载并播放音乐。当然，除非计算机中有多个CPU，否则操作系统会将CPU的时间划分成小的片段，并将其分配给不同的程序，使人产生一种并行处理的错觉。这种资源分配方法之所以可行，是因为CPU的处理速度非常快，大部分时间是空闲的。

       2.2定义

       线程(Thread)和进程(Process)的关系很紧密，进程和线程是两个不同的概念，进程的范围大于线程。

       通俗地说，进程就是一个程序，程序运行的整个过程就是进程，而线程是这个程序能够同时做的各件事情。比如，媒体播放机运行时就是一个进程，而媒体播放机同时做的下载文件和播放歌曲，就是两个线程。因此，可以说进程包含线程。从另一个角度讲，每个进程都拥有一组完整的属于自己的变量，而线程则共享一个进程内的这些数据。

       一般来说，没有定义线程的类在运行时，整个运行进程就是一个线程。程序启动时，一个线程立刻运行，该线程通常称为程序的主线程。在Java中，main()就是主线程。其他子线程都是由主线程产生的，主线程通常必须最后完成执行，因其需执行各种关闭动作。

       2.3线程的定义

       在Java中有两种方式定义线程，一种是通过继承的方式，另一种是通过接口的方式。两种方式在实例化与调用时是不同的。

       关键词：Thread，run，start

       1.父类Thread

       Java提供了类 java.lang.Thread 来方便多线程编程，这个类提供了大量的方法方便控制线程.

       Thread类最重要的方法是run() ，它为Thread 类的方法 start() 所调用。为了指定我们自己的代码，需要覆盖run()方法，来提供我们的线程所要执行的代码。

public class example extends Thread{

    public void run(){

       //线程运行的方法体

    }

    public static void main(String[] args) {

       //打开线程

       example ex = new example();

       ex.start();

    }

}

       2.接口Runnable

public class example implements Runnable{

    public void run(){

       //线程运行的方法体

    }

    public static void main(String[] args) {

       //打开线程

       example ex = new example();

       Thread t = new Thread(ex);

       t.start();

    }

}

       总而言之还是Thread类在进行线程实现，后者可以再继承别的类，前者不行，但前者直接实例化自己的类然后开启线程，后者实例化之后还要引入Thread类进行线程开启。

       2.4线程的别的方法

       在线程中不止有开启线程的start()一种方法，还有许多别的进行线程之间控制的方法。

       ①.currentThread()；getName()；setName(String s);

//MainThreadDemo.java

public class MainThreadDemo  {

       public static void main(String args[])  {

              Thread t = Thread.currentThread();

              System.out.println("当前线程名称是: " + t.getName());

              t.setName("MyJavaThread");

              System.out.println("改名后线程名称是: " + t.getName());

              System.out.println("输出当前线程: " + t);            

       }

}

       1）Thread.currentThread() 是一个静态方法，返回正在执行的线程对象的引用。我们知道main函数是程序的入口点，这里引用的线程就是主线程，通过getName()方法得到当前引用线程的名称，从程序的结果我们可以看出，名称是main。

       2）通过setName(String s) 可以改变线程的内部名称。

       ②.sleep(int time)；wait()；join()；interrupt();

       每一个线程都有四个状态：新建状态(new)，就绪状态(调用start()时)，运行状态(运行run()里的内容时)，阻塞状态以及死亡状态(线程运行结束)。

       sleep是Thread类里的一个静态方法，其内容是进行time次空循环，以毫秒为单位，从而造成线程阻塞，即等待的效果。sleep(1000)也就是循环1000次就是1秒，我们可以通过更改参数达到自己期待的等待的效果。

publicclass ThreadTest1 {

       public static void main(String[] args) throws Exception {

              System.out.println("传送文件1");

              Thread.sleep(1000 * 10);

              System.out.println("文件1传送完毕");

              System.out.println("传送文件2");

              Thread.sleep(1000 * 10);

              System.out.println("文件2传送完毕");

              System.out.println("传送文件3");

              Thread.sleep(1000 * 10);

              System.out.println("文件3传送完毕");

       }

}

       wait()方法可以令线程进入阻塞状态，导致当前的线程等待，直到其他线程调用此对象的notify() 方法或notifyAll() 唤醒方法。

       join()方法可以让别的线程进入阻塞状态，知道当前线程运行完之后，再运行别的线程。

public void work() throws Exception{

       CalThread ct = new CalThread();

       SaveThread st = new SaveThread();

       ct.start();

       ct.join();

       st.start();

}

public static void main(String[] args) throws Exception {

       new ThreadCooperateTest2().work();

}

       在运行线程ct时，命令另一个线程st等待线程ct运行完毕，才能抢占CPU进行运行。

       interrupt()方法比较特殊，它不会导致线程中断，他只是通过别的线程的控制来改变该线程的中断状态。没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意，被中断线程可以决定如何应对中断。

public class example extends Thread{

    public void run(){ 

        while(true){ 

            if(Thread.currentThread().isInterrupted()){ 

                System.out.println("Someone interrupted me."); 

            } 

            else{ 

                System.out.println("Thread is Going..."); 

            }

        } 

    } 

    public static void main(String[]args) throws InterruptedException { 

        example t = new example(); 

        t.start(); 

        Thread.sleep(3000); 

        t.interrupt(); 

    } 

}

以上，便是我对接口与线程相关知识与概念的理解和概括。欢迎大家在评论里讨论！