各种笔试，面试，打酱油

       最近各种笔试、面试，发现自己的一个问题就是对一些概念性的知识很模糊，故在这总结一下在笔试、面试中遇到的问题：

1：有很多旅游地点，需要以树型方式先存储，然后依次访问每个节点，不能重复访问，而且每个节点的一级子节点数目是不确定的（可能还有无数个节点没有画出来），写出相应算法。

      

这一句话：而且每个节点的一级子节点数目是不确定的（可能还有无数个节点没有画出来），主要问题是如何为地点的存储写一个通用的方法，每个节点的子节点数目及信息是动态变化的，也就是说要将每个节点的一级子节点作为参数。如果按普通的想法，一个子节点的写一个方法；两个子节点的需再写一个方法；三个......这太可怕了。在java中，可以通过如下方式传入不定数目的参数：Object ... o。编译器会把参数存储在数组o中

public class TreeNode {

    private TreeNode[] nodes = null;
    private Object data;

    public TreeNode(Object data,TreeNode ... node){
        if(node !=null && node[0] != null){//这一句非常重要，如果传入的参数为null，则node[0]==null
            int size = node.length;
            nodes = new TreeNode[size];
            System.arraycopy(node, 0, nodes, 0, size);
        }
        this.data = data;
    }

    public Object getData() {
        return data;
    }

    public TreeNode[] getNodes() {
        return nodes;
    }
}

 public TreeNode getNode(Object item, TreeNode... node) {  
        TreeNode no = new TreeNode(item, node);  
        return no;  
    }

public TreeNode createTree() {  
        TreeNode d, e, f, g, h, i, j, k, l, m, n, o;  
        o = getNode("台湾", (TreeNode) null);  
        n = getNode("澳大利亚", (TreeNode) null);  
        m = getNode("夏威夷", (TreeNode) null);  
        l = getNode("加拿大", (TreeNode) null);  
        k = getNode("纽约", (TreeNode) null);  
        j = getNode("巴西", (TreeNode) null);  
        f = getNode("非洲", (TreeNode) null);  
        e = getNode("伦敦", m,n,o);  
        d = getNode("巴黎", l);  
        i = getNode("鼓浪屿", j,k);  
        h = getNode("拉塞", d,e,f);  
        g = getNode("北京", h,i);       
        return g;  
    }  
  
/** 
     * 任意结点树的前序递归遍历 
     * @param treeNode 
     */  
    public void preorderTraverse_anynode(TreeNode treeNode) {  
        if (treeNode == null) {  
            throw new NullPointerException("树结点为空");  
        }  
        System.out.print(treeNode.getData()+" ");  
        TreeNode[] nodes = treeNode.getNodes();  
        if (nodes != null) {//检查是否是叶子结点，如果为null，则是叶子结点  
            for (int i = 0; i < nodes.length; i++) {×  
                preorderTraverse_anynode(nodes[i]);  
            }  
        }  
    }

2：从长度为m的字符串中任意取出n个字符。见http://blog.csdn.net/gaopo_y/article/details/8082084

3：一个矩形由X×Y个正方形组成。问这个矩形中共有多少个正方形

/**
	 * 假设X大于或等于Y；反之，将函数中的X、Y位置互换即可
	 * @param X
	 * @param Y
	 * @return
	 */
	public static int count(int X, int Y) {
		int count = 0;
		for (int i = 0; i < Y; i++) {
			for (int j = 0; j < X; j++) {
				int c = 0;
				int m = X - j;
				int n = Y - i;
				if (i == Y - 1 || j == X - 1) {
					c = 1;
				} else if (m < Y && m < n) {
					c = m;
				} else {
					c = n;
				}
				count += c;
			}
		}
		return count;
	}

4：java类方法和实例方法以及类变量和实例变量各种区别

一、用static修饰的是类方法。

二、对于类方法，在该类被加载到内存时，就分配了相应的入口地址。从而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。类方法的入口地址直到程序退出才被取消。

三、当类的字节码文件被加载到内存时，类的实例方法不会被分配入口地址，当该类创建对象后，类中的实例方法才分配入口地址，从而实例方法可以被类创建的任何对象调用执行。需要注意的是，当我们创建第一个对象时，类中的实例方法就分配了入口地址，当再创建对象时，不再分配入口地址，也就是说，方法的入口地址被所有的对象共享，当所有的对象都不存在时，方法的入口地址才被取消。

四、类方法在类的字节码加载到内存时就分配了入口地址，因此，Java语言允许通过类名直接调用类方法，而实例方法不能通过类名调用。在讲述类的时候我们强调过，在Java语言中，类中的类方法不可以操作实例变量，也不可以调用实例方法，这是因为在类创建对象之前，实例成员变量还没有分配内存，而且实例方法也没有入口地址。

a、用static修饰的变量是类变量。

b、一个类通过使用new运算符可以创建多个不同的对象，这些对象将被分配不同的内存空间，说得准确些就是：不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其它对象的这个类变量。也就是说对象共享类变量。

c、当Java程序执行时，类的字节码文件被加载到内存，如果该类没有创建对象，类的实例成员变量不会被分配内存。但是，类中的类变量，在该类被加载到内存时，就分配了相应的内存空间。如果该类创建对象，那么不同对象的实例变量互不相同，即分配不同的内存空间，而类变量不再重新分配内存，所有的对象共享类变量，即所有的对象的类变量是相同的一处内存空间，类变量的内存空间直到程序退出运行，才释放所占有的内存。Java语言允许通过类名直接访问类变量。