jAVA基础

JAVA的数组

声明: type var-name[];   var-name = new type[size];
      type[ ] var-name;  var-name = new type[size];
int month_days[] = new int[4];
int month_days[] = { 31, 28, 31, 30};
int twoD[][] = new int[4][];
twoD[0] = new int[5];
...
数组的声明需要使用new为其分配内存地址并把它赋值给数组变量名,使其成为实际的, 物理上存在的数组.

break/continue

代码块可以拥有名称
break lable;  可以结束任何代码块
标签label是标识代码块的标签。当这种形式的break执行时，控制被传递出指定的代码块。被加标签的代码块必须包围break语句，但是它不需要是直接的包围break的块代码块的名称实例: first: {} ,  outer: for(int i=0; i<3; i++) {}
​
非法的使用break
class BreakErr {
public static void main(String args[]) {
one: for(int i=0; i<3; i++) {
System.out.print("Pass " + i + ": ");
}
for(int j=0; j<100; j++) {
if(j == 10) break one; // WRONG
System.out.print(j + " ");
}
}
}

java的变量声明, 一定指明类型

类

声明类的实例时, 需要用 new 来创建类的实际物理拷贝

类的构造函数与类名相同, 可重载

定义在类中的变量被称为实例变量，这是因为类中的每个实例(也就是类的每个对象)都包含它自己对这些变量的拷贝。这样，一个对象的数据是独立的且是惟一的

static 用来显示的设置类属性和方法. 可以直接被类名访问,在实例化时不会被复制

一个变量可以声明为final，这样做的目的是阻止它的内容被修改。这意味着在声明final变量的时候，你必须初始化它（在这种用法上，final类似于C/C++中的const）. final 变量名称大写

java访问修饰符, 限制属性, 方法的可访问范围

修饰符	同一个类	同一个包	子类	全局
Private	能	否	否	否
Default	能	能	否	否
Protected	能	能	能	否
Public	能	能	能	能

Private 类型只能在声明的类中访问
Protected 类型不能在其它的包下面被访问
Public 类型全局能访问

final修饰符 
final的意思是不可变，他可以修饰类、字段、方法。修饰类后类不能被扩展（extends），也就是不能被继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写。
​
abstract修饰符 
abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写（override）。实例化一个抽象类是不可能的,但创建一个抽象类的引用是可行的
​
static修饰符 
static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例。
​
volatile修饰符
transient修饰符

嵌套类

在另一个类中定义的类就是嵌套类(nested classes).嵌套类的范围有装入它的类的范围限制. 如果类B被定义在类A之内, 那么B为A所知(能实例和调用), 然而不被A的外面所知. 嵌套类可以访问嵌套它的类的成员, 包括private成员, 但包围类不可以访问嵌套类的成员(与方法的作用域同).
嵌套类可在很多地方声明, 包括for 循环里

命令行参数

有时你想在运行程序时将信息传递到一个程序中。这通过将命令行参数（command-line arguments）传递给main()来实现。命令行参数是程序执行时在命令行中紧跟在程序名后的信息。在Java程序中访问命令行参数是相当容易的——它们作为字符串存储在传递给main()的String数组中
java demo this is a arguments test 100 -1

类继承

关键字声明: extends
每个子类只能继承一个超类, 构造函数以派生的次序调用，从超类到子类
变量的类型决定了它什么成员可以访问, 而不是它指向的对象决定
super关键字: super(parameter-list), 参数类型与数量决定了什么构造函数被调用.

超类的引用变量可以引用子类对象。Java用这一事实来解决在运行期间对重载方法的调用。过程如下：当一个重载方法通过超类引用被调用，Java根据当前被引用对象的类型来决定执行哪个版本的方法。如果引用的对象类型不同，就会调用一个重载方法的不同版本。换句话说，是被引用对象的类型（而不是引用变量的类型）决定执行哪个版本的重载方法。因此，如果超类包含一个被子类重载的方法，那么当通过超类引用变量引用不同对象类型时，就会执行该方法的不同版本,但只能访问超类定义过的属性和方法.

一:
BoxWeight(BoxWeight ob) { 
    // pass object to constructor
    super(ob);
    weight = ob.weight;
}
注意super( )被用一个BoxWeight类型而不是Box类型的对象调用。这仍然调用了构造函数Box(Box ob)。前面已经提醒过，一个超类变量可以引用作为任何一个从它派生的对象。因此，我们可以传递一个BoxWeight对象给Box构造函数。当然，Box只知道它自己成员的信息。
二:
    super.member来初始化属性. member既可以是1个方法也可以是1个实例变量。
Super的第2种形式多数是用于超类成员名被子类中同样的成员名隐藏的情况

接口(interface)

定义: 
access interface name {
    return-type method-name1(parameter-list);
    return-type method-name2(parameter-list);
    type final-varname1 = value;
    type final-varname2 = value;
    // ...
    return-type method-nameN(parameter-list);
    type final-varnameN = value;
}   
实现: 
access class classname [extends superclass]
    [implements interface [,interface...]] {
    // class-body
} 如果一个类包含一个接口但是不完全实现接口定义的方法，那么该类必须定义成abstract型。

 

异常捕获

try{} catch{} finally{}
​
throw
​
throws: 当前方法可能会抛出异常，但是不知道如何处理该异常，就将该异常交由调用这个方法的的上一级使用者处理，如果main方法也不知道如何处理这个异常的时候，就会交由JVM来处理这个异常，JVM的做法是：打印异常的跟踪栈消息，并终止程序。

 

线程 (Thread)

Thread类的方法

方法	意义
getName	获得线程名称
getPriority	获得线程优先级
jsAlive	判定线程是否仍在运行
join	等待一个线程终止
run	线程的入口点
sleep	在一段时间内挂起线程
start	通过调用运行方法来启动线程
currentThread	获取当前线程

 

线程的优先级是用来决定何时从一个运行的线程切换到另一个: “上下文转换”(context switch)
· 线程可以自动放弃控制。在I/O未决定的情况下，睡眠或阻塞由明确的让步来完成。在这种假定下，所有其他的线程被检测，准备运行的最高优先级线程被授予CPU。
· 线程可以被高优先级的线程抢占。在这种情况下，低优先级线程不主动放弃，处理器只是被先占——无论它正在干什么——处理器被高优先级的线程占据。基本上，
一旦高优先级线程要运行，它就执行。这叫做有优先权的多任务处理

线程的实现

· 实现 Runnable 接口。
· 可以继承Thread类。
​
Runnable 接口: 在定义的类中实现 public viod run() 方法, 在类内部实例化一个Thread类的对象. Thread 类定义了好几种构造函数。我们会用到的如下： Thread(Runnable threadOb, String threadName) ->
class NewThread implements Runnable {
Thread t;
​
NewThread() {
    // Create a new, second thread
    t = new Thread(this, "Demo Thread");
    t.start(); // Start the thread
}
public void run(){}
}
继承Thread类: 创建一个新类来扩展Thread类，然后创建该类的实例。当一
个类继承Thread时，它必须重载run()方法，这个run()方法是新线程的入口。它也必须调用start()方法去启动新线程执行
NewThread() {
    // Create a new, second thread
    super("Demo Thread");
    start(); // Start the thread
}