JAVA基础

JAVA基础最终课!多线程!

多线程
多任务处理
1.进程是指一种“自包容”的运行程序，有自己的地址空间；线程是进程内部单一的一个顺序控制流
2.基于进程的特点是允许计算机同时运行两个或更多的程序
3.基于线程的多任务处理环境中，线程是最小的处理单位

基于线程的多任务处理的优点
1.基于线程所需的开销更少 (占资源更少)
 ----在多任务中，各个进程需要分配他们自己独立的地址空间
 ----多个线程可共享相同的地址空间并且共同分享同一个进程
2.进程间调用涉及的开销比线程间通信多
3.线程间的切换成本比进程切换成本低

多线程
1.在java中，一个应用程序可以包含多个线程;每个线程执行特定的任务，并可与其他线程并发执行
2.多线程使系统的空转时间最少，提高CPU利用率
3.多线程编程环境用方便的模型隐藏CPU在任务间间切换的事实

为什么使用线程
1.使用线程的一些原因是他们可以帮助
-->是UI响应更快
  时间驱动的UI(如AWT和Swing)有一个事件线程，它处理UI事件，如按键盘活鼠标点击。AWT和Swing程序把事件监听器与UI对象连接。当特定事件(如单击了某个按钮)发生时，这些监听器会收到一个事件对象。事件监听器实在AWT事件线程中调用的

-->执行异步或后台处理

-->时间控制 设置游戏难度，让游戏暂停等

主线程
1.在Java程序启动时，一个线程立刻运行，该线程通常称为程序的主线程
2.每个Java程序都至少有一个线程--->主线程
3.主线程的重要性体现在两个方面:
 --它是惨胜其他子线程的线程。
 --通常它必须最后完成执行，因为它执行各种关闭动作

创建线程
通过以下两种方法创建线程对象
声明一个类，继承Thread类，并且覆盖run()方法  (也可不覆盖，不过Run中为空)
例: class MyThread extends Thread{
 public void run(){
  System.out.println("MyThread");
 }
}

声明一个类，实现Runnable接口，并且覆盖Run()方法
class MyThread implements Runnable{
 public void run(){
  System.out.println("实现Runnable的线程");
 }
}  

要开始(触发)一个新线程,使用start()方法
例:
 MyThread t=new MyThread();
 t.start();

在调用start()方法时,将创建一个新的控制线程,接着它将自动调用run()方法(执行该线程该做的事)

run()方法中的代码定义执行线程所要用的功能

线程的状态
新建(Born):新建的线程出于新建状态  比如 new 一个Thread对象
就绪(Ready):创建一个Thread对象后,它将处于准备状态,等待start()方法被调用
运行(Running):线程在开始执行时进行运行状态 ,调用了start()方法后,自动运行run方法
睡眠(sleeping):线程的执行可通过使用sleep方法来暂时停止.在睡眠后,线程将进入就绪状态,时间到后将再自动再开始运行,睡眠线程不占用处理器
等待(Waiting):如果调用了wait()方法,线程将处于等待状态.用于在两个或多个线程并发运行时.
死亡(Dead)在run()方法已完成执行或其stop()方法被调用之后,线程就处于死亡状态.

可能使线程暂停执行的条件
线程
1.线程优先级比较低,因此它不能得到CPU的控制权
2.使用sleep()方法使线程睡眠
3.通过调用wait()方法,使线程等待.
4.通过调用yield()方法,线程让出CPU控制权
5.线程由于等待一个文件I/O事件被柱塞

Java课程第9章 异常处理机制

概念:

在编写程序中，一定会遇上一些错误，但我们得把它改正过来，这个时候用传统的处理方式显得很繁琐，而且别人极不易读懂，这个时候就需要用Java中的异常处理机制来解决。如果你知道你的某一段程序里可能会出错，这个时候你可以去尝试性(try)的运行以下，如果碰到问题，该怎么做(catch)，这就使异常处理机。

处理机制:
使用异常机制，读、写和调试代码变得清晰。它把处理错误的代码和正常的代码分开。
把错误传递给调用栈
Java异常处理机制采用一个统一和相对简单的抛出和处理错误的机制。如果一个方法本身能引发异常，当所调用的方法出现异常时，调用者可以捕获异常使之得到处理；也可以回避异常，这时异常将在调用的堆栈中向下传递，直到被处理。

 

异常种类简介:
在Java中的异常处理机制也是基于面向对象这个原则来实现的，异常是一个对象,它继承自Throwable类,所有的Throwable类的子孙类所产生的对象都是异常.每当Java程序激发一个异常时，它实际上是激发了一个对象 ，而只有其超类为Throwable类的对象才能被激发。

任何异常类都派生自Throwable类。Throwable分为两个分支：Error和Exception。

 

