JAVA核心技术

1.一维数组的声明方式 type var[]或type[] var 如：int a[]，java语言中声明数组不能指定其长度

2.　动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行

　　静态初始化：在定义数组的同时就为元素分配空间并赋值

3.创建元素为引用数据类型的数组：数组存放在栈区，数组指向的对象存放在堆区

　　Java的堆是一个运行时数 据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码 来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

　　栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（int, short, long, byte, float, double, boolean, char）和对象句柄。 栈有一个很重要的特殊性，就是存在栈中的数据可以共享。

4.构造函数应包含哪些内容：

　　构造函数多半定义一些初值或内存配置的工作；一个类可以有多个构造函数（重载），根据参数的不同决定执行哪一个；如果程序中没有定义构造函数，则创造实例时使用的是缺省函数。

class A{ 
static{ 
System.out.println("Static A"); 
} 
A(){ 
System.out.println("A()"); 
} 
} 
class B extends A{ 
C c = new C(); 
static{ 
System.out.println("Static B"); 
} 
B(){ 
System.out.println("B()"); 
} 
public static void main(String[] args){ 
new B(); 
} 
} 
class C{ 
C(){ 
System.out.println("c()"); 
} 
} 

 结果：

    Static A         
    Static B
    A()     
    c()     
    B()

5.static语句块仅在其所属的类被载入时执行一次，static块通常用于初始化static类属性

6.final标记的类不能被继承；final标记的方法不能被子类重写；final标记的变量即成为常量；final标记的成员变量必须在声明的同时或在每个构造方法中显示赋值，然后才能使用。

 7.执行顺序：父类的构造函数，子类的成员变量实例变量的构造函数，子类的构造函数

public class Test { 

public static void main(String[] args){
Child child = new Child(); 
} 
} 
public class Parent { 
Parent(){ 
System.out.println("PARENT");
} 
} 
public class Child extends Parent{ 
Dele dele = new Dele(); 
public Child() { 
super(); 
System.out.println("Child"); 
} 
} 
public class Dele { 
Dele(){ 
System.out.println("Dele");
} 
} 

结果：

PARENT 
Dele 
Child

8.单例模式，得到的是同一个对象

public class TestSC { 
public static void main(String[] args){
SingleClass sc1 = SingleClass.sc; 
SingleClass sc2 = SingleClass.sc; 
sc1.test(); 
sc2.test(); 
} 
} 
public class SingleClass { 
int i=0; 
public static SingleClass sc = new SingleClass();
private SingleClass(){ 

} 
public void test(){ 
System.out.println("hello"+(++i)); 
} 
} 

结果：

hello1 
hello2

9.

public class Test2 extends TT{ 
public static void main(String[] args){
Test2 test2 = new Test2("Tom"); 
} 
public Test2(){ 
this("i am tom"); 
} 
public Test2(String s){ 
super(s); 
System.out.println("how do you do?");
} 
} 
public class TT { 
public TT(){ 
System.out.println("i am pleasure");
} 
public TT(String s){ 
this(); 
System.out.println("i am "+s); 
} 
} 

结果：

i am pleasure 
i am Tom 
how do you do?

10.内部类减少了在类文件编译后产生的字节码文件的大小，但使程序结构不清晰。存放在堆区。

11.内部类可以声明为private或protected，还可以声明为abstract或final。内部类可以声明为static的，但此时就不能再使用外部类的非static的成员变量和非static的成员方法；非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员。

12.我们为什么使用内部类：1）在内部类中，可以随意的访问外部类的成员，这可以让我们更好地组织管理我们的代码，增强代码的可读性。2）内部类可以用于创建适配器类，适配器类是用于实现接口的类。使用内部类来实现接口，可以更好的定位与接口关联的方法在大马中的位置。

13.如果要在匿名类（内部类）中使用（外部的）局部变量，则该局部变量必须被声明为final。

14.System.currentTimeMillis()取得系统时间。从1970年1月1日0时0分0秒开始，到方法执行时经过的秒数。

15.时间和日期的格式化

java.util.Date current=new java.util.Date(); 
java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
String c=sdf.format(current); 
System.out.println(c); 

16.将字符串转化为java.util.Date

1)java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd");
java.util.Date cur=sdf.parse("2013-01-04");
System.out.println(sdf.format(cur));
2)java.text.DateFormat df= DateFormat.getDateInstance();
java.util.Date cur=df.parse("2013-01-04");
System.out.println(df.format(cur));

17.月份的对应：
String [] mouths ={"一月","二月","三月","四月","五月","六月","七月","八月","久月","十月","十一月","十二月"};
java.util.Calendar calendar = Calendar.getInstance();
int mouthint = calendar.get(Calendar.MONTH);
System.out.println(mouths[mouthint]);

18.星期的对应：
String [] weeks ={"","日","一","二","三","四","五","六"};
java.util.Calendar calendar = Calendar.getInstance();
int weeksint = calendar.get(Calendar.DAY_OF_WEEK);
System.out.println(weeks[weeksint]);

19.练习：

