java基础中的技巧

eclipse软件操作

　　1.1.在一个项目里，一般将源代码放到src目录下。

　　1.2.不知道某个类所在的包？把鼠标指针放到该类名下，系统会提示import这个类所在的包。

　　1.3.自动生成get，set方法？选中变量后，右键，source/generate setters and getters。

　　1.4.Ctrl+左键，直接进入方法的实现。

注释

　　1.1.java中两种注释/* */和/** */有什么关系？

　　　　/* */只代表单纯的注释 。
　　　　/** */ 不仅有注释的功效而且你鼠标放在你注释的方法上面他会把你注释的内容显示出来，还能生成标准的api注解。如何生成api注解，需要进一步学习。。。

　

控制流

　　1.1.在判断语句里，不能用0代表false；非0代表true。

　　1.2.for，switch大括号一般不新起一行。例如：

　　　　

        switch (score)  {
            case "A":
                print(4, "(80,100)");
                break;
            case "B":
                print(5, "(60,80)");
                break;
        }

 　　1.3.简化版顺序for循环：

　　　　例如：

　　　　

        String s = "fdsfds";
        for (char c : s.toCharArray()) {
            print(1, c);
        }

类

　　1.1.写main函数的技巧？

　　　　因为文件名必须与public类名相同，因此可以将类名和文件名改为Main，这样在项目里面比较好找这个main文件。

　　1.2.静态函数的调用要求？

　　　　静态函数是属于类的方法，不是对象的方法。因此静态函数只能调用静态函数。

　　　　因此，由于main函数是静态的，则main函数只能调用其他static静态函数了。

　　　　1.2.1.为何main是静态函数？

　　　　　　传送门

　　1.3.object类对象的使用技巧？

　　　　因为object类是任何类的超类。因此，可以将任意类型的值赋给object对象，需要时，再强制转换过来。

 　　　　例如：

　　　　　　

public static void print(int index, Object obj)
    {
        System.out.println(String.format("{%d}, %s",index, obj.toString()));
    }

 　　　　　　这样，任意类型的变量传给obj对象时，通过Object.toString函数可以将object类型转为String类型。

 　　1.4.尝试某些语法的技巧？

　　　　以前，我总喜欢在main函数中写一些语法的代码。但是这样会导致冗余，其实有更好的办法。那就是在另外一个函数里面测试语法，封装成函数后，给main函数调用，这样main函数就会很简洁了。

　　　　例如：

　　　　　　

public static void testDemo()
    {
        print(1,2);
        print(2,'c');
        print(3,"fdsf");
        print(4,2.3);
    }

　　　　这样，直接在main中调用testDemo就可以完成测试，非常简洁。

　　　1.5.String类是用的最多的。

　　　　　常量池，栈，堆，详解传送门

　　　　　　　　注意：常量区的内容只有一份，在编译时确定，例如：“hello"和"he"+"llo"在常量区中，在编译时确定，只有一份。

　　　　　String类使用技巧传送门

　　　　　三个String类使用技巧传送门2

　　　　　总结：==号比较的是引用中存储的地址。若一个在常量区，一个在堆区，肯定不相等。

　　　　　　　　equals比较的是引用所指的内容。只要内容相同，无所谓数据在哪个地方。

　　　1.6.抽象类与接口。

　　　　　1.6.1.概念解释传送门

　　　　　1.6.2.接口与多态传送门

　　　　　a)若一个普通类实现了接口，那么，该普通类必须实现接口中所有的抽象方法。
　　　　　b)若一个抽象类实现了接口，那么，该抽象类可以实现接口中的抽象方法，也可以不实现。
　　　　　c)若一个普通的子类继承了抽象父类，该抽象的父类又实现了接口。那么，该普通的子类必须得重写，抽象父类中所有的抽象方法，并且，还必须得实现抽象的父类尚未实现的抽象方法。

　　　　1.6.3.implements 和 extends的区别？

　　　　　　implements表示执行，需要具体实现。

　　　　　　extends表示扩展，跟继承实现一致。

　　1.7.随机数类

　　　　一般用到随机的场景为两个：random类和shuffle函数

　　　　1.7.1.random类

　　　　　　1.7.1.1.种子，产生的随机序列一致。因为有固定的公式。

　　　　　　　　

