琐碎的java

转自   http://page.renren.com/600882494/note/773889059?ref=hotnewsfeed&sfet=2012&fin=6&ff_id=600882494&feed=page_blog&tagid=773889059&statID=page_600882494_2&level=1

 1.
　　对于类中的final类型属性，一般在声明的时候直接写 final int a =1 ;但也可以在构造函数中进行赋值
　　如：
　　final int a;
　　A{}( a =1;)
　　但要注意：需要每一个构造函数都赋值，且不能嵌套。
　　而：如果想写static final int a;则必须在声明时进行初始化,static final int a = 1;因为静态的也是不属于类。
　　2.
　　继承中要注意的问题：子类对父类中构造方法的问题
　　父类的中构造方法不能被继承，故
　　class A{}
　　class B extends A{ A();} //是错的,只能用super关键字
　　如果子类中没有显示的调用super,则系统会加上,super();注意即是找父类中无参数的构造方法,所以,如果父类自己写了构造方法而导致无参数的已经不存在了,
　　则会出错.
　　3.
　http://page.renren.com/600882494/note/773889059?ref=hotnewsfeed&sfet=2012&fin=6&ff_id=600882494&feed=page_blog&tagid=773889059&statID=page_600882494_2&level=1静态方法：只属于类本身，而不是某个对象。它是在类加载的时候，就已经为之分配好内存了。这时，并没有产生这个的对象。而对象只有在new时候才会出现。所以只能把这个变量加个static.这也叫做类变量，与之对应的叫做实例变量。
　　4.
　　main是静态的，因为它不是属于某个类的，而是全局的。
　　因此在执行时直接找到main,而不是针对某个类的对象。
　　如果不是static,则会先产生类的对象。
　　public：由于其是虚拟机调用，因此必须是public的
　　static：由于其不必产生对象，因此是static的
　　5.
　　对于主类的修饰符是default时：表示在同一个包中可以被访问。
　　6.
　　final类不能被继承。
　　7.
　　private的方法，只要出了类就不能被访问，不管是在同一个包中，还是继承关系。
　　默认的访问权限都是在这个包中，被继承也不能被访问。
　　protected 方法对以上均适用，但 和 public 方法也有区别
　　在于：对于不同包中，没有继承关系的两个类而言，在一个类中使用了另一个类的对象，则只有public方法可以被访问，而protected方法不能被访问。
　　8.
　　抽象方法的声明：abstract void proMethod(); //不要加大括号
　　看一个类是否被实现，不是看{}里面有没有代码，而是看有没有{}

        9. JNI(Java Native Interface)，它允许Java虚拟机(JVM)内部运行的Java代码能够与用其它编程语言(如c、c++、汇编语言)编写的应用程序和库进行互操作。
　　JNI可以理解为Java和本地应用程序之间的中介。
　　它最大的好处是没有对底层Java虚拟机的实现施加任何限制。
　　写一个native的方法：
　　1.写java代码段，如HelloWorld.java。
　　2.用javac来编译之，得到.class文件。
　　3.用javah -jni 来生成HelloWorld头文件，得到HelloWorld.h
　　4.用HelloWorld.h来生成本地方法，得到HelloWorldImp.c
　　5.编译本地代码，加载共享库，生成Hello.so
　　(so文件是linux,或unix下动态连接库的文件，相当于windows下的.dll)
　　10.
　　对于接口中的方法，默认情况下就是public abstract的，因此不用再写，也因此，实现接口时必须用public来修饰。
　　接口中的数据成员默认都是public static final.
　　11.
　 
以下是代码片段：
　class Z extends A implements B,C 
　　{ 
　　} 
　　//注意这个顺序先派生类，再实现接口。
　　12.
　　有关内部类：
　　当我们产生一个派生类的对象的时候，它会调用基类的构造函数，产生一个基类的对象。
　　因此
　 
以下是代码片段：
　class Car 
　　{ 
　　class Wheel 
　　{ 
　　} 
　　} 
　　class PlaneWheel extends Car.Wheel 
　　{ 
　　public static void main(String[] args) 
　　{ 
　　PlaneWheel pw = new PlaneWheel(); 
　　} 
　　}
　　这是不能通过编译的，因为我们要产生pw，就必须先产生Car.Wheel的对象，而它是内部类，所以要产生它的对象，就必须先产生外部类的对象，才能建立起内部与外部的引用关系。
　　因此作出改变：
以下是代码片段：
　　class PlaneWheel extends Car.Wheel 
　　{ 
　　PlaneWheel(Car car) 
　　{ 
　　car.super(); 
　　} 
　　public static void main(String[] args) 
　　{ 
　　Car car = new Car(); 
　　PlaneWheel pw = new PlaneWheel(car); 
　　} 
　　}
　　21.
　　javac A.java
　　可以生成B.class
　　前提是classB，在A.java中被声明为一个类，且不是Public的。
       22.