java.util.Calendar calendar = Calendar.getInstance(); 
System.out.println(calendar.get(Calendar.YEAR)+""+calendar.get(Calendar.MONTH)+""+calendar.get(Calendar.DAY_OF_MONTH));
calendar.add(Calendar.DAY_OF_YEAR, 315); 
System.out.println(calendar.get(Calendar.YEAR)+""+calendar.get(Calendar.MONTH)+""+calendar.get(Calendar.DAY_OF_MONTH));

结果：

201305
20131016

20.Runtime.getRuntime()
例子：System.out.println(Runtime.getRuntime().freeMemory());
Runtime.getRuntime().gc();
System.out.println(Runtime.getRuntime().freeMemory());

21.获取Class实例的三种方法：
1）利用对象调用getClass（）方法获取该对象的Class实例
2）使用Class类的静态方法forName（），用类的名字获取一个Class实例
3）运用.class方法来获取Class实例
newInstance()调用类中缺省的构造方法

22.数组的复制：java.lang.System.arraycopy(src, srcPos, dest, destPos, length);
数组的排序：Arrays.sort(a);
在已排序的数组中查找某个元素：Arrays.binarySearch(a, key);

23.对象的克隆：在派生类中覆盖Object的clone（）方法,并声明为public，调用super.clone（），在派生类中实现Cloneable接口；
影子clone：

public class AAA implements Cloneable{
public String name;
public Object clone(){
AAA o = null;
try {
o = (AAA) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
AAA a1 = new AAA(); 
AAA a2 = new AAA(); 
a1.name = "a1"; 
a2 = (AAA) a1.clone(); 
a2.name = "a2"; 
System.out.println(a1.name); 
System.out.println(a2.name); 

如果类的成员变量时数组或复杂类型时，要实现深度clone：

public class AAA implements Cloneable{ 
public String name[]; 
AAA(){ 
name = new String [2]; 
} 
public Object clone(){ 
AAA o = null; 
try { 
o = (AAA) super.clone(); 
o.name =(String []) name.clone(); //深度拷贝
} catch (CloneNotSupportedException e) {
e.printStackTrace(); 
} 
return o; 
} 
} 
public class TestAAA { 
public static void main(String[] args){ 
AAA a1 = new AAA(); 
AAA a2 = new AAA(); 
a1.name[0] = "a1"; 
a1.name[1] = "0"; 
a2 = (AAA) a1.clone(); 
a2.name[0] = "a2"; 
a2.name[1] = "1"; 
System.out.println(a1.name[0]+" "+a2.name[1]);
System.out.println(a2.name[0]+" "+a2.name[1]);

} 
}

24.集合：

1）数组结构：每个元素占用连续的内存单元，这样可以获得很高的访问速度
2）链表结构：每个集合元素记录其后面元素的位置，这样对内存空间要求很低，但查找效率不高
3）散列表（哈希表）：以节点关键字为自变量，通过一定的函数关系（散列函数）计算出对应的函数值，以这个值作为节点存储在散列表中的地址，这样存取元素的额效率很高，但内存空间不能完全利用。
4）树形结构：每个元素按照一定的规律和已存在的元素进行比较而决定如何存放，会自动排序。

25.Set接口和List接口都继承自Collection接口 ，Map接口没有继承Collection接口
方法：add 向集合中加入一个对象
　　　　clear 删除集合中的所有对象
　　　　contains 判断集合中是否存在指定对象
　　　　isEmpty 判断集合是否为空
　　　　iterator 返回一个Iterator对象--用它可以遍历集合中的元素
　　　　remove 从集合中删除一个对象
　　　　size 返回集合中元素的个数
　　　　toArray 返回一个数组（包含集合中的所有元素）

　　Set不能包含重复的元素，SortedSet是一个按照升序排列的元素的Set。
List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。
Map包含的key-value对，Map不能包含重复的key。SortedMap是一个按照升序排列的key的Map。

Iterator接口，3个方法：
　　boolean hasNext（）判断集合中是否还有未迭代的元素--有就返回true
　　E next（）：返回（迭代中的）下一个元素。
　　void remove（） 从集合中删除（由上一个next方法返回的）元素。
如果集合中的元素未排序，则Iterator遍历集合中元素的顺序是任意的--未必与向集合中加入元素的顺序一致

List：
ArrayList 相当与长度可变的数组，可以对元素进行快速的随机访问，但插入删除较慢
LinkedList 插入删除较快，随机访问的速度较慢
List的get（int index）方法返回集合中由参数index指定的索引位置的对象。

Set：
HashSet：按照"哈希算法"存取集合中的对象，存取速度较快
TreeSet：该类实现了SortedSet接口，因而具有派讯功能。

26.日志记录包：java.lang.logging

LogManager lMgr = LogManager.getLogManager(); 
String strName ="logPkg"; 
Logger logger = Logger.getLogger(strName); 
lMgr.addLogger(logger); 

logger.setLevel(Level.WARNING);//设置记录器的记录级别，以忽略低于WARNING级别的消息 
logger.info("aaaa"); //不输出 
logger.warning("bbbbbbb"); //警告 
logger.severe("ccccc"); //严重警告