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.构造函数应包含哪些内容：

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

 1 class A{ 
 2 static{ 
 3 System.out.println("Static A"); 
 4 } 
 5 A(){ 
 6 System.out.println("A()"); 
 7 } 
 8 } 
 9 class B extends A{ 
10 C c = new C(); 
11 static{ 
12 System.out.println("Static B"); 
13 } 
14 B(){ 
15 System.out.println("B()"); 
16 } 
17 public static void main(String[] args){ 
18 new B(); 
19 } 
20 } 
21 class C{ 
22 C(){ 
23 System.out.println("c()"); 
24 } 
25 }

结果：

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

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

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

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

 1 public class Test { 
 2 
 3 public static void main(String[] args){
 4 Child child = new Child(); 
 5 } 
 6 } 
 7 public class Parent { 
 8 Parent(){ 
 9 System.out.println("PARENT");
10 } 
11 } 
12 public class Child extends Parent{ 
13 Dele dele = new Dele(); 
14 public Child() { 
15 super(); 
16 System.out.println("Child"); 
17 } 
18 } 
19 public class Dele { 
20 Dele(){ 
21 System.out.println("Dele");
22 } 
23 }

结果：

PARENT 
Dele 
Child

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

 1 public class TestSC { 
 2 public static void main(String[] args){
 3 SingleClass sc1 = SingleClass.sc; 
 4 SingleClass sc2 = SingleClass.sc; 
 5 sc1.test(); 
 6 sc2.test(); 
 7 } 
 8 } 
 9 public class SingleClass { 
10 int i=0; 
11 public static SingleClass sc = new SingleClass();
12 private SingleClass(){ 
13 
14 } 
15 public void test(){ 
16 System.out.println("hello"+(++i)); 
17 } 
18 }

结果：

hello1 
hello2

 1 public class Test2 extends TT{ 
 2 public static void main(String[] args){
 3 Test2 test2 = new Test2("Tom"); 
 4 } 
 5 public Test2(){ 
 6 this("i am tom"); 
 7 } 
 8 public Test2(String s){ 
 9 super(s); 
10 System.out.println("how do you do?");
11 } 
12 } 
13 public class TT { 
14 public TT(){ 
15 System.out.println("i am pleasure");
16 } 
17 public TT(String s){ 
18 this(); 
19 System.out.println("i am "+s); 
20 } 
21 }

结果：

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.时间和日期的格式化

1 java.util.Date current=new java.util.Date(); 
2 java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
3 String c=sdf.format(current); 
4 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：

 1 public class AAA implements Cloneable{
 2 public String name;
 3 public Object clone(){
 4 AAA o = null;
 5 try {
 6 o = (AAA) super.clone();
 7 } catch (CloneNotSupportedException e) {
 8 e.printStackTrace();
 9 }
10 return o;
11 }
12 }
13 AAA a1 = new AAA(); 
14 AAA a2 = new AAA(); 
15 a1.name = "a1"; 
16 a2 = (AAA) a1.clone(); 
17 a2.name = "a2"; 
18 System.out.println(a1.name); 
19 System.out.println(a2.name);

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

 1 public class AAA implements Cloneable{ 
 2 public String name[]; 
 3 AAA(){ 
 4 name = new String [2]; 
 5 } 
 6 public Object clone(){ 
 7 AAA o = null; 
 8 try { 
 9 o = (AAA) super.clone(); 
10 o.name =(String []) name.clone(); //深度拷贝
11 } catch (CloneNotSupportedException e) {
12 e.printStackTrace(); 
13 } 
14 return o; 
15 } 
16 } 
17 public class TestAAA { 
18 public static void main(String[] args){ 
19 AAA a1 = new AAA(); 
20 AAA a2 = new AAA(); 
21 a1.name[0] = "a1"; 
22 a1.name[1] = "0"; 
23 a2 = (AAA) a1.clone(); 
24 a2.name[0] = "a2"; 
25 a2.name[1] = "1"; 
26 System.out.println(a1.name[0]+" "+a2.name[1]);
27 System.out.println(a2.name[0]+" "+a2.name[1]);
28 
29 } 
30 }

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

1 LogManager lMgr = LogManager.getLogManager(); 
2 String strName ="logPkg"; 
3 Logger logger = Logger.getLogger(strName); 
4 lMgr.addLogger(logger); 
5 
6 logger.setLevel(Level.WARNING);//设置记录器的记录级别，以忽略低于WARNING级别的消息 
7 logger.info("aaaa"); //不输出 
8 logger.warning("bbbbbbb"); //警告 
9 logger.severe("ccccc"); //严重警告

posted @ 2013-01-06 13:50 柱柱阅读(261) 评论(0) 编辑收藏举报

刷新页面返回顶部

柱柱

String man,woman; if(man == "fei" && woman == "fang"){ System.out.println("love for ever"); }

JAVA核心技术

公告