华为Java企业级规范

一、"JAVA基础语句"编程规范

1. 建议:switch 语句要有default分支，除非其条件变量是枚举类型。

说明：
如果没有默认分支，当条件变量没有和任一case语句后的值匹配时，程序将不会有任何输出。

2. 使用break跳出swich语句。

说明：
switch语句的工作流程是，当条件变量的值和case语句后面的值相等时，switch语句从该位置开始向下执行，直到遇到break 或者 switch语句结束。

3. if-else if语句，最后应以else分支作为结尾。

说明：
else用以处理以上分支没有处理到的情况。

4. 不能用浮动数作为循环变量

说明：
浮动数不是一类精确的数据

5. 明确地进行数据类型转换

意外的浮动数截取转换将使得误差放大

二， "类的使用"编程规范

6. 使用类名调用静态方法，不要使用实例。

说明：
使用实例名调用静态方法时，调用的静态方法是声明类型的静态方法，
和实例的实际类型无关。

package BlueBridge;

public class Dog {
	public static void main(String [] args) {
		Dog dog = new Dog();
		Dog basenjiDog = new Basenji();
		dog.run();
		basenjiDog.run();
		dog.eat();
		basenjiDog.eat();
	}
	public static void eat() {
		System.out.println("Animal eat");
	}
	public void run() {
		System.out.println("Animal running");
	}
}

class Basenji extends Dog{
	public static void eat() {
		System.out.println("Basenji eat");
	}
	public void run() {
		System.out.println("Basenji running");
	}
}

Animal running
Basenji running
Animal eat
Animal eat

分析：
basenjiDog.eat(); 此处使用实例名调用静态，结果为Animal eat。
总结：
父类和子类有同名非静态方法时，子类方法将重写父类方法；
【当子类的创建方式为 父类声明 子类实现时】
父类和子类有同名 静态方法时，父类方法将隐藏字类方法。

7. 避免无关的变量或概念重名，导致的隐藏（hiden），遮蔽（shadow），和遮掩（obscure）。

obscure: v.使模糊；使隐晦；使费解

说明：
override 存在于子类和父类之间。
	子类中的【实例方法】可以覆写 override 其在超类中能够访问（非私有）的同签名的实例方法（非静态方法）。
	
overload存在于某个类之间。
	某个类中的【某个方法】可以重载 overload 同类中的另一个具有相同命名和不同签名的方法。

hide 存在于子类和父类之间。	
	子类中的 【属性】，【静态方法】或者【内部类】可以被隐藏在 其超类中可以访问的同名（同签名）的属性，静态方法或内部类。
	子类中被隐藏的成员将不能被继承。

shadow 存在于某个类之间
	某个类中的 【属性】，【方法】和【内部类】可以分别 遮蔽 shadow 同类中的零个同名的属性，方法和内部类，使其无法使用简单名被引用。

override实例

public class Animal {
    private String name;
    private int id;

