java知识点总结

0、 局部变量 前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量 
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。 

1、当一个方法前面的修饰符为private 或 static时，系统会自动在方法前面加一个final,所以该方法可以被继承但不能被重写。 

2.任何类都有构造方法，abstract方法有没有实现的构造方法，所以他的实例对象只能通过它的子类实现。 

3.interface可以extends多个接口，类只能单继承（extends），多实现（implements）。 

4.final和abstract永远不能同时存在，synchronized，native,static不能和abstract放一起。 

5.多态：编译时多态（overload重载）/运行时多态（override重写）。 
  构造器Constructor不能被继承（override）,可以重载（override）。 

6.接口里面的成员变量和成员方法：常量：public static final NULL="null" ; 
                            抽象方法：public [abstract] void setDao() ; 
方法没有实现，没有实现！=空实现  public void setDao(){} ; 

7.抽象类里面可能有抽象方法和非抽象方法，有抽象方法的类一定是抽象类。 

8.IAImple extends A implements IA,IB{} 
  IB I = new IAImple() ; 
  I instance of IAImple/A/IA/IB   均为true  对象I就是类IAImple、A，接口IA和IB的实例对象。 

9.Object类是java体系中所有类的父类（包括抽象类），Object里面的三个方法： 
   finalize(),当对象被垃圾回收器回收时调用。 
   toString(),当输出一个对象时，默认调用 对象.toString() ; 
   equals(),判断两个字符串是否一样 

10.String类为为final类，一个字符串值不可变，存在JVM的字符串池中，以后可以去池中找 
   StringBuffer是可变字符串 

11.

Java代码  

1. String a = new String("momo") ;  
2.    String b = new String("momo") ;  
3.    a==b   //false   比较a和b的地址，两个都是新New的连个不同对象，地址不一样    
4.   
5.    String a = "momo" ;  //a会去JVM的字符串池中找“momo”,没有则系统将“momo”存在池中  
6.    String b = "momo" ;  //去池中找，有“momo”,把momo地址给b  
7.    a==b   //true        比较a、b地址是否一样  
8.   
9.   String a="momo" ;  
10.    a.equals("momo") ;  //true  比较a、b的值  
11.   
12.    Student s1 = new Student("momo") ;  
13.    Student s2 = new Student("momo") ;  
14.    s1.equals(s2) ;  //false  
15.    s1==s2 ;         //false   

Java代码  

1. package com.org.momo.字符串;  
2.   
3. public class String1 {  
4.    public static void main(String[] args){  
5.        String a = new String("momo") ;  
6.        String b = new String("momo") ;  
7.        System.out.println(a==b) ;  
8.        System.out.println(a.equals(b)) ;  
9.          
10.        Team t1 = new Team("momo") ;  
11.        Team t2 = new Team("momo") ;  
12.        System.out.println(t1==t2);  
13.        System.out.println(t1.equals(t2)+"\t输出对象t1:"+t1) ;  
14.          
15.        String c = "momo" ;  
16.        String d = "momo" ;  
17.        System.out.println(c==d) ;  
18.        System.out.println(a==c) ;  
19.        System.out.println(a.equals(c));  
20.        }  
21. }  
22.   
23.   
24. 输出结果：  
25. false  
26. true  
27. false  
28. false   输出对象t1:com.org.momo.字符串.Team@c17164  
29. true  
30. false  
31. true  

   

12. 数组：大多用来存放简单的数据类型（8种），可以存放对象 
    Collection接口和Map接口只能存放对象   

13. 
  同步的实现方面有两种，分别是synchronized,wait与notify 
  线程实现的两种方式：继承Thread类与实现Runnable接口 
 

Java代码  

1. 一：class MyThread extends Thread{  
2.       public void run(){}  
3.       }  
4.      public class TestThread{  
5.       main(){  
6.       Thread t1 = new Mythread() ;  
7.       t1.start() ;  
8.    }    
9.     }  
10.        
11.   二：Class MyThread implements Runnable{  
12.       public void run(){  
13.         Runnable target = new MyThread() ;  
14.         Thread t3 = new Thread(target) ;  
15.         Thread.start() ;//启动多线程  
16.       }  
17.     }  

  
就绪、运行、synchronize阻塞、wait和sleep挂起、结束。 
wait必须在synchronized内部调用。 

调用线程的start方法后线程进入 就绪 状态，线程调度系统将就绪状态的线程转为 运行 状态，遇到synchronized语句时，由运行状态转为 阻塞 ，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为 挂起 状态，当线程关联的代码执行完后，线程变为 结束 状态。 




14.当一个线程进入一个对象的一个synchronized方法后，其它线程不能进入此对象的其它方法。 

15.接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承 实体类(例如：Object类) ，但前提是实体类必须有明确的构造函数。 

16.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会在return前执行。 

17.A a=new A(); 
   a就是句柄，是引用类型的变量只是一个普通变量，储存了引用类型的地址，存储在栈内存中的 
   new出来的对象是存放在堆内存中，要想调用它则要通过它的引用类型a中的地址进行调用。 