//种子为1，每次产生地随机数在100以内。
    public static void demoRandom() {
        Random rand = new Random(1);
        for (int i = 0;  i < 101; ++i)
            print(i, rand.nextInt(100));
    }

　　　　　　　　总结:加入固定种子以后，每次运行程序的结果一样。

　　　　　　　　

    public static void demoRandom() {
        Random rand = new Random();
        for (int i = 0;  i < 101; ++i)
            print(i, rand.nextInt(100));
    }

　　　　　　　　总结：加入随机种子以后，每次运行程序结果不一致。

　　　　　　1.7.1.2.技巧：每次存种子，就可以找到种子产生的序列，减少存储。

 　　　　1.7.2.shuffle

　　　　　　功能:打乱序列的排序。

　　　　　　例如：

　　　　　　　　

        List<Integer> array = Arrays.asList(new Integer[] {1, 2, 3});
        print(1, array);
        for (int i = 0; i < 9; ++i) {
            Collections.shuffle(array);
            print(2, array);
        }

 　　1.8.时间Date类

　　　　1.8.1使用DateFormat类自定义格式

　　　　　　　　

    public static void demoDate() {
        Date date = new Date();
        print(1, date);
        print(2, date.getTime());
        DateFormat df = new SimpleDateFormat("HH:mm:ss yyy/MM/dd");
        print(3, df.format(date));
    }

　　　　1.8.2.使用系统显示时间的格式

　　　　　　　　

print(4, DateFormat.getTimeInstance(DateFormat.FULL).format(date));

　　1.9.UUID

　　　　　1.9.1.随机产生32位的字符。

　　　　　　

UUID.randomUUID()

　　2.0.Math类也挺常用

　　　　

数据结构

　　数据结构基本分为：list列表，set集合，map键值对。　　

　　它们都是接口，以不同的逻辑方法实现，就变成了不同的类。例如，ArrayList类，HashMap类等等。

　　1.1.list

　　　　1.1.1.list里面可以放重复的元素。

　　　　1.1.2.在使用list列表时，可能要重写list排序算法，要使用匿名内部类。

　　　　　　基本概念传送门

　　　　　　代码例子：

　　　　　　

Collections.sort(strList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2)
            {
                return o2.compareTo(o1);
            }
        });

　　　　　　　　总结：由于comparator是接口，因此new的时候要实现，也就是重写。

　　　　1.1.3.经常也会用数组

　　　　　　

int[] intArray = new int[] {1,2,3};

 　　1.2.set

　　　　1.2.1.set元素不会重复。

　　1.3.map

　　　　1.3.1.去重。

　　　　1.3.2.快速查找。

异常

　　1.1.1不知道一部分代码有没有问题，可以把这些代码放在try块里，若抛出异常，用catch接住，finally进行善后工作，例如关闭文件，关闭流。

　　1.1.2.异常代码可以有两种形式。函数throw到外部或者函数内部触发。

　　　　1.1.2.1：函数内部触发异常。

　　　　　　

public static void demoException() {
        try  {
            int a = 1;
            String b = null;
            //b.indexOf("2");
            a = 1 / 0;
        }
        catch (NullPointerException npe) {
            print(1, "npe");
        }
        catch(Exception e) {
            print(2, "e");
        }
        finally {
            print(3, "done");
        }
    }

 　　　　　　总结：内部逻辑，内部解决。

　　　　1.1.2.2：函数throw到外部触发异常。　　　

　　　　　　

//即将被测试异常地代码
public static void demoException()  throws Exception {
            int a = 1;
            String b = null;
            //b.indexOf("2");
            a = 1 / 0;
    }

　　　　　　

public static void main(String args[])
    {
        try  {
            demoException();
        }
        catch (NullPointerException npe) {
            print(1, "npe");
        }
        catch(Exception e) {
            print(2, "e");
        }
        finally {
            print(3, "done");
        }
    }

 　　　　　　总结：在函数中专注于写代码，外部处理exception。

　　　　　　

包

　　包在java中类似于c++命名空间。

　　1.1.如何建立多层包？

　　　　传送门

　　　　注意：

　　　　每个包目录下面的文件，开头的格式都是package bag1.bag2.xxx.xxx...;　　表示这个文件在哪个包（目录）里面。不能随意修改和删除这个语句，要不然产生不匹配的错误。

　　　　在一个包（目录）下新建一个文件夹，那么这个文件夹就会变成子包。