JAVA基础

SCJP
1 JAVA 版本：J2SE，J2EE，J2ME
2 JAVA 历史                     命名项目 Green 注册语言 Oak.
               Sun -> James                                  JAVA
不要整天坐在办公室。要出去走走。要跟人交流。
Internet 发展 Java 则写了个 HOTJAVA
95 jdk1.0
98 jdk1.2 j2se j2ee j2me
jsdk
2004 jdk1.5 jdk5.0
jdk6
        Basic language Elements 基本语法 Flow Control 流程控制             Arrays 数组
part1
        Collection 集合（新特性）。面向对象，高级语法：接口。泛型 Generic
part2
        异常 Exceptions 反射与标注            Reflections&Annotation
        GUI 事件（Java GUIs&Event Handle）           I/O 流(Strean I/O and Files)
part3
        多线程(Multi-Threads)          网络应用(java network programming)
环境：
Java 语言：集成环境。Write once,run anywhere 一次编写，到处运行。跨平台性
        多线程，动态更新（向后兼容）。
          健壮，纯面向对象。
JVM：垃圾回收机制，代码安全检查
基础语法：
                     //文件主类。与文件关联。一个源文件只有一个 public 类，但可以
public class Test{
                     //有多个类。
        //入口 main()方法。
           public static void main(String arg[]){
                     System.out.println("Test");
           }
}
cd
vi.vimrc
:set nu vi 中显示行号
         设置间格
:set ts
java -classpath d:\xiegy\corejava\day1 Welcome ： windows 用；
                              是当类中用到其它地方的类时编译
1.java -cp       javac -cp
2.设定环境变量 CLASSPATH。
注意：如果通过 java -cp 的方式指定 CLASSPATH 会忽略变量 CLASSPATH 的值。
Package 关键字        需要创建文件夹
全限定名＝包名＋类名               java cn.day1.Testpackage
javac -d 文件夹 类文件                           指定存放生成的类文件的位置
                            -d <目录>
javac -d classes Hello.java 此时的类文件将自成生成包文件夹
    classes-|
           -|cn
           -|day1
           -|Hello.class
java cn.day1.testpackage
javac -d . testpackage.java    .表示当前目录
import 关键字 导入类文件
import java.lang.*;导入 java lang 下的所有类。但不导入父子包，必须是包下看得见的。
jre->lib->rt.jar
javac 源文件　如果源文件中要使用其他的类，而其它的类不在当前目录。则要通过-cp
选项指定路径。
Java 全限定名　　默认在当前路径下查找该类的字节码文件，如果没有，则要通过-cp
选项指定路径，在指定路径中查找。路径与路径之间 windows 用分号(;) 分割，
Unixt/Linux 用（:）分隔。
注意： 如果通过-cp 的方式指定 CLASSPATH 会忽略变量 CLASSPATH 的值。
在包名当前目录下有源文件将会出错，
Java 的注释
//单行注释。编译器当作看不见
/*    */多行注释
文档注释：
/**
    @param　参数信息
    @return　返回信息
    @author　作者信息
    @version 版本信息
*/
文档生成：
javadoc [选项] [软件包名称] [源文件] [@file]
javadoc -d doc TestComment.java
生成 doc 中文显乱码？
javadoc -d doc -charset utf-8      TestComment.java
jar cvf t.jar -C . p1
用法: jar [vfm0Me] [jar-file] [manifest-file] [entry-point] [-C dir] files ...
选项包括：
       创建新的归档文件
   -c
       列出归档目录
   -t
       解压缩已归档的指定（或所有）文件
   -x
       更新现有的归档文件
   -u
       在标准输出中生成详细输出
   -v
       指定归档文件名
   -f
       包含指定清单文件中的清单信息
   -m
       为捆绑到可执行 jar 文件的独立应用程序
   -e
       指定应用程序入口点
       仅存储；不使用任何 ZIP 压缩
   -0
       不创建条目的清单文件
   -M
       为指定的 jar 文件生成索引信息
   -i
       更改为指定的目录并包含其中的文件
   -C
如果有任何目录文件，则对其进行递归处理。
清单文件名、归档文件名和入口点名的指定顺序
与 "m"、"f" 和 "e" 标志的指定顺序相同。
示例 1：将两个类文件归档到一个名为 classes.jar 的归档文件中：
      jar cvf classes.jar Foo.class Bar.class
示例 2：使用现有的清单文件 "mymanifest" 并
          将 foo/ 目录中的所有文件归档到 "classes.jar" 中：
      jar cvfm classes.jar mymanifest -C foo/ .