Error:用于描述运行时系统的内部错误和资源耗尽错误。这种错误发生时，除了通知用户并终止程序外没有别的办法，所以不应该抛出这种类型的错误

 

在Exception中有一个子类RuntimeException，它是程序运行时自动地对某些错误作出反应而产生的。

产生RuntimeException的原因是编程错误，应该修改程序进行改正。如：
错误的造型转换
越界数组访问
空引用访问
被0除

 

产生Exception其它子类错误的原因是正确的程序遇到了意外的情况，必须
进行处理。如：
打开不存在的文件
打开错误的URL
Exception分支是编写程序时处理的重点

常见的异常及用途
Exception 用户程序中可捕获异常体系结构的根类
RuntimeException java.lang包中多数异常的基类
ArithmeticException 算数错误，如除以0
IllegalArgumentException 方法收到非法参数
ArrayIndexOutOfBoundsException  数组下标出界
NullPointerException 试图访问null对象引用(即空的指针，没有被new过)
SecurityException 试图违反安全性
ClassNotFoundException 不能加载请求的类
AWTException AWT中的异常
IOException I/O异常的根类
FileNotFoundException 不能找到文件
EOFException 文件结束
IllegalAccessException 对类的访问被拒绝
NoSuchMethodExcepiton 请求的方法不存在
InterruptedException 线程中断

 

异常处理模型:
由5个关键字来处理,try,catch,finally,throw,throws

Java 中可用于处理异常的两种方式:
--自己处理:可能引发异常的语句封入在 try 块内，而处理异常的相应语句则封入在 catch 块内。

--回避异常:在方法声明中包含 throws 子句，通知潜在调用者，如果发生了异常，必须由调用者处理.

抛出异常:
throw new NullPointerException();
throw new NullPointerException("HERE!");
当方法执行中检测到非正常情况，而在方法内部又处理不了时，所以必须抛（throw）出一个异常。throw后面必须跟Exception这个类及其子类的对象。一旦throw被运行，则
1.一个异常对象建立起来了。
2.当前运行的路径(程序流程)被停止，异常对象被弹出(控制权给异常处理机制)。
3.异常处理机制接管，开始找寻一个合适的地方来继续执行

Catch an exception:
Java的异常机制的好处就在于它使我们在一个地方将精力集中在要解决的问题上，而在令一个地方处理来自那部分代码的异常情况.
Try { //code that may make exception         
//try语句中集中处理要解决的问题
    }
    catch (Type1 id1) {        
    }
    catch (Type1 id2) {
    }
   //把可能出现异常的情况,放在另外的地方来解决 

 

逐级传递异常:
调用栈机制 ：
1.如果方法中的一个语句抛出一个没有在相应的try/catch块中处理的异常，那么这个异常就被抛出到调用方法中。如果异常也没有在调用方法中被处理，它就被抛出到该方法的调用程序。这个过程要一直延续到异常被处理。如果异常到这时还没被处理，它便回到main()，如果main()不处理它，那么该异常就中断程序。

2.异常在传递过程中，一旦遇到相应的catch语句，则被捕获处理并停止传递，所以异常情况可以在适当的位置被处理。

3.异常只有捕获或者传递两种处理方法，二者必居其一。所以能够保证所有的异常都被得到处理

嵌套的 try - catch 块:
1.有时，块的一部分引起一个错误，而整个块可能又引起另一个错误。在此情况下，需要将一个异常处理程序嵌套到另一个中

2.在使用嵌套的try块时，将先执行内部 try 块，如果没有遇到匹配的 catch 块，则将检查外部 try 块的 catch 块
例:
class MultiNest {
 static void procedure() {
  try {
   int[] c = {1};
   c[42]=99;
  } catch(ArrayIndexOutOfBoundsException e) {
   System.out.println("array index oob: " + e);
  }
 }
 
 public static void main(String args[]) {
  try {
   int a = args.length;
   System.out.println("a = " + a);
   procedure();    
   int b = 42/a;
  } catch(ArithmeticException e) {
   System.out.println("div by 0: " + e);
  }
 }
}

使用 throw:
抛出异常使用throw语句，分为三步操作:
1.找到一个合适的异常类
2.创建该类的一个对象
3.抛出该对象(转去执行异常处理程序)

Throwable
//返回该类的构造函数中的字符串
String getMessage();  
//返回该对象的类名
String toString();
//打印在栈区中被跟踪的信息(具体出错的位置)
void printStackTrace();
     //该方法能够输出异常抛出在程程序中的具体位置，因什么原因引起的

finally 块
try语句可以带有finally块，表示不管是否发生异常，也不管发生何种类型的异常，finally块都将运行。确保了在出现异常时所有清除工作都将得到处理