　　finally的问题：不是在try，catch之后的语句就相当于finally，因为如果在try中有return语句，则其后的是不会被执行的。而如果放在finally中，则一定会执行。
　　如果在代码中会有一个严重错误，而不想让finally中的语句执行，则写
　　System.exit(-1);来避免其执行。//不是0就可以。
　　23.
　　c++中允许程序员重载操作符，但java中不允许。
　　针对String的"+"和"+="，是java中唯一被重载的操作符。
　　24.
　　StringBuffer的应用：
　　StringBuffer sb = new StringBuffer().append("a").append("bc").append("123");
　　可用toString()方法，将其转化为toString();
　　由于在打印时会自动调用toString方法，因此，打印时不必显示加上。
　　25.
　　java中的索引是从0开始，而且，对于一个区间的数值，是大于等于，小于的关系。即前面的数字是包含的，而后面的是不包含的。
　　26.
　　java中，传参时：
　　对于基本数据类型，传递的是数据的拷贝;
　　对于引用类型，传递的引用的拷贝。但是对于引用的拷贝，是浅拷贝，即指向了堆中同一处内存。
　　因此在改变值的时结果不一样，对于基本类型，其回到传参者时没有改变其值，而对于引用，其值则改变了。
　　27.
　　有的接口中没有任何抽象方法，如cloneable，叫作标识接口。它仅仅是告诉编译器自己可以被克隆。
　　如果类中的成员有引用，则涉及到浅拷贝还是深拷贝的问题。
　　浅拷贝就是把除了引用成员的全都拷贝一份，而对于引用部分则指向同一处。而深拷贝就是把所有的都拷贝一份。
　　调用super.clone()方法，它可以在运行时刻，object中的clone()识别出你要复制的哪一个对象，然后为此对象分配空间，并进行对象复制，将原始对象的内容一一复制到新对象的存储空间中。
　　28.
        Integer的
　　valueOf(String s) //把s转化成一个包装类对象返回
　　parseInt(String s) //把s转化成一个int型数据返回
　　封装类的对象的值是不能被修改的，只能是读。
　
  　  29.
         java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。
　　获取class实例的三种方式：
　　a.利用对象调用getClass()方法获取该对象的class实例;
　　b.使用class类的静态方法forName(),用类的名字获取一个class实例
　　c.运用.class的方式来获取class实例，对于基本数据类型的封装类，还可以用.type来获取相对应的基本数据类型的class类型。
　　如：
　　 
以下是代码片段：
Point pt = new Point(); 
　　Class c1 = pt.getClass(); 
　　System.out.println(c1.getName()); 
　　try{ 
　　Class c2 = Class.forName("Point"); 
　　System.out.println(c2.getName()); 
　　} 
　　catch{……} 
　　Class c3 = Point.class; 
　　System.out.println(c3.getName()); 
　　Class c4 = int.class; 
　　System.out.println(c4.getName()); 
　　Class c5 = Integer.TYPE; 
　　System.out.println(c5.getName());
　　30.
　　java中的反射api：主要用于：对于某个不知道名字的类，通过反射机制调用他们的构造函数，为构造函数及其他函数进行传参，调用。

　　31.
        runtime这个类提供了应用程序与环境之间的接口。
　　可以获取jvm的总共内存，已占有的内存。
　　用getRuntime()方法获取其实例。
　　Runtime rt = Runtime.getRuntime();
　　System.out.println(rt.freeMemory());
　　System.out.println(rt.totalMemory());
　　另可以有执行命令，返回一个process. 为应用程序做准备。
　　try{rt.exec("notepad");}
　　try{rt.exec(javac ArrayTest.java);};
　　要获得其具体输出的信息，可以用process类。
　　try{
　　Process p = rt.exec("java ArrayTest");
　　InputStream is = p.getInputStream();//此时，其输出全在了 InputStream中
　　int data;
　　while((data=is.read())!=-1)
　　{
　　System.out.print((char)data);
　　}
　　}
　　Runtime类是使用单例模式的一个例子。

　　32.
        单例模式：
　　a.一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类。
　　b.单例类的一个最重要特点：它是类的构造方法是私有的，从而避免了外部利用构造方法直接创建多个实例。
　　 
以下是代码片段：
class Singleton 
　　{ 
　　private static final Singleton st = new Singleton(); 
　　private Singleton(){} 
　　public static Singleton getInstance() 
　　{ 
　　return st; 
　　} 
　　}