java知识点总结

javase知识点总结 

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.

String a = new String("momo") ;
   String b = new String("momo") ;
   a==b   //false   比较a和b的地址，两个都是新New的连个不同对象，地址不一样

   String a = "momo" ;  //a会去JVM的字符串池中找“momo”,没有则系统将“momo”存在池中
   String b = "momo" ;  //去池中找，有“momo”,把momo地址给b
   a==b   //true        比较a、b地址是否一样

  String a="momo" ;
   a.equals("momo") ;  //true  比较a、b的值

   Student s1 = new Student("momo") ;
   Student s2 = new Student("momo") ;
   s1.equals(s2) ;  //false
   s1==s2 ;         //false

package com.org.momo.字符串;

public class String1 {
   public static void main(String[] args){
       String a = new String("momo") ;
       String b = new String("momo") ;
       System.out.println(a==b) ;
       System.out.println(a.equals(b)) ;

       Team t1 = new Team("momo") ;
       Team t2 = new Team("momo") ;
       System.out.println(t1==t2);
       System.out.println(t1.equals(t2)+"\t输出对象t1:"+t1) ;

       String c = "momo" ;
       String d = "momo" ;
       System.out.println(c==d) ;
       System.out.println(a==c) ;
       System.out.println(a.equals(c));
       }
}


输出结果：
false
true
false
false   输出对象t1:com.org.momo.字符串.Team@c17164
true
false
true

   

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

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

一：class MyThread extends Thread{
      public void run(){}
      }
     public class TestThread{
      main(){
      Thread t1 = new Mythread() ;
      t1.start() ;
   }
    }

  二：Class MyThread implements Runnable{
      public void run(){
        Runnable target = new MyThread() ;
        Thread t3 = new Thread(target) ;
        Thread.start() ;//启动多线程
      }
    }

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

public static void main(String[] args) {
  String[] abc = new String[]{"1", "2", ""};
  ss(abc);
  for(String str : abc) {
   System.out.println(str);
  }
 }

 public static void ss(String[] aa) {
  aa[2] = "3";
 }
打印1  2  3
并不是说函数内能影响到函数外的数据就一定是引用传参，注意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 

24.JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）： 
request 用户端请求，此请求会包含来自GET/POST请求的参数 
response 网页传回用户端的回应 
pageContext 网页的属性是在这里管理 
session 与请求有关的会话期 
application servlet 正在执行的内容 
out 用来传送回应的输出 
config servlet的构架部件 
page JSP网页本身 
exception 针对错误网页，未捕捉的例外 

25.JSP共有以下6种基本动作: 
jsp:include：在页面被请求的时候引入一个文件。 
jsp:useBean：寻找或者实例化一个JavaBean。 
jsp:setProperty：设置JavaBean的属性。 
jsp:getProperty：输出某个JavaBean的属性。 
jsp:forward：把请求转到一个新的页面。 
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。 

26.动态INCLUDE：<jsp:include page="included.jsp" flush="true" /> 
   静态INCLUDE：<%@ include file="included.htm" %> 

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

28.分页时页面需要保存以下参数： 
      每页显示行数：设定值 
      当前页数：请求参数 
      总行数：根据sql语句得到总行数 
    原理：页面根据当前页数和每页行数计算出当前页第一行行数，定位结果集到此行，对结果集取出每页显示行数的行即可。 

29.SSH作用：  
Struts的目的是为了分离视图层和控制层 
  Spring是为了让你养成用接口编程的好习惯 提高程序的重用率还有可维护性（健壮性） 
  Hibernate的目的是为了实现用面向对象的思想来管理数据库 实现与数据库之间的低耦合 
  MVC三层架构：模型层，控制层和视图层。 
模型层，用Hibernate框架让来JavaBean在数据库生成表及关联，通过对JavaBean的操作来对数据库进行操作； 
控制层，用Struts框架来连接数据层和视图层的，接收、处理、发送数据并控制流程； 
视图层，用JSP模板把页面展现给用户以及提供与用户的交互。 
而Spring框架粘合了Hibernate和Struts，透明的管理了整个架构，提供IOC容器使代码松耦合以及AOP框架的切面功能等等。 


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.怎样实现一个线程： 

//new一个继承Thread类的实例对象
new Thread(){
public void run(){
}
}.start();

//new一个实现Runnable接口的实例对象
new Thread(new Runnable(){
public void run(){
}
}
).start();

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

