【java】基础中的杂乱总结（一）

1 构造代码块

作用：给对象进行初始化。对象一建立就运行，并且优先于构造函数执行

构造函数是给所有对象进行统一初始化，构造函数是给对应的对象初始化

package package1;

class Person{
    private String name;

    {
        System.out.println("person code run");
    }

    Person(){
        System.out.println("name="+name);
        cry();
    }

    Person(String name){
        this.name = name;
        System.out.println("name="+name);
        cry();
    }

    public void cry(){
        System.out.println("crying");
    }
}

public class Test1 {
    public static void main(String[] args){
        Person p = new Person();
        Person p1 = new Person("tom");
    }
}

结果：

person code run
name=null
crying
person code run
name=tom

2 javadoc 注释文档的制作（以数组ArrayTool为例）

package package1;

/**
 * 这是一个对数组操作的工具类事例，提供最值，排序等功能
 * @author balfish_ac
 * @version V1.1
 *
 */

public class ArrayTool {
    private ArrayTool(){}

    /**
     * 获取最大值
     * @param arr 接收int类型的数组
     * @return 返回一个该数组中最大值
     */
    public static int getMax(int[] arr){
        int max = 0;
        for(int i=1; i<arr.length; i++){
            if(arr[i] > arr[max]){
                max = i;
            }
        }
        return arr[max];
    }

    /**
     * 选择排序
     * @param arr
     */
    public static void selectSort(int[] arr){
        for(int i=0; i<arr.length-1; i++){
            for(int j=i+1; j<arr.length; j++){
                if(arr[i] > arr[j]){
                    swap(arr,i,j);
                }
            }
        }
    }

    /**
     * 冒泡排序
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        for(int i=0; i<arr.length-1; i++){
            for(int j=0; j<arr.length-i-1; j++){
                if(arr[j] > arr[i+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }
    /**
     * 位置置换
     * @param arr
     * @param a 要置换的位置
     * @param b 要置换的位置
     */
    private static void swap(int[] arr, int a, int b){
        int tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
    }

    /**
     * 打印数组中的元素
     * @param arr
     */
    public static void printArray(int[] arr){
        for(int i=0; i<arr.length; i++){

        }
    }

}

命令行：javadoc -d mydoc -author -version ArrayTool.java

myeclipse： 项目上点右键-export-java-javadoc  即可（自己选路径）

3 静态代码块 , 构造代码块 , 构造函数 的执行顺序

package package1;

class StaticCode{
    StaticCode(){
        System.out.println("b");
    }

    static{
        System.out.println("a");
    }

    {
        System.out.println("c");
    }

    StaticCode(int x){
        System.out.println("d");
    }

}

public class Test1 {
    public static void main(String[] args){
        StaticCode s = new StaticCode(1);
    }
}

运行结果：

a
c
d

静态代码块 > 构造代码块 > 构造函数

4 Person p = new Person("zhangsan",20);

这句话都做了什么事情？

（1）因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中

（2）执行该类中的static代码块，如果有的话，给Person.class类进行初始化

（3）在堆内存中开辟空间，分配内存地址

（4）在堆内存中建立对象的特有属性，并进行默认初始化

（5）对属性进行显示初始化

（6）对对象进行构造代码初始化

（7）对对象进行对应的构造函数初始化

（8）将内存地址赋给栈内存的p变量

5 内部类相关

static的内部类行为上象一个独立的类，非static的内部类在行为上类似类的属性或方法且禁止声明static的方法。

内部类可以访问外部类的所有方法与属性，但static的内部类只能访问外部类的静态属性与方法。

/*
 * 内部类的访问规则：
 * 1 内部类可以直接访问外部类中的成员，包括私有，
 *    之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式为 外部类名.this
 * 2 外部类要访问内部类，必须建立内部类对象

 */

package package1;

class Outer{
    private int x = 3;
    class Inner{
        int x = 4 ;
        void function(){
            int x = 6;
            System.out.println("Inner: "+Outer.this.x);
            System.out.println("Inner: "+x);
        }
    }

    void method(){
            Inner in = new Inner();
            in.function();
    }
}

public class Test8 {
    public static void main(String[] args){
        Outer out = new Outer();
        out.method();
        System.out.println("-------------------------");
        //直接访问内部类中的成员
        Outer.Inner in = new Outer().new Inner();
        in.function();

    }
}

运行结果：

Inner: 3
Inner: 6
-------------------------
Inner: 3
Inner: 6

