`

java类浏览器

浏览器JavaSwingCC++ 
阅读更多 
package treeroot.reflect;

import java.util.List;
public interface Node {
 int CLASS=0x10000;
 int INTERFACE=0x01000;
 int CONSTRUCTOR=0x00100;
 int METHOD=0x00010;
 int FIELD=0x00001; 
 void setChilds(List childs);
 boolean hasChild();
 List getChilds();
 String getName();
 String getDetail();
 int getType();
 
 //in order to sort
 int getOrder();
}



package treeroot.reflect;

import treeroot.reflect.Node;
import java.util.List;
import java.lang.reflect.Method;

public class MethodNode implements Node {
 
 private int order;
 private Method m;
 public MethodNode(Method m){
  this(m,0);
 }
 public MethodNode(Method m,int order){
  this.m=m;
  this.order=order;  
 }

 /**
  * Method setChilds
  *
  *
  * @param parm1
  *
  */
 public void setChilds(List parm1) {
  throw new UnsupportedOperationException("MothodNode has no child!");
  // TODO: Add your code here
 }

 /**
  * Method hasChild
  *
  *
  * @return
  *
  */
 public boolean hasChild() {
  return false;
  // TODO: Add your code here
 }

 /**
  * Method getChilds
  *
  *
  * @return
  *
  */
 public List getChilds() {
  throw new UnsupportedOperationException("MothodNode has no child!");
  // TODO: Add your code here
 }

 /**
  * Method getName
  *
  *
  * @return
  *
  */
 public String getName() {
  return m.getName()+ Helper.getParams(getDetail());
  // TODO: Add your code here
 }

 /**
  * Method getDetail
  *
  *
  * @return
  *
  */
 public String getDetail() {
  return m.toString();
  // TODO: Add your code here
 }

 /**
  * Method getType
  *
  *
  * @return
  *
  */
 public int getType() {
  return METHOD;
  // TODO: Add your code here
 }

 /**
  * Method getOrder
  *
  *
  * @return
  *
  */
 public int getOrder() {
  return order;
  // TODO: Add your code here
 } 
 public String toString(){
  return getName();
 }
}



package treeroot.reflect;

import treeroot.reflect.Node;
import java.util.List;
import java.lang.reflect.*;
public class InterfaceNode implements Node {
 
 private Class c;
 private int order;
 private List childs;
 
 public InterfaceNode(Class c){
  this(c,0);
 }
 
 public InterfaceNode(Class c,int order){
  if(!c.isInterface()){
   throw new RuntimeException("InterfaceNode must accept a Interface!");
  }
  this.c=c;
  this.order=order;
 }
 
 /**
  * Method setChilds
  *
  *
  * @param parm1
  *
  */
 public void setChilds(List parm1) {
  this.childs=parm1;
  // TODO: Add your code here
 }

 /**
  * Method hasChild
  *
  *
  * @return
  *
  */
 public boolean hasChild() {
  return (childs!=null)&&(childs.size()>0);
  // TODO: Add your code here
 }

 /**
  * Method getChilds
  *
  *
  * @return
  *
  */
 public List getChilds() {
  return childs;
  // TODO: Add your code here
 }

 /**
  * Method getName
  *
  *
  * @return
  *
  */
 public String getName() {
  return c.getName();
  // TODO: Add your code here
 }

 /**
  * Method toString
  *
  *
  * @return
  *
  */
 public String toString() {
  return "<html><i>"+getName()+"</i></html>";
  // TODO: Add your code here
 }

 /**
  * Method getDetail
  *
  *
  * @return
  *
  */
 public String getDetail() {
  StringBuffer sb=new StringBuffer(Modifier.toString(c.getModifiers()));
  
  sb.append(c.getName());
  Class[] inters=c.getInterfaces();
  if(inters.length>0){
   sb.append(" implements ");
   for(int i=0;i<inters.length;i++){
    sb.append(inters[i].getName());
    sb.append(',');
   }
   sb.setLength(sb.length()-1);
  }
  return sb.toString();  
  
  
  // TODO: Add your code here
 }

 /**
  * Method getType
  *
  *
  * @return
  *
  */
 public int getType() {
  return INTERFACE;
  // TODO: Add your code here
 } 
 public int getOrder(){
  return order;
 }
}


package treeroot.reflect;

import treeroot.reflect.Node;
import java.util.List;
import java.lang.reflect.Modifier;
import java.lang.reflect.Field;

public class FieldNode implements Node {
 
 private int order;
 private int mode;
 private Field field;
 
 public FieldNode(Field field){
  this(field,0);
 }
 public FieldNode(Field field,int order){
  this.field=field;
  this.order=order;
 }
 
 /**
  * Method setChilds
  *
  *
  * @param parm1
  *
  */
 public void setChilds(List parm1) {
  throw new UnsupportedOperationException("Field can hava Child Nodes!");
  // TODO: Add your code here
 }

 /**
  * Method hasChild
  *
  *
  * @return
  *
  */
 public boolean hasChild() {
  return false;
  // TODO: Add your code here
 }

 /**
  * Method getChilds
  *
  *
  * @return
  *
  */
 public List getChilds() {
  //you should call the hasChild() to test.
  throw new UnsupportedOperationException("Field can hava Child Nodes!");
  // TODO: Add your code here
 }

 /**
  * Method getName
  *
  *
  * @return
  *
  */
 public String getName() {
  return field.getName();
  // TODO: Add your code here
 }

 

 /**
  * Method getDetail
  *
  *
  * @return
  *
  */
 public String getDetail() {
  return field.toString();
  // TODO: Add your code here
 }

 /**
  * Method getType
  *
  *
  * @return
  *
  */
 public int getType() {
  return FIELD;
  // TODO: Add your code here
 } 
 
 
 public int getOrder(){
  return order;
 }
 public String toString(){
  return getName();
 }
}



package treeroot.reflect;

import treeroot.reflect.Node;
import java.util.List;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

public class ConstructorNode implements Node {
 
 private Constructor con;
 private int order;
 
 public ConstructorNode(Constructor con){
  this(con,0);
 }
 public ConstructorNode(Constructor con,int order){
  this.con=con;
  this.order=order;
 }
 /**
  * Method setChilds
  *
  *
  * @param parm1
  *
  */
 public void setChilds(List parm1) {
  throw new UnsupportedOperationException("ConstructorNode has no child!");
  // TODO: Add your code here
 }

 /**
  * Method hasChild
  *
  *
  * @return
  *
  */
 public boolean hasChild() {
  return false;
  // TODO: Add your code here
 }

 /**
  * Method getChilds
  *
  *
  * @return
  *
  */
 public List getChilds() {
  throw new UnsupportedOperationException("ConstructorNode has no child!");
  // TODO: Add your code here
 }

 /**
  * Method getName
  *
  *
  * @return
  *
  */
 public String getName() {
  return con.getName()+ Helper.getParams(getDetail());
  // TODO: Add your code here
 }

 /**
  * Method getDetail
  *
  *
  * @return
  *
  */
 public String getDetail() {
  return con.toString();
  // TODO: Add your code here
 }

 /**
  * Method getType
  *
  *
  * @return
  *
  */
 public int getType() {
  return CONSTRUCTOR;
  // TODO: Add your code here
 }

 /**
  * Method getOrder
  *
  *
  * @return
  *
  */
 public int getOrder() {
  return order;
  // TODO: Add your code here
 } 
 public String toString(){
  return getName();
 }
}


package treeroot.reflect;

import treeroot.reflect.Node;
import java.util.List;
import java.lang.reflect.*;
public class ClassNode implements Node {
 
 private Class c;
 private int order;
 private List childs;
 
 public ClassNode(Class c){
  this(c,0);
 }
 public ClassNode(Class c,int order){
  if(c.isInterface()||c.isArray()||c.isPrimitive()){
   throw new RuntimeException("ClassNode must accept a Class!");
  }
  this.c=c;
  this.order=order;
 }
 
 
 /**
  * Method setChilds
  *
  *
  * @param parm1
  *
  */
 public void setChilds(List parm1) {
  this.childs=parm1;
  // TODO: Add your code here
 }

 /**
  * Method hasChild
  *
  *
  * @return
  *
  */
 public boolean hasChild() {
  return (childs!=null)&&(childs.size()>0);
  // TODO: Add your code here
 }

 /**
  * Method getChilds
  *
  *
  * @return
  *
  */
 public List getChilds() {
  return childs;
  // TODO: Add your code here
 }

 /**
  * Method getName
  *
  *
  * @return
  *
  */
 public String getName() {
  return c.getName();
  // TODO: Add your code here
 }

 /**
  * Method toString
  *
  *
  * @return
  *
  */
 public String toString() {
  return "<html><b>"+getName()+"</b></html>";// TODO: Add your code here
 }

 /**
  * Method getDetail
  *
  *
  * @return
  *
  */
 public String getDetail() {
  StringBuffer  sb=new StringBuffer(Modifier.toString(c.getModifiers()));
  sb.append(" ");
  sb.append(c.getName());
  Class superClass=c.getSuperclass();
  
  if(superClass!=null){
   sb.append(" extends ");
   sb.append(superClass.getName());
  }
  
  Class[] inters=c.getInterfaces();
  
  if(inters.length>0){
   sb.append(" implements ");
   for(int i=0;i<inters.length;i++){
    sb.append(inters[i].getName());
    sb.append(',');
   }
   sb.setLength(sb.length()-1);
  }
  return sb.toString();  
 }

 /**
  * Method getType
  *
  *
  * @return
  *
  */
 public int getType() {
  return CLASS;
  // TODO: Add your code here
 }
 public int getOrder(){
  return order;
 } 
}


package treeroot.reflect;

class Helper {
 static String getParams(String s){
  return s.substring(s.indexOf('('),s.indexOf(')')+1);  
 }
}


package treeroot.reflect;

import java.util.*;
import java.lang.reflect.*;
public class ClassMeta {
 public static Node getClassTree(Class c){
  //
  Node root;
  if(c.isInterface()){
   root=new InterfaceNode(c);
  }
  else{
   root=new ClassNode(c);
  }
  List childs=new ArrayList();
  
  //add super class as first node,if the class if Object.class,break recursion.
  //only Class has the superClass.

   
  Class superClass=c.getSuperclass();
  if(superClass!=null)
   childs.add(getClassTree(superClass));
  
  //add the inteferaces 
  //Class or Interface must have the Interfaces
    
  Class[] inters= c.getInterfaces();
  for(int i=0;i<inters.length;i++){
   childs.add(getClassTree(inters[i]));
  }
  
  //add the constructors
  //Only Class have the Constructors.
  
  Constructor[] cons=c.getConstructors();
  for(int i=0;i<cons.length;i++){   
   childs.add(new ConstructorNode(cons[i]));
  }
  
  
  //add the methods
  Method[] methods=c.getDeclaredMethods();
  for(int i=0;i<methods.length;i++){
   childs.add(new MethodNode(methods[i]));
  }
  
  
  //add the fields
  Field[] fields=c.getDeclaredFields();
  for(int i=0;i<fields.length;i++){
   childs.add(new FieldNode(fields[i])); 
  }
  root.setChilds(childs);
  return root;
 }
 
}


//以下是图形界面了

package treeroot.classviewer;

import treeroot.reflect.Node;
import treeroot.reflect.ClassMeta;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.List;
import java.util.*;
import javax.swing.tree.*;
import javax.swing.event.*;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.JScrollPane;


public class ClassViewer extends JPanel {
 JTree tree;
 DefaultTreeModel model;
 JPanel detail=new JPanel();
 JLabel lbl=new JLabel("the Detail Message");
 private DefaultMutableTreeNode getRoot(Node node){
  DefaultMutableTreeNode root=new DefaultMutableTreeNode(node);
  if(node.hasChild()){
  
   List childs=node.getChilds();
   for(int i=0;i<childs.size();i++){ 
    root.add(getRoot((Node)childs.get(i)));
   }
  }
  return root;  
 }
 public ClassViewer(){
  DefaultMutableTreeNode root=getRoot(ClassMeta.getClassTree(Object.class));
  model=new DefaultTreeModel(root);
  tree=new JTree(model);
  TreeSelectionModel selectModel =new DefaultTreeSelectionModel();
  selectModel.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  tree.setSelectionModel(selectModel);
  tree.addTreeSelectionListener(new TreeSelectionListener(){
   public void valueChanged(TreeSelectionEvent e){
    DefaultMutableTreeNode node=(DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
    if(node!=null){
     Node n=(Node)node.getUserObject();
     lbl.setText(n.getDetail());
    }
   }
  }
  );
  this.setLayout(new BorderLayout());
  this.add(new JScrollPane(tree),BorderLayout.CENTER);
  detail.add(lbl);
  this.add(detail,BorderLayout.SOUTH);
 }
 void setTree(Node treeRoot){
  DefaultMutableTreeNode root=getRoot(treeRoot);
  model=new DefaultTreeModel(root);
  tree.setModel(model);
  this.updateUI();
 }
}

package treeroot.classviewer;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.JOptionPane;
import treeroot.reflect.*;
import javax.swing.tree.*;

public class MainFrame extends JFrame{
 private JTextField txtClass=new JTextField("java.lang.Object",20);
 private JButton btnClass=new JButton("confirm");
 private JPanel topPanel=new JPanel();
 ClassViewer tree=new ClassViewer();
 public MainFrame(){
  this.setTitle("Class Viewer");
  
  Toolkit kit=Toolkit.getDefaultToolkit();
  Dimension d=kit.getScreenSize();
  int width=d.width;
  int height=d.height;
  
  this.setLocation((width-WIDTH)/2,(height-HEIGHT)/2);  
  this.setSize(WIDTH,HEIGHT);
  //this.setResizable(false);
  
  topPanel.add(txtClass);
  topPanel.add(btnClass);
  btnClass.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e){
    Class c=null;
    try{
     String cls=txtClass.getText().trim();
     c=Class.forName(cls);
    }
    catch(ClassNotFoundException ex){
     JOptionPane.showMessageDialog(null,"can find the class!");
     return;
    }
    Node root=ClassMeta.getClassTree(c); 
    tree.setTree(root);
   }
  }
  );
  this.getContentPane().add(topPanel,BorderLayout.NORTH);
  this.getContentPane().add(tree,BorderLayout.CENTER);
 }
 
 public static void main(String[] args){
  MainFrame main=new MainFrame();
  //main.pack();
  main.show();
 }
 private static int WIDTH=800;
 private static int HEIGHT=600;
 
}

 


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/treeroot/archive/2004/12/29/232826.aspx

分享到：
| Java NIO 拷贝文件（使用compact）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java实现内置浏览器

    Java实现内置浏览器是一种技术实践，它允许开发者在Java应用程序中集成一个Web浏览器组件，使得用户可以在应用程序内部浏览网页，提供类似桌面应用的体验。这种方式通常使用JavaFX或Swing库来构建用户界面，并通过...

    Java 浏览器 Java浏览器

    总的来说，"Java浏览器"项目不仅展示了Java在创建复杂应用程序时的能力，还为Java开发者提供了一个实践多线程、网络编程、UI设计和安全策略的绝佳案例。通过深入研究和改进这样的项目，Java开发者可以提升自己的技能...

    漂亮的java嵌套浏览器IE，chrome

    Java内嵌浏览器是一种在Java应用程序中集成Web浏览功能的技术，使得用户可以在不离开主应用界面的情况下访问和交互网页。在给定的标题“漂亮的java嵌套浏览器IE，chrome”中，我们可以看出这是关于一个Java库，它...

    java模拟浏览器访问网站

    用java模拟访问浏览网站的代码，可以输出各种网页属性，以及html源代码

    基于java的浏览器的设计与实现课程设计.pdf

    【基于Java的浏览器设计与实现】是一门课程设计，旨在让学生通过使用Java语言在Eclipse环境中构建一个Web浏览器，以实现基本的浏览功能，并在Windows操作系统上运行。这个设计涵盖了图形界面设计和底层功能实现两个...

    java图片浏览器java图片浏览器

    java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java图片浏览器java...

    Java嵌入谷歌内核简单浏览器

    标签"java-cef"、"Java浏览器"和"java谷歌"暗示了这个项目是关于Java环境下利用CEF实现的浏览器功能，特别强调了与谷歌技术的结合。因此，开发者应当熟悉Java编程，了解CEF框架，以及谷歌的Web技术标准。在实践中，...

    java 网页浏览器开发

    在Java编程领域，开发一款网页浏览器是一项挑战性的任务，它涉及到网络通信、用户界面设计、渲染引擎等多个核心组件。下面将详细阐述这个项目所涵盖的关键知识点。 首先，我们需要理解Java的基础，包括类、对象、...

    超漂亮的纯JAVA浏览器

    标题中的“超漂亮的纯JAVA浏览器”指的是一个基于Java语言开发的网页浏览应用，它具有出色的用户界面设计，提供了良好的视觉体验。这样的浏览器通常利用Java的跨平台特性，可以在多种操作系统上运行，包括Windows、...

    JCB-使用WTL用C ++编写的Java类浏览器

    标题中的“JCB-使用WTL用C++编写的Java类浏览器”指的是一个软件项目，该项目采用Microsoft的Windows Template Library (WTL)框架，用C++编程语言实现了对Java类的浏览功能。WTL是一个轻量级的库，主要用于开发...

    java简易自制浏览器

    java简易自制浏览器 java简易自制浏览器 java简易自制浏览器 java简易自制浏览器 java简易自制浏览器 java简易自制浏览器

    java的图片浏览器

    Java 图片浏览器是一种基于Java编程语言开发的应用程序，主要用于查看和浏览存储在计算机中的图片文件。这个应用提供了基本的图片浏览功能，如打开指定目录、上下翻页以及自动播放和停止播放图片。以下是对这些核心...

    java嵌入浏览器JxBrowser6.21

    Java嵌入浏览器技术是将一个完整的网页浏览功能集成到Java应用程序中的方法，使得开发者可以在Java应用内部展示网页、实现Web应用交互。JxBrowser是一款专为此目的设计的库，它提供了一个API，允许Java开发者轻松地...

    Java 图片浏览器 源码

    Java 图片浏览器 源码，实现简单的图片浏览的功能，代码简洁，容易懂的。

    Java实现浏览器CA证书的签名和验证

    Java提供了丰富的API来处理证书的生成、签名、验证等操作，包括但不限于使用Java Cryptography Architecture (JCA) 和 Java Cryptography Extension (JCE)。 在Java中，可以使用keytool工具来生成自签名证书，或者...

    Java简单浏览器源代码

    Java简单浏览器源代码是基于Java Swing库和Socket编程技术实现的一款基础浏览应用，它为开发者提供了一个学习和理解网络浏览器工作原理的实例。这个项目主要包含以下几个关键知识点： 1. **Java Swing**: Java ...

    Java网页浏览器

    5. **安全机制**：考虑到网络安全，Java浏览器需要有安全策略来防止恶意代码。Java内置了沙箱机制，限制了未经许可的系统访问，同时还可以利用SSL/TLS协议确保数据传输的安全性。 6. **缓存机制**：为了提高加载...

    java 内嵌浏览器 DJNativeSwing

    java 内嵌浏览器 DJNativeSwing，可实现内嵌浏览器，提高用户体验。

    java制作的浏览器

    2. JavaScript引擎：Java浏览器通常会包含一个JavaScript引擎，如OpenJDK的HotSpot或Mozilla的Rhino，用于执行网页中的JavaScript代码。JavaScript引擎使浏览器能够与用户交互、处理动态内容和执行服务器请求。 3. ...

    Java-Swing嵌入浏览器（本地浏览器和webkit浏览器-火狐内核）

    这个压缩包文件“Java-Swing嵌入浏览器（本地浏览器和webkit浏览器-火狐内核）”显然提供了一个实现这一功能的示例，主要涉及到的技术是DJnative-SWT和SWT。 DJnative-SWT 是一个开源项目，它的目标是将Java和...

Magicbox
Global site tag (gtag.js) - Google Analytics