坦克书房

开始画面叫SplashScreen，在1.6里面有很大的加强。经过各种研究，终于弄明了了它的用法。我现在变得不废话了，以下是代码，如果有用，但又看不懂的朋友可以给我留言。

 



继承Runnable，就可以使用多线程，这样，就可以真正和程序交互了。在程序开始时出现Splash，等载入完必，Splash被停止。

Splash中用了Java2D的API，感觉很亲切，和OpenGL像极了。

 

在界面中，有时候会用到一种带超链接的标签，只要用户鼠标一点，就能打在外部用浏览器打开一个网页，或打开默认的邮件客户端，给特定地址发信。

而Swing中没有提供这种控件（Swing太灵活了，其实没有必要提供那么多控件，没有提供，意味着更加自由。当然自己写，也是种快乐。）

注意，本方法只能在Java1.6里面用，以防虚拟机不支持，故在一些地方做了检测。 

以下是LinkLabel类：

 

最近做了个Oracle+Java的项目，GUI用Swing做的，SWT我看不到前途，Swing和Java本身一样优雅。故有些实用的代码。

窗口居中

这个是用于JFrame居中的，当然可以用同样的方法，实现JWindow等的居中。不了小组其它成员用着方便，我写成了一个类，貌似有些Functor的意思（一个设计模式）。其实只要达到目的就行了。废话少说，以下是代码：

 

 

Java复习

