zoukankan      html  css  js  c++  java

  • 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

    9.

     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"); //严重警告
  • 相关阅读:
    MySQL之SQL优化详解（三）
    MySQL之SQL优化详解（二）
    MySQL之SQL优化详解（一）
    RabbitMQ从入门到精通（三）
    RabbitMQ 从入门到精通（二）
    RabbitMQ 从入门到精通 （一）
    Redis 的主从复制(Master/Slave)
    Redis的事务讲解
    Linux CentOS完全卸载PHP
    Linux（CentOS7）常用命令详解
  • 原文地址：https://www.cnblogs.com/fanglove/p/2847586.html
Copyright © 2011-2022 走看看