java复习笔记

Math 类主要提供了下面 5 个与取整相关的方法：
1） static double ceil(double a)：返回大于等于 a 的最小整数。
2） static double floor(double a)：返回小于等于 a 的最大整数。
3） static double rint(double a)：四舍五入方法，返回与 a 的值最相近的整数，为 double类型。
4） static long round(double a)：四舍五入方法，返回与 a 的值最相近的长整型数。
5） static int round(float a)：四舍五入方法，返回与 a 


接口和抽象类的区别;
接口（ interface）和抽象类（ abstract class）是支持抽象类定义的两种机制（注意，该句中前后两个抽象类的意义不一样，前者表示的是一个实体，后者表示的是一个概念）。
两者具有很大的相似性，甚至有时候是可以互换的。但同时，两者也存在很大的区别。
具体而言，接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，如果一个类中包含抽象方法，那么这个类就是抽象类。
在 Java 语言中，可以通过把类或者类中的某些方法声明为 abstract（ abstract 只能用来修饰类或者方法，不能用来修饰属性）来表示一个类是抽象类。接口就是指一个方法的集合，接口中的所有方法都没有方法体，在 Java 语言中，接口是通过关键字 interface 来实现的。
包含一个或多个抽象方法的类就必须被声明为抽象类，抽象类可以声明方法的存在而不去实现它，被声明为抽象的方法不能包含方法体。在抽象类的子类中，实现方法必须含有
相同的或者更低的访问级别（ public->protected->private）。抽象类在使用的过程中不能被实例化，但是可以创建一个对象使其指向具体子类的一个实例。抽象类的子类为父类中所有的
抽象方法提供具体的实现，否则，它们也是抽象类。接口可以被看作是抽象类的变体，接口中所有的方法都是抽象的，可以通过接口来间接地实现多重继承。接口中的成员变量都是
static final 类型，由于抽象类可以包含部分方法的实现，所以，在一些场合下抽象类比接口存在更多的优势。
接口与抽象类的相同点如下：
1）都不能被实例化。
2）接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能被实例化。
接口与抽象类的不同点如下：
1）接口只有定义，不能有方法的实现，而抽象类可以有定义与实现，即其方法可以在抽象类中被实现。
2）实现接口的关键字为 implements，继承抽象类的关键字为 extends。一个类可以实现多个接口，但一个类只能继承一个抽象类，因此，使用接口可以间接地达到多重继承的目的。
3）接口强调特定功能的实现，其设计理念是“ has-a”关系，而抽象类强调所属关系，其设计理念为“ is-a”关系。
4）接口中定义的成员变量默认为 public static final，只能够有静态的不能被修改的数据成员，而且，必须给其赋初值，其所有的成员方法都是 public、 abstract 的，而且只能被这两
个关键字修饰。而抽象类可以有自己的数据成员变量，也可以有非抽象的成员方法，而且，抽象类中的成员变量默认为 default，当然也可以被定义为 private、 protected 和 public，这些
成员变量可以在子类中被重新定义，也可以被重新赋值，抽象类中的抽象方法（其前有abstract 修饰）不能用 private、 static、 synchronized 和 native 等访问修饰符修饰，同时方法必
须以分号结尾，并且不带花括号{}。所以，当功能需要累积时，使用抽象类；不需要累积时，使用 接口。
5）接口被运用于实现比较常用的功能，便于日后维护或者添加删除方法，而抽象类更倾向于充当公共类的角色，不适用于日后重新对里面的代码进行修改




java中实现多线程的方式：
Java 虚拟机（ Java Virtual Machine， JVM，是运行所有 Java 程序的抽象计算机，是 Java 语言的运行环境）允许应用程序并发地运行多个线程。在 Java 语言中，多线程的实现一般有以下三种方法：
1）实现 Runnable 接口，并实现该接口的 run()方法。
以下是主要步骤：
① 自定义类并实现 Runnable 接口，实现 run()方法。
② 创建 Thread 对象，用实现 Runnable 接口的对象作为参数实例化该 Thread 对象。
③ 调用 Thread 的 start()方法。
class MyThread implements Runnable
{ 
//创建线程类
public void run()
{
System.out.println("Thread body");}
}
}
public class Test
{
public static void main(String[] args)
{
MyThread thread=new MyThread();
Thread t=new Thread(thread);
t.start(); //开启线程
}
}
2）继承 Thread 类，重写 run 方法。
Thread 本质上也是实现了 Runnable 接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过 Thread 类的 start()方法。 start()方法是一个 native（本地）方
法，它将启动一个新线程，并执行 run()方法（ Thread 中提供的 run()方法是一个空方法）。这种方式通过自定义类直接 extends Thread，并重写 run()方法，就可以启动新线程并执行自己
定义的 run()方法。需要注意的是，当 start()方法调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（ Runnable），什么时候运行多线程代码是由操作系统决定的。
下例给出了 Thread 的使用方法。
class MyThread extends Thread
{
//创建线程类
public void run()
{
System.out.println("Thread body"); //线程的方法体
}
}
public class Test
{
public static void main(String[] args)
{
MyThread thread=new MyThread();
thread.start(); //开启线程
}
}
3）实现 Callable 接口，重写 call()方法。
Callable对象实际是属于 Executor框架中的功能类，Callable接口与 Runnable接口类似，但是提供了比 Runnable 更强大的功能，主要表现为以下三点：
① Callable 可以在任务结束后提供一个返回值， Runnable 无法提供这个功能。
② Callable 中的 call()方法可以抛出异常，而 Runnable 的 run()方法不能抛出异常。
③ 运行 Callable 可以拿到一个 Future 对象， Future 对象表示异步计算的结果。它提供了检查计算是否完成的方法。由于线程属于异步计算模型，所以无法从其他线程中得到方法
的返回值，在这种情况下，就可以使用 Future 来监视目标线程调用 call()方法的情况，当调用 Future 的 get()方法以获取结果时，当前线程就会阻塞，直到 call()方法结束返回结果。
示例代码如下所示：import java.util.concurrent.*;
public class CallableAndFuture
{
// 创建线程类
public static class CallableTest implements Callable<String>
{
public String call() throws Exception
{
return "Hello World!";
}
}
public static void main(String[] args)
{
ExecutorService threadPool = Executors.newSingleThreadExecutor();
// 启动线程
Future<String> future = threadPool.submit(new CallableTest());
try
{
System.out.println("waiting thread to finish");
System.out.println(future.get()); // 等待线程结束，并获取返回结果
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
上述程序的输出结果为
waiting thread to finish
Hello World!
在以上三种方式中，前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。当需要实现多线程时，一般推荐实现 Runnable 接口的方式，原因如下：首先， Thread 类
定义了多种方法可以被派生类使用或重写，但是只有 run 方法是必须被重写的，在 run 方法中实现这个线程的主要功能。这当然是实现 Runnable 接口所需的同样的方法。而且，很多
Java 开发人员认为，一个类仅在它们需要被加强或修改时才会被继承。因此，如果没有必要重写 Thread 类中的其他方法，那么通过继承 Thread 的实现方式与实现 Runnable 接口的效
果相同，在这种情况下最好通过实现 Runnable 接口的方式来创建线程。