重点：
>> 所有Java关键字都是小写的，TURE、FALSE、NULL等都不是Java关键字
>> Java字符采用Unicode编码，每个字符占两个字节
>> Java浮点类型常量有两种表示形式    3.14 314.0 .314 或3.14e2 3.14E2 314E2
>> Java浮点型常量默认为double型
>> 引用类型变量的值是某个对象的句柄，而不是对象本身
>> 声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个具体的对象
>> Java也不能完全防止if(bool i = true){//...}错误的产生；但是Java可以解决这样的问题if(Int = 3){//...}因为Java的if里只能接收boolean
>> 在switch语句里别忘了break和default，switch只能接收byte short char int
>> Java的三类循环语句for/ while/ do while
>> 在数组中不能进行类型提升
         int [ ] a;
         int [ ] b = new int [4];
         char [ ] c = new char [5];
         a = b;
         a = c；//ERROR
>> 数组的初始化有两种方式：动态和静态
>> 每个数组都有一个属性length指明它的长度
>>
         int[][] tt = new int[4][];
         tt[0] = new int[2];
         tt[1] = new int[4];
         tt[2] = new int[6];
         tt[3] = new int[8];

>> int intArray[][] = {{1,2},{2,3},{3,4,5}};
   int intArray1[3][2] = {{1,2},{2,3},{4,5}};  //illegal
>> 当复制大量数据时，使用System.arraycopy()命令, 优化JAVA程序开发，提高JAVA性能
----> arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

>>
重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型
重写方法不能使用比被重写方法更严格的访问权限
public class Parent {
 public void method1() {}
}
public class Child extends Parent {
 private void method1() {}  //illegal
}

>>
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造方法中调用父类的构造方法
super的追溯不仅于直接父类

>>
// student.java:
class Person{
 ...
}
class Student extends Person {
 ...
 public static void main (String args[]){
  Person p = new Person ("Liming",50);
  Student s = new Student ("Wangqiang",20,"PKU");
  Person p2 = new Student ("Zhangyi",18,"dlut");
  Student s2 = (Student) p2;
 }
}

>>
一个对象只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象
  Person p = new Student();
  Object o = new Person();
  o = new Student();
>>声明是父类型的，但指向子类型，那么子类型的一些域就不可以使用
 Student m = new Student();
 m.school = "dlut";    //合法
 Person e = new Student();
 e.school = "dlut";    //非法
>> 虚拟方法调用(多态情况下)
class TestVirtualInvoke{
 
 static void doStuff(Shape s){
  s.draw();
 }
 
 public static void main (String[]args){
  Circle c = new Circle();
  Triangle t = new Triangle();
  Line l = new Line ();
  doStuff(c);
  doStuff(t);
  doStuff(l); 
 }
}
class Shape {
 void draw (){ System.out.println("Shape drawing."); }
}
class Circle extends Shape {
 void draw (){ System.out.println("Draw Circle."); }
}
class Triangle extends Shape {
 void draw (){ System.out.println("Draw Triangle."); }
}
class Line extends Shape {
 void draw (){ System.out.println("Draw Line."); }
}

>> 对象数据类型的转型
损失为“精度”—— “数据域”（属性和方法）

>>
  同类收集( homogenous collections)

 MyDate[] m = new MyDate[2];
 m[0] = new MyDate(22, 12, 1964);
 m[1] = new MyDate(22, 7, 1964);

  异类收集(heterogeneous collections)

 Person [] p= new Person[3];
 p[0] = new Student();
 p[1] = new Person();
 p[2] = new Graduate();

>> 继承的诡计
public class TestHeritate{
 public static void main (String[] args){
  Base b = new Subclass();
  System.out.println(b.x);
  System.out.println(b.method());
 } }

class Base{
 int x = 2;
 int method(){ return x; }
}

class Subclass extends Base{
 int x = 3;
 int method (){ return x ; }
}
// 结果是
2
3

访问一个引用型的变量的非静态方法，运行时与实际引用的对象的方法绑定。
访问一个引用型的变量的成员变量（包括静态变量和实例变量），运行时与声明的类的成员变量绑定。
访问一个引用型的变量的静态方法，运行时与声明的类的方法绑定。

>> instanceof 关键字 确定对象类型
class InstanceOf {
 public static void main (String[] args){
  Object [] things = new Object [3];
  things [0] = new Integer (4);
  things [1] = new Double (3.14);
  things [2] = new Double (2.09);
  double s = 0;
  
  for (int i=0; i< things.length; i++){
   if (things[i] instanceof Integer)
     s += ((Integer)things[i]).intValue();
   else if (things[i] instanceof Double)
     s += ((Double)things[i]).doubleValue();
  } 
  System.out.println("sum="+s);
 }
}
>> 对Java对象的强制类型转换称为造型
在造型前可以使用instanceof操作符测试一个对象的类型
从子类到父类的类型转换可以自动进行
Object o = new Child();
从父类到子类的类型转换必须通过造型(强制类型转换)实现
Child child;
Parent parent = new Parent();
child = (Child)parent;

无继承关系的引用类型间的转换是非法的
如两个数组间的转换,如从int[]到char[]

>>
this(argument_list) 可以调用父类的构造方法
super(argument_list)语句调用父类的构造方法

>> super的使用有三种情况：
用来访问父类被隐藏的成员变量，如：super.variable
用来调用父类中被重写的方法，如：super.Method ( [paramlist] )；
用来调用父类的构造函数，如：super( [paramlist] )；
>> this的使用也有三种情况，类似

>> 在子类构造函数中，调用了父类的构造函数，而在父类的构造函数中调用了一个被子类覆盖的方法，此时，这个方法会被子类覆盖。发生错误
所以设计构造函数的时候要尽可能地简洁。
>> static块通常用于初始化static (类)属性
class Person {
 public static int total;
 static {
         total = 100;//为total赋初值
 }
 …… //其它属性或方法声明
 }

>> 用static来实现Singleton
 class Single{
   private static Single onlyone = new Single();
   private String name;
  public static Single getSingle() {
    return onlyone;
   }
   private Single() {}
   }

public class TestSingle{
 public static void main(String args[]) {    Single  s1 = Single.getSingle();
    Single  s2 = Single.getSingle();
     if (s1==s2){
   System.out.println("s1 is equals to s2!");
  }
     }
}

>>
final标记的类不能被继承。
final标记的方法不能被子类重写。
final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。

>>
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。否则不能被实例化。
抽象方法只需声明，不需实现。
abstract 返回类型 函数名(参数列表)

>> abstract方法必须位于abstract类中

>> public class A{
        private int s = 111;
        public class B {
 private int s = 222;
 public void mb(int s) {
         System.out.println(s); // 局部变量s
         System.out.println(this.s); // 内部类对象的属性s
         System.out.println(A.this.s); //  外层类对象属性s
 }
       }
       public static void main(String args[]){
 A a = new A();
 A.B b = a.new B();
 b.mb(333);
        }
}

>> java.Math
Math.floor //不大于参数的最大整数
Math.ceil //  不小于参数的最小整数

>> finally
不论在try代码块中是否发生了异常事件，finally块中的语句都会被执行。

>>
equals比较“引用”是否相等
实现为
public boolean equals(Object o) { return this==o; }
改写后为比较“内容”。改写的有File、Date、String、包装类（wrapper）
comparable为比较“大小”
实现为
public interface Comparable {  public int compareTo(Object o); }

>> Object类的hashCode方法实现是将对象内存地址转换成一个整数，所以，不同对象的散列值不同。
不同的对象应该提供不同的散列值。

>> 每个基本数据类型都对应一个包装类。
如 char 有Character包装类

>> 数学运算全部都是静态方法
故使用时可以这样做
Math.abs(XX)

>> Java GUI
1、提供了一些容器组件，用来容纳其他的组件
2、用布局管理器来管理组件在容器上的布局
3、利用监听接口或适配器来响应各种事件，实现界面与用户的交互。
4、提供了一套绘图机制，来自动维护或刷新图形界面。

//------------------------------------------------------------

java.lang.Object
   |
   +----java.awt.Component
           |
           +----java.awt.Container
                   |
                   +----java.awt.Window
                           |
                           +----java.awt.Frame

//-------------------------------------------------------------

//-------------------------------------------------------------

java.lang.Object
   |
   +----java.awt.Component
           |
           +----java.awt.Container
                   |
                   +----java.awt.Panel

//-------------------------------------------------------------

>> 布局管理器
BorderLayout、FlowLayou