6 Iterator迭代器相关

（1）Iterator迭代器只有next，hasNext，remove方法，如果要获得其他方法且（在List接口子类情况下） 可以使用子接口ListIterator

（2）迭代时不能够再访问迭代中的framework，由于迭代引用已经指向框架对象，再有操作会有同步问题

（3）在一次的Iterator的迭代过程中不要出现两次it.next()，原因见下程序

package package1;
import java.util.ArrayList;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
//        al.add("java03");

        Iterator it = al.iterator();
        while(it.hasNext()){
            System.out.println(it.next() + "------" +  it.next());
        }
    }
}

运行结果：throw new NoSuchElementException(); 不是成对出现的，注释去掉可以运行通过  （正常取一次判断一次而现在是取两次才判断）

7 HashSet相关

注意Hash相关的集合框架要覆写equals和hashCode，一定要注意和Object的参数列表相同，否则不是覆写。

另外， 判重只有HashCode值相同，才会判断equals！！！

package package1;
import java.util.HashSet;
import java.util.Iterator;

/*
 * HashSet保证元素唯一性的方法是：hashCode和equals方法
 * 如果元素的HashCode值相同，才会判断equals是否为true
 */
class Person{
    private String name;
    private int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "("+name+":"+age+")";
    }

    public int hashCode(){

        System.out.println(this.name+"...hashCode");
//        return 30;    标记1
        return name.hashCode() + age * 37;   //标记2
    }

    public boolean equals(Object obj){
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        System.out.println(this.name+ "...equals..." + p.name);
        return this.name.equals(p.name)&&this.age==p.age;
    }
}

public class Test {
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<Person>();
        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));

        Iterator it = hs.iterator();
        while(it.hasNext()){
            Person p = (Person) it.next();
            System.out.println(p.getName() + "::" + p.getAge());
        }
    }
}

运行结果：

采用标记1：

a1...hashCode
a2...hashCode
a2...equals...a1
a3...hashCode
a3...equals...a2
a3...equals...a1
a2...hashCode
a2...equals...a3
a2...equals...a2
a3::13
a2::12
a1::11

采用标记2：

a1...hashCode
a2...hashCode
a3...hashCode
a2...hashCode
a2...equals...a2
a1::11
a3::13
a2::12

8 Arrays工具类的asList方法

把数组变成list集合，可以使用集合的思想和方法来操作数组中的元素

注意，使用asList时，不能使用集合的增删方法，因为数组的长度是固定的

而indexOf，contains，get什么的方法都没问题

package package1;

import java.util.Arrays;
import java.util.List;

public class Testhh {
     public static void main(String[] args) {
        String[] arr = {"abc" , "cc" , "kkkk"};    

        List<String> list = Arrays.asList(arr);
        System.out.println("contains:" + list.contains("cc"));

     //    list.add("qq"); //UnsupportedOperationException
        System.out.println(list);
     }
}

运行结果：

contains:true
[abc, cc, kkkk]

（若加注释抛出异常）

9 可变参数

其实就是数组参数的简写形式，不用每一次都手动建立数组对象，只要将要操作的元素作为参数传递即可，隐式地将参数封装为数组

注意：可变参数一定在参数列表的最后，防止冲突（放前面默认把后面的参数也当做可变参数接收 ）

package package1;

public class Testhh {
     public static void main(String[] args) {
        /*
         int[] arr1 = {2,3,4};
         show(arr1);

         int[] arr2 ={2,3};
         show(arr2);
         */

         show(2,3,4);
         System.out.println("--------------------------");
         show(2,3,4,5,6,7);
     }

     /*
     public static void show(int[] arr){
         System.out.println(arr);
     }
     */

     public static void show(int... arr){
         for(int i=0 ; i<arr.length ; i++){
             System.out.println(arr[i]);
         }
     }

}

运行结果：

2
3
4
--------------------------
2
3
4
5
6
7

10 静态导入

如 import java.lang.System.*;  导入所有System类的静态成员

下面以Arrays为例说明。

package package1;

import static java.util.Arrays.*;
import  java.util.*;

import java.util.Arrays;

public class Testhh {
     public static void main(String[] args) {
         int[] arr = {3 , 1 , 5};
         sort(arr);
         int index = binarySearch(arr , 1);
         System.out.println(Arrays.toString(arr));  //不可省略Arrays,与Oeject的成员方法toString冲突
         System.out.println("index=" + index);
     }

}

运行结果：

[1, 3, 5]
index=0