jar cvfm t.jar MANIFEST.MF p1
MANIFEST.MF 中添加：Main-Class: p1.p2.p3.testJar                                   :后要空格 完成后要回车
也可用命令：jar cvfe t.jar p1.p2.p3.TestMethod p1
jar cvf jar 包名.jar 第一层包名
jar cvfe jar 包名.jar main 方法所在类的全限定名 第一层包名
java.lang
java.awt/javax.swing
java.io
java.net
标识符由：字母，数字，_$组成 第一个字符必须是字母
命名习惯：1.包名小写
                2.类名：每个单词的首字符大写
                3.变量：首字符小写，后面每个单词的首字符大写
                4.方法名：首字符小写后面每个单词的首字符大写。
                5.常量：每个字母都大写。
                6.要望文生义
native 本地方法，本地变量。 goto 跳转，不要用。strictfp　java 虚拟机用，原子值
const C++中表常量，不在 java 中启作用。
true false null 不是保留关键字，是值，
JAVA 类型 8 大基本类型：数字类型 1B 8 bits
                             整型 ：byte(1B) short(2B) int(4B) long(8B)
                             浮点型:float(4B) double(8B)
                      字符类型 char(2B)
                     布尔类型 boolean(1bit)
             引用类型：String
JAVA 有严格的类型
  1.局部变量的作用范围在定义它的代码块中
  2.在同一个代码块中，不能定义相同的局部变量。
  3.局部变量要先初始值后使用。
符号位
0正            －128～127 byte
1负
b1=(byte)s1;//error 可能损失精度()进行强制类型转换，不能随便强制类型转换。
数值运算符，逻辑运算符。注意精度的影响。
类型自动提升 byte->short->int->long->float->doulbe
b1+=20;//不会做类型的自动提升,隐式做了类型的强制转换，b1=30,会有精度的损失
/=;-= ;%=;.....都会如此！
instanceof
        恒等，不等
== !=
＞＞有符号右移              前补符号位    相当于除于 2，不能超过 32 位。移 32 位相当于没动！
＜＜有符号左移
＞＞＞ 无符号右移，前面补 0              正数移后还是正数，负数移后变正数且很大。
& | ^ ~ 位运算符。与（有 0 则 0），或（有 1 则 1），异或（异为 1 同为 0 和普通加法一
样），取反             补码（取反＋1）；
逻辑运算符 && 会有短路操作，前面条件满足，后面就不会执行到。AND
               || OR
             &取地址符
             | 单步运算符。
逻辑表达式?value1 : value2       相当于 if else;
前＋＋ 后 ＋＋
流程控制：
if(){}
if(){} else{]
                        else{} 条件必须为 true;
if(){}    else if(){}
switch(var){//里面的类型只能 byte,short,char,int
           case var1:break;
           case var2:break;
           case var3:break;
           default:
}
循环：while loop 先判断后执行
           while(){
           }
           先执行后判断
           do{
           }while(){
           }
Break 跳出循环           Continue 跳出本次循环，继续执行
for(表达式 1；表达式 2：表达 3){
           语句 1；
           语名 2：
}
java.lang.Math
Math.random 方法 返回一个 double 类型。
        向下取整
floor
       向上取整个
ceil
sqrt 开方
java.util.Random
数组：An array is a object
      数组有个 length 值。
遍历：访问每一个元素。可通过 length 属性进行 for 循环
                                                                  这是显示初始化
char[] c = new char[];//不能指定数组空间大小
隐式初始化 char:'\n0000' int:0 double/float:0.0 boolean:false;
1.声明：
           a.char[] c = new char[6];
           b.char[] is = new int[];
           c.float[] fs = ;
2.访问：
           通过下标进行访问。第一个元素的下标是 0，最后一个元素的下标是数组的长
度减 1；
           c[0]='a';
           char cc = c[0];
3.数组是一个对象，有一个属性 length 表示数组的大小。
4.数组的遍历：
           for(int i=0;i<c.length;i++){
                      System.out.println(c[i]);
           }
数组的大小一经确定，不能改变。
要进行扩容操作
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
                      src： 源数组
                      srcPos： 从源数组哪个位置开始拷贝(位置指的是元素的下标)
                      dest： 目标数组
                      destPos： 拷贝的元素放到目标数组的起始位置
                      length： 拷贝多少个