例如：
              String str1 = "ab" ;
       String str3 = new String("ab") ;
       System.out.println(("a"+"b" == str1)) ;//true
            System.out.println((str1 == str3)) ;//false,物理地址不一样，不是同一对象

        System.out.println(str1.hashCode()) ;  //3105
       System.out.println(("a"+"b").hashCode()) ;  //3105
       System.out.println(str3.hashCode()) ;  //3105

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

41.非void类型的方法一定有 return 
    void类型的方法也可以有return,但必须置于句末。 

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

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

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


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

45. 

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class IOTest {
public static void main(String[] args) throws Exception {
String str = "中国人";

//以下三个是从内存输出，写到文件中
FileOutputStream fos  = new FileOutputStream("1.txt");
fos.write(str.getBytes("UTF-8"));
fos.close();

FileWriter fw = new FileWriter("1.txt");
fw.write(str);
fw.close();

PrintWriter pw = new PrintWriter("1.txt","utf-8");
pw.write(str);
pw.close();



//以下三个是从文件中读，输入到内存中
FileReader fr = new FileReader("1.txt");
char[] buf = new char[1024];
int len = fr.read(buf);
String myStr = new String(buf,0,len);
System.out.println(myStr);

FileInputStream fr = new FileInputStream("1.txt");
byte[] buf = new byte[1024];
int len = fr.read(buf);
String myStr = new String(buf,0,len,"UTF-8");
System.out.println(myStr);

BufferedReader br = new BufferedReader(
new InputStreamReader(new FileInputStream("1.txt"),"UTF-8"));
String myStr = br.readLine();
br.close();
System.out.println(myStr);
}
}

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” ，则该方法变为成员方法而不是构造方法。 

public class Main {
  private String name ;
   Main(){}   //无参构造，JVM默认加public
   Main(String m) {}  //构造方法  public
   void Main(String m){}   //成员方法
}

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


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

package com.org.momo.变量;

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

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

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

55.容器介绍：http://my.oschina.net/zhaoqian/blog/89741 

 

 

 

56.java几种数据类型之间的转换

 

 

 

     (1)  String类型变量转换成int类型变量：使用Integer类的parseInt(String )方法 
     如：String s = "123"; 
             int num = Integer.parseInt(s); 
             Float f= Integer.parseInt (s); 
             Long lo=long. parseInt (s); 
             Double d=double. parseInt (s); 

             Byte b=Integer.intValue(s); 
             Short sh=Integer.intValue(s); 
        注意：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，会抛出异常java.lang.NumberFormatException 

      (2)  String类型转换成double类型变量：使用double类的parseDouble(String )方法 
     如：String s = "123"; 
             idouble num = Double.parseDouble(s); 

      (3)  int类型变量转换成String类型变量：使用String类的valueOf(int )方法 
      如： int num = 123; 
              String s = String.valueOf(num); 

      (4)  Double类型变量转换成String类型变量：使用String类的valueOf(int )方法 
      如： Double num = 123.0; 
              String s = String.valueOf(num); 

      (5)  String变量转换成字符数组Char[]：使用String类的toCharArray()方法 
      如： String s = "123"; 
               char[] ch = s.toCharArray(); 

      (6)  String->char 转换 
     String s=”abc”; 
    Char a=s.charAt(0); 

      (7)  String-->boolean 转换 
      String s=”true”; 
     Boolean flag=Boolean.valueOf (“s”); 

      (8)  字符或字符数组转换成字符串，也是通过valueOf()方法，不再给出示例代码。 

 

 

57.键盘输入 

(1)通过java.util.Scanner类获取输入 

Java代码   

1.  import java.util.Scanner;  

2.    

3.  public class data{  

4.    public static void main(String[] args){     

5.      Scanner input = new Scanner(System.in);    

6.     

7.      System.out.println("输入一个数");  

8.       int data_1 = input.nextInt();  

9.         

10.    System.out.println("输入一个字符");  

11.     String str = input.next();  

12.      

13.    System.out.println("输入一个实数");  

14.    double data_2 = input.nextDouble();  

15.    String huiche = input.nextLine();  

16.    /* 

17.    nextXXX()方法的工作原理: 

18. 

19.       从一行中扫描，直到碰到特定的标识符：空格或是换行符（\n），便获取之前的东西。 

20.       nextDouble()读取了之前的数据，但并没有读入"\n"，也不负责换行，然后就把 "\n"丢给了nextLine()处理， 

21.        nextLine()看见“\n”就收了，然后扫描了 \n 之前的内容，也就是空字符串。于是出现问题了。 

22.    */      

23.  

24.    System.out.println("输入一行字符:");     

25.    String str2 = input.nextLine();  

26.      

27.    System.out.println("输入的这个数为："+data_1);       

28.    System.out.println("输入的这个字符为："+str);  

29.    System.out.println("输入的这个实数为："+data_2);  

30.    System.out.println("输入的这个字符为："+str2);  

31.    }  

32.}  