    public Animal(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public void eat() {
        System.out.println("吃东西");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

public class Horse extends Animal{
    public Horse(String name, int id) {
        super(name, id);
    }

    @Override
    public void eat() {
        System.out.println("吃草");
    }

    @Override
    public void sleep() {
        System.out.println("站着睡觉");
    }

}

hide实例

import java.awt.*;

class Swan {
    int weight = 1;

    public static void fly() {
        System.out.println("swan can fly");
    }

    public void gender(){
        System.out.println("雄");
    }

    public class  Blood{
        public int bp = 1;

        public void circulate() {
            System.out.println("swan`s blood circulate");
        }
    }
}

class UglyDuck extends Swan {
    int weight = 2;

    public static void fly() {
        System.out.println("ugly duck can`t fly ...");
    }

    public void gender() {
        System.out.println("雌");
    }

    public class Blood {
        public int bp = 2;

        public void circulate() {
            System.out.println("UglyDuck`s blood circulate");
        }
    }

}
public class Tester {
    public static void main(String[] args) {
        System.out.println("-----隐藏父类信息显示子类信息-----");
        UglyDuck 丑小鸭  = new UglyDuck(); // 从子类访问
        丑小鸭.fly(); // 隐藏父类静态方法
        丑小鸭.gender(); // 子类的实例方法
        System.out.println("丑小鸭的重量是 "+丑小鸭.weight); // 隐藏父类属性
        UglyDuck.Blood childInner = 丑小鸭.new Blood(); // 隐藏父类内部类
        childInner.circulate(); // 隐藏父类内部类的方法
        System.out.println("ugly Duck`s bp is "+childInner.bp);  // 隐藏父类内部类的属性

        System.out.println("-----显示父类信息-----");
        Swan father = new UglyDuck(); // 从父类访问
        father.fly(); // 父类的静态方法
        father.gender(); // 父类的实例方法
        System.out.println("天鹅的重量是 "+father.weight); // 显示父类属性
        Swan.Blood fatherInner = father.new Blood(); // 父类的内部类
        fatherInner.circulate(); // 父类内部类的方法
        System.out.println("Swan`s bp is "+fatherInner.bp); // 父类内部类的属性



    }
}

-----隐藏父类信息显示子类信息-----
ugly duck can`t fly ...
雌
丑小鸭的重量是 2
UglyDuck`s blood circulate
ugly Duck`s bp is 2
-----显示父类信息-----
swan can fly
雌
天鹅的重量是 1
swan`s blood circulate
Swan`s bp is 1

Process finished with exit code 0

8. 子类覆写父类方法时，应加上@Override注释

tip
覆写要求子类实例方法和父类实例方法的签名相同，即一下都相同：

• 返回值
• 方法名
• 参数列表

9. 将对象存入HashSet或者作为Key存入HashMap时，必须确保对象的哈希值HashCode不变，避免因为哈希值的变化，导致对象不能从集合中删除。

实例9

import java.util.Objects;

public class Email {
    private String address;
    private String name;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Email(String address, String name) {
        this.address = address;
        this.name = name;
    }

    @Override
    public int hashCode() {
        return Objects.hash(address, name);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Email) {
            Email that = (Email) obj;
            return Objects.equals(this.address, that.address) &&
                    Objects.equals(this.name, that.name);
        }
        return false;
    }
}

import java.util.HashSet;
import java.util.Set;

public class TestEmail {
    public static void main(String[] args) {
        HashSet<Email> emailSet = new HashSet<>( ) ;
        Email email = new Email ( "fly.com", "Jim" ) ;
        emailSet .add(email ) ;
        email.setAddress( "run.com" ) ;
//        System.out.println(Set.contains(email ) ) ;
        emailSet.remove(email);
        for (Email setEmail : emailSet) {
            System.out.println(setEmail.getAddress());
            System.out.println(setEmail.getName());
        }
    }
}

run.com
Jim

分析：
emailset集合中只放入了一个对象email,最后却能将对象的信息打印，说明
emailSet.remove(email);删除语句没有成功。
原因就是对象的哈希值确定方式如下：

@Override
public int haseCode(){
		return Object.hash(address,name);
}

email.setAddress( "run.com" ) ;该语句将对象的Address改变导致对象的哈希值改变，使得对象不能被正确删除。

10. 向下类型转换前使用instanceof进行判断

向下类型转换是指从大类型向小类型的转换

例如：

        Tiger tiger = new Tiger () ;
        Animal animal = tiger: // 向上类型转婪自动类型转换
        animal. eat O :
        Tiger tigerl = (Tiger) animal; // 向下类型转痪强制类型转换
        tiger1. eat() ;
        Goat goat= (Goat) animal; // 向下类型转换强制类型转痪
        goat. eat();

分析：
可能会因为类型不匹配导致运行期异常

        Tiger tiger = new Tiger () ;
        Animal animal = tiger;
        animal. eat () ;
        if ( animal instanceof Tiger) {
        Tiger tiger1 =  (Tiger) animal;
        tiger1.eat () ;
        } else {
        System.out.println("动物对象不能转换成老虎对象！");
        if (animal instanceof Goat) {
        Goat goat = (Goat) animal;
        goat. eat ();
        } else {
        System.out.println(" 动物对象不能转换成山羊对象！");
        }

三，"异常处理"编程规范