Java基础，持续更新中~

Java Basics

java package 命名规范

• 个人的项目命名
  • indi:
    个体项目（individual），指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
    包名为"indi.发起者名.项目名.模块名.XXX"
  • onem:
    单人项目（one-man），推荐用indi，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
    包名为"onem.发起者名.项目名.模块名.XXX"
  • pers:
    个人项目（personal），指个人发起，独自完成，可分享的项目，copyright主要属于个人。
    包名为"pers.个人名.项目名.模块名.XXX"
  • priv:
    私有项目（private），指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。
    包名为"priv.个人名.项目名.模块名.XXX"
• 团体的项目命名
  • team:
    团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。
    包名为"team.团队名.项目名.模块名.XXX"
  • com:
    公司项目，copyright由项目发起的公司所有。
    包名为"com.公司名.项目名.模块名.XXX"

java 枚举 enum

public class Enum{
    public static void main(String[] args) {
        forEnum();
        useEnumInJava();
    }

    /**
     * 循环枚举
     */
    private static void forEnum(){
        for(SimpleEnum simpleEnum : SimpleEnum.values()){
            System.out.println(simpleEnum + " ordinal" + simpleEnum.ordinal());
        }
        System.out.println("---------------");
        for(TYPE type : TYPE.values()){
            System.out.println("type=" + type + " type.name=" + type.name() + " typeName=" + type.getTypeName() + " ordinal=" + type.ordinal());
        }
    }

    /**
     * 使用带参枚举
     */
    private static void useEnumInJava(){
        String typeName = "f5";
        TYPE type = TYPE.fromTypeName(typeName);
        if(TYPE.BALANCE.equals(type)){
            System.out.println("一致");
        }else{
            System.out.println("不一致");
        }
    }

    /**
     * 普通枚举
     */
    private enum SimpleEnum{
        SPRING,
        SUMMER,
        AUTUMN,
        WINTER
    }

    /**
     * 常用类型(带参数的枚举常量)
     */
    private enum TYPE{
        FIREWALL("firewall"),
        SECRET("secretMac"),
        BALANCE("f5");
        private String typeName;
        TYPE(String typeName){
            this.typeName = typeName;
        }
        //根据类型的名称，返回类型的枚举实例
        public static TYPE fromTypeName(String typeName){
            for(TYPE type : TYPE.values()){
                if(type.getTypeName().equals(typeName)){
                    return type;
                }
            }
            return null;
        }
        public String getTypeName(){
            return this.typeName;
        }
    }
}

java 序列化和反序列化实现

• 什么是序列化和反序列化
  • Java序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程；
  • 序列化: 对象序列化的最主要的用处就是在传递和保存对象的时候，保证对象的完整性和可传递性。序列化是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。序列化后的字节流保存了Java对象的状态以及相关的描述信息。序列化机制的核心作用就是对象状态的保存与重建。
  • 反序列化: 客户端从文件中或网络上获得序列化后的对象字节流后，根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象.
  • 本质上讲，序列化就是把实体对象状态按照一定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态。
• 为什么需要序列化与反序列化
  • 永久性保存对象，保存对象的字节序列到本地文件或者数据库中；
  • 通过序列化以字节流的形式使对象在网络中进行传递和接收；
  • 通过序列化在进程间传递对象；
• 序列化算法一般会按步骤做如下事情
  • 将对象实例相关的类元数据输出。
  • 递归地输出类的超类描述直到不再有超类。
  • 类元数据完了以后，开始从最顶层的超类开始输出对象实例的实际数据值。
  • 从上至下递归输出实例的数据。

User实体类

public class User implements Serializable {
    private String username;
    private String password;
    private String sex;

    public User(String username, String password, String sex) {
        this.username = username;
        this.password = password;
        this.sex = sex;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

Serial 实现

public class Serial {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化
        FileOutputStream fs = new FileOutputStream("object.out");
        ObjectOutputStream oos = new ObjectOutputStream(fs);
        User user = new User("xipiker", "123456", "male");
        oos.writeObject(user);
        oos.flush();
        oos.close();
        //反序列化
        FileInputStream fis = new FileInputStream("object.out");
        ObjectInputStream ois = new ObjectInputStream(fis);
        User userRs = (User) ois.readObject();
        System.out.println(userRs.getUsername()+";"+userRs.getPassword()+";"+user.getSex());
    }
}

java如何跳出多层循环

for(int i = 0; i < 3; i++){
    forOne:
    for(int j = 0; j < 3; j++){
        forTwo:
        for(int m = 0; m < 3; m++){
            forThree:
            if(m == 1){
                break forTwo;
            }
            System.out.println(i+"--"+j+"--"+m);
        }
    }
}

final, finalize和finally的不同之处

• final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。
• finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。
• finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。