二维数组：              申明：
                   char[][] cs1 = new char[2][];//OK
           //      char[][] cs2 = new char[][2];//Error,必须要指定一维的大小。
                   int[][] is2 = new int[][],};//非对称矩阵
                   int[][] is3 = ,};
                   遍历：
                   for(int i=0;i<is.length;i++){
                              int[] a = is[i];
                              for(int j=0;j<a.length;j++){
                                         System.out.print(a[j]+" ");
                              }
排序：冒泡排序。
Java.util.Arrays  sort();
           二分搜索：int binarySearch(int[] array,int num);
           copyof
           fill 填满；
面向对象：
           面向过程：功能
           缺点：代码难以维护
           先有算法，再有数据结构
           面向对象：数据
           1.代码维护性好。
           2.符合人的思维习惯。
         先有数据结构，后有算法
类：具有相同功能或相同特性的一类事件的抽象。
对象：类的一个实例
方法重载（overload)：方法名相同，参数列表不同。
方法重载：参数向上兼容
            byte->short->int->long->float->double;
            参数不能出现二义性
方法的参数传递规则：
基本类型传值；对象类型 传引用！拷贝
值传递
引用类型         对象类型 默认为 null
对象的产生：
            1.分配空间
            2.初始化属性
            3.调用构造方法
构造方法：每一个类都有一个默认的无参构造方法，但用户自己添加了构造方法后将不会
有默认的无参构造方法.
在一个类中局部变量与实例变量同名时,局部变量是优先使用的.
this 关键字代表当前对象.区分实例变量与局部变量.
this 的用法:this 代表当前对象
作用:1.可以用 this 区分实例变量和局部变量.
              通过 this 可以在一个构造方法中,调用另外一个构造方法,但必须是该构造方
     2.this
法的第一条语句.!
UML 统一建模语言
private -
default 不写
protected #
public +
依懒:uses-a 类作为参数传递给一个方法,该方法使用类的方法.或者是调用类静态方法或者
是调用其属性.如下例,MatchMaker 依懒 Boy 和 Girl. ----------->
class Boy{
            public void introduce{}
}
class Girl{
            public ovid introduce(){}
}
class MatchMaker{
            public void appointment(Boy boy,Girl girl){
                      boy.introduce();
                      girl.introduce();
          }
}
关联:比依懒强,          has-a
                            Dirver Car 一个类是另外一个类的属性,单向关联
          a.聚合      is-a
                    关系更强.整体与局部的关系
          b.组合
class Driver{
          String name;
          Car car;
}
class Car{
          String color;
          String maker;
}
双向关联:
继承:
封装：如何写好一个类
1.如何定义一个类
2.怎样定义属性方法
3.方法重载（overload)
4.构造方法
5.this 的使用
6.数据的隐藏。方法公开，属性隐藏
继承：java 不允许多重继承！                         构造方法不可继承
          1.extends
          2.共性写在父类中，子类写个性。
          3.super 的使用
             a.在子类的构造方法中调用父类的构造方法；要放在第一个语句。
super(var1,var2);
             b.在子类的方法中调用父类被覆盖的方法 super.eat();
          4.方法的覆盖（Override）
          修饰符相同，或更宽
          返回类型相同或 父类返回类型的子类。
          方法名相同，参数列表相同
          抛出的异常：不能抛出比父类更多的异常
构造顺序：先构造父类对象，再构造子类对象。
多态：
          1.父类的引用可以指向子类的对象。
          2.通过父类的引用调用父类的被覆盖的方法。是调用子类覆盖类父类的方法
          3.通过父类的引用，不能调用子类特有的方法。
          4.父类对象要给子类的引用赋值要强制类型 转换。
             是不是
instanceof
继承会导致过分封装，系统复杂度高，维护困难！
多态：
            用一个父类的引用指向一个子类的对象
            Animal Dog
            Dog d = new Dog(); //dog is a dog
            Animal a = new Dog();//dog is a animal
            编译期类型         运行期类型
a.eat();a.sleep();
a.watchHome();//无。不能调用。
方法的参数，方法的返回类型 都会表现多态。属性没有多态
完全封装：如 javabean          所有的属性都是 private，并提供 set get 方法
Object 是所有类的父类。
1.分配所有父子类的空间
2.初始代所有父子类的属性
（byte short int long =0 char='\u0000'                        引用类型为：null)
                                          float double = 0.0
3.显示初始化属性
4.调用构造方法
            递归的调用构造方法
例 1.分配所有父子类的空间
    2.初始化所有父子类的属性
    3.初始化 Dog 的属性
         4.初始化 Animal 的属性，
            5.初始化 Object 的属性（如果有）
         6.调用 Object 的构造方法
      7.调用 Animal 的构造方法
    8.调用 Dog 的构造方法