使用 throws
1.如果一个方法可能导致一个异常但不处理它，此时要求在方法声明中包含 throws 子句，通知潜在调用者，如果发生了异常，必须由调用者处理。
2.一个throws子句列举了一个方法可能引发的所有异常类型。
3.这对于除Error或RuntimeException及它们子类以外类型的所有异常是必要的

finally 块
try语句可以带有finally块，表示不管是否发生异常，也不管发生何种类型的异常，finally块都将运行。确保了在出现异常时所有清除工作都将得到处理

 

使用 throws
1.如果一个方法可能导致一个异常但不处理它，此时要求在方法声明中包含 throws 子句，通知潜在调用者，如果发生了异常，必须由调用者处理。
2.一个throws子句列举了一个方法可能引发的所有异常类型。
3.这对于除Error或RuntimeException及它们子类以外类型的所有异常是必要的

 

异常的限制：

1.当你覆盖一个方法时，你只能声明和抛出不比他父类版本中声明的异常多的异常，就是不能比父类抛出的异常多，换言之，覆盖方法的时候，你只能抛出这个方法在基类中的版本所声明的异常

 

2.如果方法是在派生类中定义而不是基类中定义的，那么抛出异常的时候，就没有这个问题。同时这种异常方面的限制对构造函数不起作用。另外，派生类的构造函数不能捕获任何由基类构造函数抛出的异常

 

Java课第八章 类的高级特性 （END）

子类覆盖父类方法的同时，其访问权限必须比父类高

 

访问修饰符,public,protected,private

类成员的高级访问控制

可为类的成员或方法加3种访问修饰符，public ,protected,private

如果没有加任何访问修饰符，则为默认的(包内友好);

public

被public 修饰的类成员为公共性的，可以在任何地方访问此成员

访问权限：最高

 

protected

被protected修饰的类成员可在包中任何地方被访问，并且被在包外的子类访问

访问权限：高

 

默认

如果没被任何访问修饰符修饰的类成员，默认的功能是：只可在包中任何地方被访问，包外则不行

访问权限：中

 

private

被private修饰过的类成员的访问权限最低，只能在类中使用，即{}中，如果想访问此成员必须用一个public 的方法来间接的访问它(setXXX,getXXX)

 

 

类本身的访问控制：

1.类的声明格式

[修饰符]class 类名 [extends 父类] [implements 接口名]

 

类修饰符:

public类，可以被所有的类访问

 

protected类 默认的类，如果没加任何修饰符，则类被默认为protected类,只可在同包中使用，不能被包外的类调用

 

final类  最终类，不能拥有任何子类，即不能被继承

 

abstract类 抽象类，不具体实现任何方法，提供给子类一个或多个接口，子类必须覆盖抽象类的所有方法.

 

封装类:

java有%5的东西是不完全面向对象的，因为有8种基本数据类型,和static变量和方法，为了弥补这些，提供了对应这8种基本数据类型的8种封装类，

boolean    Boolean

short      Short

int        Integer

long       Long

double     Double

float      Float

char       Char

byte       Byte

有些时候需要处理的是对象，而不是一个具体的值，这个时候就需要用到封装类

比如对比2个数的值是否一样，用Object的equals()方法

Integer a=new Integer(5);

Integer b=new Integer(5);

a.equals(b); 

因为要调用equals方法必须得用一个对象，这里就用了a这个为Integer的类，这里也可以写成

a.equals(new Integer(5));

 

数据之间的转换:

有些时候需要用到数据之间的转换，这里需要查阅API帮助文档，下面是一些例子

基本数据类型--->字符串

int a=555;

String aa=String.valueof(a);  

//valueof方法将传入的a转换为了一个字符串再赋给aa

如果将字符串用+号的话 555+111，结果为555111,而不是想要的666，这里就要用到Integer类的一个方法将字符串转为基本数据类型，来进行相加

 

字符串---->基本数据类型

String b=new String("95);

int bb=Integer.parseInt(b);

//这里将b的字符串值转为int型的95,再赋给bb;

 

封装类---->字符串

Integer c=new Integer(11);

String cc=c.toString;  将c的11直接给cc;

 

字符串-->封装类

String PI="3.14159";

Double ppp=Double.valueof(PI);   //将字符串变的值3.14..赋给封装类的对象ppp

double pppp=ppp.doublevalue(); ///再将ppp的对象值返赋给pppp这个基本数据类型

 

内部类：

1.内部类为非静态的嵌套类.

2.在类中定义的类为内部类,即在一个{}中间的声明的类

3.包含内部类的类叫外部类

4.内部类可访问其外部类中的所有成员变量或方法，（包括被private修饰的方法或变量),并能够以和外部类的其他非静态成员相同的方式直接引用它们.

5.如果想访问内布类的成员，必须在外部类创建内部类的对象才可以

6.某外部类的内布类，不能在其他的类中创建对象

 

Java课第八章 类的高级特性 abstract(抽象类) interface(借口)