18.JAVA中只有 值传递 ，没有 引用传递 任何数据（不管是基本类型，还是引用类型）传到一个方法里时，都是拷贝了一份，所以无法在一个方法里修改他们的值，当然，如果传递的是对象的话，也就是引用，那么其实是拷贝这个对象的一个引用。 
当一个 对象实例 作为一个参数被传递到方法中时，参数的值就是对该 对象的引用 。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。 

Java代码  

1. public static void main(String[] args) {  
2.   String[] abc = new String[]{"1", "2", ""};  
3.   ss(abc);  
4.   for(String str : abc) {  
5.    System.out.println(str);  
6.   }  
7.  }  
8.    
9.  public static void ss(String[] aa) {  
10.   aa[2] = "3";  
11.  }  
12. 打印1  2  3  
13. 并不是说函数内能影响到函数外的数据就一定是引用传参，注意abc是一个“对象的引用”，你这个并没有做到改变函数外面abc的值，你实际上修改的是abc“指向的对象”，而不是修改的“abc本身” 。  

19.switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char、 byte。long,string 都不能作用于swtich。 

20.JVM加载class文件的原理机制： 
在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备、解析 
    装载：查找和导入类或接口的二进制数据； 
    链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的； 
    校验：检查导入类或接口的二进制数据的正确性； 
         准备：给类的静态变量分配并初始化存储空间； 
         解析：将符号引用转成直接引用； 
初始化：激活类的静态变量,初始化Java代码和静态Java代码块 

21.作用域public,private,protected,以及不写时的区别  
作用域 当前类 同一package 子孙类 其他package 
public    √    √         √      √ 
protected √    √         √      × 
default   √    √         ×      × 
private   √    ×         ×      × 

22.显示转换（强制转换）：大转小  float f = （float）3.4 ;  int i=(int)2L ; 
   隐式转换： 小转大  Double d = 3.4f ; Long l = 2 ; 

23.集合接口：Collection、Map(java.util.*) 
Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
│　└Stack 
└Set 
Map （key----> value） 
├Hashtable 
├HashMap 
└WeakHashMap 

27.Class.forName(str).newInstance()：返回一个以字符串str指定类名的类的对象，通过反射实现。 

30. 类访问  
a.如果一个A.java文件，里面类 class  A {} 没有用public修饰，系统会默认给他加一个public。 
b.加入A.java文件里面还有另一个类 B {}，也没有修饰符，系统默认给他加 default访问权限。 

31.要想定义一个非public访问属性的类，可以再一个public Class类里面写一个与他等级并列的类！该类的访问权限为default,只能子类或本类中可以实例化该类。 

32.final、finally、finalized 
final修饰符：修饰类（不能被继承）、属性（常量）、方法（不能被重写） 
finally异常调用:异常捕获一定会执行，且最后一次执行。 
finalize():Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。 

33.finally中的代码比return 和break语句后执行 

32.String s="a"+"b"+"c"+"d"; 
   一共创建了1个对象，javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。 

33. 
     String s1 = "a"; 
    String s2 = s1 + "b"; 
    String s3 = "a" + "b"; 
    String s = "a" ; 
    String s4 = new String("a"); 
    String s44 = new String("a") ; 
    System.out.println(s1 == s) ;    //true 
    System.out.println(s4 == s44) ;  //false 
    System.out.println(s2 == "ab");  //false 
    System.out.println(s3 == "ab");  //true 

34.String s = new String("xyz");创建了几个对象？ 
  创建两个。一个是编译时决定的，最后放在常量池(constant pool)中"xyz"。一个是运行时放在堆里面的new String("xyz")。两个都是"xyz"。还有的,s确实只是一个引用，本身不是对象。 

35.存放位置： 
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制. 
2. 栈：存放 基本类型的变量 数据和 对象的引用 ，但 对象本身不存放在栈 中，而是存放在堆 （new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。） 
3. 堆：存放所有new出来的对象。 
4. 静态域：存放静态成员（static定义的） 
5. 常量池：存放字符串常量和基本类型常量（public static final）。 
6. 非RAM存储：硬盘等永久存储空间 

36.线程sleep()和wait()区别： 
sleep： 是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 
wait： 是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。 

37.异常：运行过程中可能出现的非正常状态。 
Throwable 
├Exception 
│├RuntimeException(可以不捕获) 
│├ 一般异常（必须捕获或声明抛出） 
└error 

一般异常（常见的）： 
NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException、ClassNotFoundException、IOException 

38.怎样实现一个线程： 

Java代码  

1. //new一个继承Thread类的实例对象  
2. new Thread(){  
3. public void run(){  
4. }  
5. }.start();  
6.   
7. //new一个实现Runnable接口的实例对象  
8. new Thread(new Runnable(){  
9. public void run(){  
10. }   
11. }  
12. ).start();  

39. Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数. 
    1.相同的对象一定会返回相同的hashCode(整型) 
    2.不同的对象可能会返回相同的hashCode 
    3.hashcode不同的两个对象是两个不同的对象 
    4.两个对象值相同(x.equals(y) == true)，但却可有不同的hash code 

Java代码  