当依懒情况复杂时，这会导致 new 一个对象会有困难。这就要使用单例模式（设计模式
中的一种）
单例设计模式：
            一个类只允许有一个对象，保证所有引用的对象都是同一个对象。
            因为只允许存在一个对象，则不允许在外面直接 new 出新的对象，所以应该把
构造器设为 private，。
     在类内定义一个公开的静态方法，让使用者进行调用，通过该方法去获得一个
实例。
     例：
          public calss Singleton{
                    private static Singleton s;
                    private Singleton(){}
                    public static Singleton newInstance(){
                              if ( s == null)
                                        s = new Singleton();
                              return s;
                    }
          }
属性不表现多态，而表现遮盖！
观察者模式
有抽象方法的类一定是抽象类。Abstract
抽象类不一定有抽象方法,其中的方法是参考实现
重载发生在编译期。覆盖发生在运行期。
public class TestFinal{
                    public static void main(String[] args){
                              ClassA a;
                              a = new B();
                              System.out.println(a instanceof ClassA );//true a 是一
个抽象父类的对象，但不能直接用 new 来创建抽象类对象。因为自动向上转型
                    }
}
abstract class ClassA｛
          public void m(){
                    }
}
class B extends ClassA{
}
abstract 修饰类使其成为抽象类，修饰方法使其成为抽象方法。
final 可修饰一个局部变量，使其成为一局部常量。
          可修饰一个实例变量。但实例变量必须显示初始化。
          final 修饰方法，该方法不能被覆盖！维护方法的稳定性
          final 修饰一个类，该类不能被继承。
static 修饰一个实例变量使其成为类变量。只有一份
          静态方法中不能调用非静态的属性和方法
          静态方法可以覆盖，但没有多态！静态方法只能被静态方法覆盖。非静态方法
          不能被静态方法覆盖。
          修饰静态代码块，用来初始化，读取一些配置信息