关键字：abstract,interface,implements

abstract 抽象类:

1.一个类仅仅提供一组子类共有的行为，而不是具体的实现细节。抽象类表示一个概念，从中派生的类代表的对在这一概念的实施。定义抽象类的主要目的是为他的子类定义公共接口。

 

2.java语言中，用abstract关键字来修饰一个类时，这个类叫做抽象类，用abstract关键字来修饰一个方法时，这个方法叫做抽象方法。

例:

abstract class vehicle{

        abstract void move();

        abstract void stop();

}

 

//定义抽象类 vehicle类 有两种行为 move和stop,2种方法也为抽象方法

 

3.抽象类的方法是不完全的，它只有一个声明，没有方法体，所以上面的例子不需要加{}

 

4.从抽象类继承的子类必须覆盖所有的抽象方法，否则它自己会成为一个抽象类

 

5.一个抽象类可以包含非抽象类的方法和变量，但是，一个非抽象类不能包含抽象的方法

//抽象类可以包含非抽象类的方法和变量

例：abstract class vehicle{

      void move(){}

      int speed;

     }

 

//非抽象类不可以包含抽象方法

例:horse extends vehicle{

      void move();         //这是个抽象方法，这里是不能被编译通过的

 }                              //void move(){}  必须加{}才能证明这个方法不是抽象方法

 

6.抽象类是不能被实例化的，即不能创建任何抽象类的对象

 

7.一个抽象类可以不包含抽象方法 譬如上面的例子，void move(){} 是个非抽象方法

 

8.抽象类在java中表示一种继承关系，而继承关系在本质上是"is a"关系。要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的.(子类方法覆盖父类)

 

interface 接口:

*同抽象类一样，实现接口的子类必须覆盖接口的所有方法

1.接口可以理解为一个比abstract类更加抽象的类,它更加纯，它的方法全部是抽象的

 

2.一个接口可以继承多个接口，但只能从接口得到继承

 

3.Java程序一次只能继承一个类但可以实现几个接口。(普通父类与子类继承只允许单线，子类之允许有一个父类，但可以间接继承到父类上面的类，好比现实生活中的，儿子继承父亲，也可以继承到爷爷)

 

4.接口不允许有任何具体的方法，只能使没有方法体的方法

例: interface BreathFire{

     void breathFire();      //不能加任何方法体

}

5.在接口中所有的成员变量都是加过public static final修饰符的，即使没有声明

例：在接口中

int=500相当于  public static final int=500;

 

6.声明在接口中的方法，默认加public 访问修饰符，即使你没有声明

 

7.接口也可以用来定义可被类使用的一组常量

 

8.对于接口来说并不要求接口的实现者和接口定义在概念上本质是一致的，仅仅是实现了 接口定义的契约而已，表示"has a .. ablility",例如在java中，接口常常被命名为....albe(既能做什么),(Runnable,Cloneable,可以跑得，可以克隆的).接口的含义只是为实现者以供一种功能。

 

格式：

//有方法的接口

public interface Myinterface{

       public void add(int x,int y);

                void volume(int x,int y,int z);//这里不加public 和上面是一样，默认加一个public

}

 

//定义有常量的接口

public interface Yourinterface{

       public static final int speed=100;

        double  dollar= 5.5;       //同上，默认加public static final

 

使用接口:

使用关键字:implements来实现接口，好比extends来继承父类一样

 

例: public interface Water{        //洗衣机的放水功能

         void water();

}

 

public class Washer implements{

          void water(){

          System.out.println("洗衣机可以洗衣");

          }

}

 

如果想“实现”多个接口，可以用逗号来隔开接口名

例：public class Nightmare implements CanFire,CanWater,ImmuneEarth

 

抽象类与接口的比较：

语法定义的角度：

1.抽象类中，可以有自己的变量成员，也可以有非抽象的成员方法，而在接口中，只能有静态并且不可修改的成员变量(既加了public static final修饰符的，不过在接口中一般不定义成员变量），并且所有的成员方法都是抽象的。从某种意义上说，接口是一种特殊形式的抽象类.

 

2.一个类只能继承一个父类，但可以“实现”多个接口(可实现多种功能).接口不能继承类，但可以继承多个接口

 

3.在抽象类中，我们可以赋予方法的默认行为（既可以写方法体),而在接口中却不行，方法必须是抽象的，即不能加{}

 

在以下情况下，某个类将成为抽象类:

1.当一个类中的一个方法或多个方法为抽象方法时

2.当该类为一个抽象类的子类，并且没有覆盖所有抽象类的方法时(抽象类的子类必须覆盖所有抽象父类中的所有方法，否则子类自己也被成为抽象类，编译无法通过)

3.当一个类实现(既继承)一个接口，没有覆盖掉所有的接口的方法时,编译将无法通过