1. 例如：  
2.               String str1 = "ab" ;  
3.        String str3 = new String("ab") ;  
4.        System.out.println(("a"+"b" == str1)) ;//true  
5.             System.out.println((str1 == str3)) ;//false,物理地址不一样，不是同一对象  
6.   
7.         System.out.println(str1.hashCode()) ;  //3105  
8.        System.out.println(("a"+"b").hashCode()) ;  //3105  
9.        System.out.println(str3.hashCode()) ;  //3105  

40.类对象的成员变量声明时，可以不用显示赋值，JVM会默认给其赋值。 
   方法里面的局部变量声明时要显示的赋值，否则使用该变量时会编译报错。 

42.去掉一个Vector集合中重复的元素 

Java代码  

1. Vector newVector = new Vector();  
2. For (int i=0;i<vector.size();i++)  
3. {  
4. Object obj = vector.get(i);  
5. if(!newVector.contains(obj);  
6. newVector.add(obj);  
7. }  
8. 还有一种简单的方式，HashSet set = new HashSet(vector);   

43.Collection 和 Collections的区别。 
     Collection是集合类的上级接口，继承与他的接口主要有Set 和List. 
    Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 


44.Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。 

45. 

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.FileInputStream;  
3. import java.io.FileOutputStream;  
4. import java.io.FileReader;  
5. import java.io.FileWriter;  
6. import java.io.InputStreamReader;  
7. import java.io.PrintWriter;  
8.   
9. public class IOTest {  
10. public static void main(String[] args) throws Exception {  
11. String str = "中国人";  
12.   
13. //以下三个是从内存输出，写到文件中  
14. FileOutputStream fos  = new FileOutputStream("1.txt");  
15. fos.write(str.getBytes("UTF-8"));  
16. fos.close();  
17.   
18. FileWriter fw = new FileWriter("1.txt");  
19. fw.write(str);  
20. fw.close();  
21.   
22. PrintWriter pw = new PrintWriter("1.txt","utf-8");  
23. pw.write(str);  
24. pw.close();  
25.   
26.    
27.   
28. //以下三个是从文件中读，输入到内存中  
29. FileReader fr = new FileReader("1.txt");  
30. char[] buf = new char[1024];  
31. int len = fr.read(buf);  
32. String myStr = new String(buf,0,len);  
33. System.out.println(myStr);  
34.   
35. FileInputStream fr = new FileInputStream("1.txt");  
36. byte[] buf = new byte[1024];  
37. int len = fr.read(buf);  
38. String myStr = new String(buf,0,len,"UTF-8");  
39. System.out.println(myStr);  
40.   
41. BufferedReader br = new BufferedReader(  
42. new InputStreamReader(new FileInputStream("1.txt"),"UTF-8"));  
43. String myStr = br.readLine();  
44. br.close();  
45. System.out.println(myStr);  
46. }   
47. }  

46.Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。 Java语言没有提供释放已分配内存的显示操作方法。 所以程序员不能自行清除内存，只能调用System.gc() ;提醒JVM去处理，具体什么时候去处理，我们不得而知。 

47.垃圾回收器（Gabage Collection）的基本原理是什么？ 
   当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。 

48.垃圾回收器可以马上回收内存吗？ 可以 

49.有什么办法主动通知虚拟机(JVM)进行垃圾回收(GC)？ 
   程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。 

50.assertion(断言) 
   是在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，assert将给出 警告或退出 。 

51.java语言中，除开接口，其他一切类都有构造方法。 

a. 构造方法的特征 
• 它具有与类相同的名称； 
• 它不含返回值； 
• 它不能在方法中用 return 语句返回一个值； 
• 当自定义了构造方法后，编译器将不再自动创建不带参数的构造方法 。 
• 在构造方法里不含返回值的概念是不同于 “void” 的，在定义构造方法时加了 “void” ，则该方法变为成员方法而不是构造方法。 

Java代码  

1. public class Main {  
2.   private String name ;  
3.    Main(){}   //无参构造，JVM默认加public  
4.    Main(String m) {}  //构造方法  public  
5.    void Main(String m){}   //成员方法  
6. }  

b. 构造方法的作用：  
当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。 


52.成员变量和局部变量的作用范围 

Java代码  

1. package com.org.momo.变量;  
2.   
3. public class 变量作用范围 {  
4.    int a  ;  
5.    public static void main(String args[]){   
6.        int j ;  
7.        while(true){  
8.            int j = 2 ; //编译会报错，方法里面不允许定义两个同名变量  
9.            System.out.println(j) ;  //编译会报错，应为j不是类的成员变量，而是局部变量JVM不会帮你初始化，需自己初始化后在使用  
10.        }  
11.    }  
12.    public void print(){  
13.        int a = 10 ;    //编译通过，类里面允许定义两个同名变量  
14.    }  
15. }  

53、类的成员变量： 
    final 变量名 ；  在声明时初始化/在构造方法里面初始化 
    final static 变量名 ；  声明时初始化/静态块里初始化 

54、java类加载机制： http://my.oschina.net/zhaoqian/blog/83778  

55.容器介绍