这三个修饰不能修饰构造方法
老师总结：
          abstract:方法，类
          final:变量(实例变量，局部变量），方法
          static:实例变量，方法，代码块，类。
          类加载：把字节码文件读入 JVM 中的过程；类加载只被加载一次，加载时会执
          行静态代码块。
          类加载的时机：原则是能不加载就不加载！
                    1.声明一个类的引用时，不会类加载！
                    2.产生该类的对象的时候，会加载该类。
                    3.调用一个类的静态方法时也会加载类
                    4.加载子类必先加载父类。
                    5.通过子类调用父类的静态方法。只加载父类
                    6.当子类中的静态实例变量需要迟绑定时，也要加载父类。（JDK5.0
不用）
                    7.Class.forName(“ 类的全限定名”)显示加载类字节码
单例模式：
class ClassA{
          //饿汉式 小对象
                    private static final ClassA a = new ClassA();
                    private ClassA(){
                    }
                    public static ClassA getInstance(){
                               return a;
                    }
}
//懒汉式 大对象
class ClassB{
          private static ClassB b;
                    private ClassB(){
                    }
                    public static synchronized ClassB getInstance(){//会有线程安全
//问题
                               if(b == null){
                                         b = new ClassB();
                               }
                               return b;
                    }
}
interface 接口
                    接口中的属性默认为必须的公开的静态的常量。所有方法为公开的
抽象方法
实现类与接口之间是父子关系。
impl instanceof IA//有没有实现该接口
接口无构造方法           接口可以多继承
在该接口中找方法，没有则在父接口中找。如果在所有父接口没有找到该方法。在 Object
中找是否有该方法，如果没有，则抛出 NoSuchMethodError.
因为调用接口中的方法，其实是调用实现接口类中的方法。而所有的类都是 Object 的子
类。
1.使用接口解决了 JAVA 中多重继承的问题。
2.解耦合
java.text.SimpleDataFormat
SimpleDateFormat format = new SimpleDateFormat("yyyyy-MM-dd HH:mm:ss");
                              String time = format.format(visitTime);
Java.util.Calendar 日历类。
DMS 任务一不用设环境变量编译运行
[asd08112@localhost DMS]$ javac -cp ./lib/generator-data4dms.jar:.
DataCollector.java
[asd08112@localhost DMS]$ java -cp .:./lib/generator-data4dms.jar DataCollector
javac *.java 编译文件下的所有.java 文件
接口回调
public class TestCallback{
                    public static void main(String[] args){
                              //RedGlass g = new RedGlass();
                              Lamp lamp = new Lamp();
                              Glass g=new RedGlass();
                              lamp.g = g;//如果没有传值进去，会抛空指值异常
java.lang.NullPointerException
                              lamp.powerOn(); //默认为发白光
                    }
}
interface Glass{
                    void lightOn();
}
//progrmamer other
class Lamp{
//                  RedGlass g;
                    Glass g = new WhiteGlass();//使用接口。
                    public void powerOn(){
                              g.lightOn();
                    }
}
//programmer A
class WhiteGlass implements Glass{
                    public void lightOn(){
                              System.out.println("白灯泡发白光");
                    }
}
class RedGlass implements Glass{
                    public void lightOn(){
                              System.out.println("红灯泡发红光");
                    }
}
class BlueGlass implements Glass{
                    public void lightOn(){
                              System.out.println("蓝灯泡发蓝光");
                    }
}
访问权限：
private: 外部都不能访问
default:包访问权限 当 class 不加 public 时，为默认包访问权限。则这个类在包外部不能
被导入使用。因此一个类最好以一个.java 文件，类为 public.
protected:子类可访问权限(凡子类可访问)。当前同一包可访问。
public:公共访问权限
类只能被 public 修饰或默认。修饰符不能修饰局部变量
Object 类。getClass()获得运行期的类
          toString() 要按用户打印则常 常 要覆盖这个方法。
          clone()
clone()利用：类不可改变。
                    1.private 属性；
                    2.在构造方法中给属性赋值
                    （如果属性是引用类型 ，则要克隆一份后再赋值）
                    3.只提供 get 方法
                    （如果返回的是引用类型 ，则要克隆一份后再返回）
finalize()释放资源 //在垃圾回收器回收该对象的时候 自动被 调用
System.gc();//建议垃圾回收器回收垃圾对象
一般自己写释放资源的方法，主动调用访方法释放连接和资源。
针对接口编程时，完全利用接口的标准。
equals();根据需求重写 equals（）方法。简化后面的工作。
                       父类的属性都　不满足子类也将不会。因此子类中要覆盖父类的
equals 方法。必须调用除父类中的 equals 方法（Object 的 equals()方法除外的）
                       public boolean equals(Object obj){
                                  if(obj == null) return false;
                                  if(obj == this) return true;
                       //         if(!(obj instanceof Super)) return false;
                                  if(this.getClass() != obj.getClass()) return false;//更
                                                                               //安全
                                  Super s = (Super)obj;
                                  if(s.a != this.a) return false;
                                  return true；
                       }
优先使用 getClass(),有父子类情况时用 instanceof
         是不变对象。会产生大量中间对象。
String
           public String substring(int beginIndex)
           public String substring(int beginIndex,int endIndex)不包括 beginIndex.
           public String trim()返回字符串的副本，忽略前导空白和尾部空白。
           public char charAt(int index)返回指定索引处的 char 值。索引范围为从 0
到 length() - 1。序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类
推，这类似于数组索引。
StringBuffer 线程安全的可变字符序列。
           public StringBuffer append(long lng)
池
public class Pool{
           private String name;
           private Pool[] poo1 = new Pool[100];
           private int index;
           public Pool(String name){
                    this.name   =name;
          }
          public Pool getInstance(String name){
                    for(int i=0;i<index,i++{
                              Pool ca = new Pool[i];
                              if(ca[i].name.equals(name)){
                                         return ca;
                              }
                    }
                    Pool ca = new Pool(name);
                    pool[index++]=ca;
                    return ca;
          }
}
JDK5.0 新特性：
4 小点。
1.变长参数
2.静态导入
3.自动封箱，自动拆箱
4.格式化输出
5.for-each
四大点
1.枚举
2.泛型
3.标注
4.对多线程的支持。
时间操作：
                              long time = System.currentTimeMillis();
                              Date date = new Date(time);
                              System.out.println(date);
                              SimpleDateFormat sf = new SimpleDateFormat("yyyy MM
dd");
                              String s = sf.format(date);
                              System.out.println(s);
                              Calendar c = Calendar.getInstance();
                          System.out.println(c.get(Calendar.DAY_OF_MONTH));
                          System.out.println(c.get(Calendar.DAY_OF_WEEK));
     System.out.println(c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
                          System.out.println(c.get(Calendar.DAY_OF_YEAR));
变长参数：不能同时声明数组参数和变长参数。
     一个方法的可变参数必须放在最后一个参数。且只有一个！