(2)、通过输入流获取输入 

Java代码   

1.  第一个JAVA文件  

2.    

3.    

4.  import java.io.*;  

5.  class MuLei{  

6.      private BufferedReader br=null;  

7.      public MuLei(){  

8.          br=new BufferedReader(new InputStreamReader(System.in));  

9.      }  

10.    public int fun(String str){  

11.        System.out.println(str);  

12.        int a=0;  

13.        try{  

14.            a=Integer.parseInt(br.readLine());  

15.        }catch(Exception e){  

16.            System.out.println("请输入一个整数！");  

17.            fun(str);  

18.        }  

19.        return a;  

20.    }  

21.    public void add(int a,int b){  

22.        System.out.printf("%s+%s=%s",a,b,(a+b));  

23.    }  

24.}  

25.  

26.  

27.  

28.  

29.第二个JAVA文件：  

30.  

31.  

32.public int fun(String str){  

33.        System.out.println(str);  

34.        int a=0;  

35.        try{  

36.            a=Integer.parseInt(br.readLine());  

37.        }catch(Exception e){  

38.            System.out.println("请输入一个整数！");  

39.            return fun(str);//注意这里，把函数的返回值要赋给a，不然a就还是初始值0。  

40.        }  

41.        return a;  

42.    }  

 

58.java中的静态块、非静态块
     java中经常有一些静态块，这是用来在生成类之前进行的初始化，无论java还C++中的static，都是最先初始化好的。 

凡是声明为static的语句（变量，方法，代码块），是在加载类的时候就执行的 
在这个类第一次被调用或实例化的时候就会被执行。 
静态代码块只会执行一次，一般会用来初始化一些值，并且在所有对象中全局共享。 
所以注意： 
（1）在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法），而不 

能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创 

建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。 

（2） 静态方法不能以任何方式引用this和super关键字，因为静态方法在使用前 

不用创建任何实例对象，当静态方法调用时，this所引用的对象根本没有产生， 

至于非静态块是存在每一个类中，除了带有static块以外，它最先执行，（在构 

造函数前）下面是一个例子。 

（3）类装载步骤 
   在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备和解析三步，除了解析外，其它步骤是严格按照顺序完成的，各个步骤的主要工作如下： 
装载：查找和导入类或接口的二进制数据； 
链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的； 
校验：检查导入类或接口的二进制数据的正确性； 
准备：给类的静态变量分配并初始化存储空间； 
解析：将符号引用转成直接引用； 
初始化：激活类的静态变量的初始化Java代码和静态Java代码块。 
初始化类中属性是静态代码块的常用用途，但只能使用一次。 
（简单来讲就是项目加载的时候就执行静态代码块，你想了解更清楚的话就写点代码测试一下） 

Java代码  

1.  public class text {   

2.    

3.   public int a;   

4.    

5.   {   

6.    

7.    System.out.println("非静态2");   

8.    

9.   }   

10.  

11. static{   

12.  

13.   System.out .println("static");   

14.  

15. }   

16.  

17. text(){   

18.  

19.  System.out.println("text");   

20.  

21. }   

22.  

23.}   

24.  

25.public class text1 extends text{   

26.  

27.public int t;   

28.  

29.public double w;   

30.  

31.{   

32.  

33. System.out.println("非静态块");   

34.  

35.}   

36.  

37.static {   

38.  

39. System.out.println("static1");   

40.  

41.}   

42.  

43.public text1(){   

44.  

45. System.out.println("text1");   

46.  

47.}   

48.  

49.public static void main(String args[]){   

50.  

51. text1 te=new text1();   

52.  

53.}   

54.  

55.}   

56.  

57.结果是：   

58.  

59.static static1   

60.  

61.非静态2   

62.  

63.text   

64.  

65.非静态块   

66.  

67.text1