通过查阅一些资料，以及在视频中的点滴总结，将两个设计的小技巧分享给大家，希望大家能写出优良的程序。

一、类设计的技巧

我们在设计类的时候，就像在室内设计一样，怎么合理创建每个变量，并安排每个方法，是非常重要的。一方面看起来更有专业的水平，便于自己和他人阅读；另一方面，也可以更清晰的在其他类或包中调用该类，使得java的封装性更好，健壮性更强，等等。

1、一定要将数据设计为私有

       当然，这里说一定，并不是说所有的数据都要这么做，在一些必要的数据上是可以放宽一些权限的；不过为了安全起见，设置成为私有，是为了其封装性的良好。其实最重要，需要强调的就是：绝对不要破坏封装性。当数据保持私有时，外部使用者就不用去直接调用这些数据，而是通过一个入口，一个方法访问，这样，使用者不需要知道内部数据怎么组织的，只需要知道如何传入数据，如何使用结果等就可以了。而且，这些数据也就避免了被访问，从而防止被修改了。

2、对数据进行初始化

       我们在创建对象之前，一定要对其初始化。对实例变量进行显式的初始化是有一定必要的，因为如果让系统对对象的一些变量进行初始化，那么我们有的时候不知道系统会提供怎样的默认初始化值，这就会对数据的使用造成了一定的影响。比如说，你在设计小轿车这类汽车的时候，如果你不初始化它的轮胎数默认为int = 4;（或者更多）的话，而让系统默认初始化值为0，这显然是不符合实际的。

3、不是所有的变量或者域都需要独立的访问器和设定器（即getXxx和setXxx，Xxx代表变量名）

      当把数据或者说一些变量设置为private的时候，需要对数据进行访问和必要的修改的时候，是需要访问器和更改器的，但是，并不是所有的都是如此。比如说对于一个雇员的工资而言，是需要获得或设置的，这是需要getSalary()和setSalary()方法的，但是对于雇员的姓名和雇佣日期等，一旦构造了这个雇员对象，就就应该禁止更改了。另外，在对象中，常有一些不希望别人获得或设置的实例对象，如一些地区的信息等。

4、类中不要存在过多的方法，适当的分解一个类的功能

       这里的”过多“到底是多少呢？这就要根据个人的经验而定了，但是，如果很复杂的一个类可以很明显地分解成两个或更多的简单的类，这就需要将其分解。当然，也不能把一个很简单的方法作为一个类，这就显然有些不合适了，掌握好度就可以了。比如说：一个类可以包含这样几个方法：对数据获取最大值，最小值，排序等操作，另一个类可以包含这样几个方法：对数据进行增加或删除等操作。

5、类名或者方法名要能够体现各自的职责

         这与变量一样，一个类名或者方法名应该有自己一个能够反映出其含义的名字。命名可以这样写：arraySort，即对数组的排序；如类名可以是Employee，即是雇员的类。这样更清晰的给自己也给其他人方便的阅读。

6、使用固定的格式对类进行定义

         在对类进行定义的时候，可以按这样的顺序定义，如：

1. java] view plaincopyprint?
   
2. //创建一个简单的雇员类  
   
3. import java.util.*;  
   
4. public class Employee   
   
5. {  
   
6.     public Employee(String name,int age,double salary)  
   
7.     {  
   
8.         //将变量定义为private  
   
9.         private this.name = name;  
   
10.         private this.age = age;  
    
11.         private this.salary = salary;  
    
12.     }  
    
13.   
    
14.     //访问器方法  
    
15.     public String getName()  
    
16.     {  
    
17.         return name;  
    
18.     }  
    
19.   
    
20.     public int getAge()  
    
21.     {  
    
22.         if (age<18)//限制age的值  
    
23.         {  
    
24.             System.out.println("不好意思啦，我们不接收未成年人！嘿嘿");  
    
25.             return;  
    
26.         }  
    
27.         return age;  
    
28.     }  
    
29.   
    
30.     public double getSalary()  
    
31.     {  
    
32.         return salary;  
    
33.     }  
    
34.   
    
35.     //修改雇员工资：涨byPercent个百分点的工资  
    
36.     public void setSalary(double salary,double byPercent)  
    
37.     {  
    
38.         salary + = salary*byPercent/100;  
    
39.     }  
    
40. }  

复制代码

        你可以先将特定包中的类导入，在创建构造器，然后创建变量和方法等等，当然这种风格不是固定的，重要的是，你在定义自己的所有类的时候都要遵循自己的风格，让类设计出来更统一，这样更显专业。

二、继承设计的技巧

下面是一些对设计继承关系的建议

1、将公有成员放在超类中

这里的成员包括成员变量和成员方法。这样既可以减少代码的重复编写，避免出错（代码越多，越容易出错）；还可以增强封装性，是程序更健壮。

2、尽量不要使用受保护的变量（即被protected修饰）

很多人认为，将大多数的实例变量定义为protected是很不错的，这样的话，子类就能在需要的时候直接访问它们了。但是，使用protected修饰并不能得到更好的保护作用，究其原因在于：第一、子类如果不被声明为final的话，其他程序员是可以向下派生出子类的，这样就可以直接访问该类中protected的成员，那么，所谓的封装性就会被破坏了。第二、protected修饰的成员是可以被同一包中的所有类访问的，无论是不是这个类的子类，这样，依然是对数据产生一定的危险。

3、使用继承实现字父类关系

使用继承可以节省很多的代码，但是要防止被随意使用。比如说，钟点工同样有姓名和年龄，但是他们和公司雇员是不一样的，是没有所谓的工资的，因为他们是按小时获得劳动报酬的。不会有雇员一样的薪资待遇的。所以，如果在Employee类（假设有一个Manager子类）再派生出一个子类Contrator，显然是不合理的，因为在Employee中的类似打印工资单的方法，是不适用于钟点工的。所以说，要清楚是否两个类之间有子父类的关系，在使用继承。

4、使用继承的方法有有意义，否则不要使用继承关系

对于可以相互转换的两类事物，使用继承是不好的。比如说，假日也是一天，可将假日作为一周或一个月的子类考虑，但是假日是可以转换为非假日的，那么这就不太合适了。

5、在覆盖方法时，不要改变预期的行为

在覆盖一个方法的时候，不应该随意改变行为的内涵，应该是由于超类的方法不适宜子类的应用，或者有缺陷的时候，才覆盖该方法。如果我们自己不慎重考虑覆盖的方法是否有意义，编译器是不会知道该方法是否有任何意义，只要语法没有错误，是可以通过编译的。

6、使用多态，而非类型信息

对于下面的代码：

1. if(x is of type1)
   
2.         action1(x);
   
3. else if(x is of type2)
   
4.         action2(x);
   

复制代码

这就需要考虑使用多态了。

如果action1和action2表示的是相同的内容，就可以定义一个方法，将其放置在两个类的超类或者接口中，然后就直接调用x.action()，因为JVM虚拟机可以动态绑定x是属于那种类型，这样可以节省很多代码，提高执行效率，而且更有利于对代码进行维护和扩展。

下面是举例：

1. class Employee
   
2. {
   
3.         //将变量定义为private
   
4.         private String name;
   
5.         private double salary;
   
6.         public Employee(String name,double salary){
   
7.                 this.name = name;
   
8.                 this.salary = salary;
   
9.         }
   
10.        
    
11.         public String getName(){
    
12.                 return name;
    
13.         }
    
14.         public double getSalary(){
    
15.                 return salary;
    
16.         }
    
17.         public void setSalary(double salary){
    
18.                 this.salary = salary;
    
19.         }
    
20. }
    
21. 
    
22. class Manager extends Employee{
    
23.         private double bonus = 0;
    
24.         public Manager(String name,double salary){
    
25.                 //调用超类Employee中的构造器
    
26.                 super(name,salary);
    
27.         }
    
28.         //获得Manager类中对象的salary，有额外的奖金
    
29.         public double getSalary(){
    
30.                 double baseSalary = super.getSalary();
    
31.                 return baseSalary + bonus;
    
32.         }
    
33.         public void setBonus(double bonus){
    
34.                 this.bonus = bonus;
    
35.         }
    
36. }
    
37. 
    
38. class ManagerText{
    
39.         public static void main(String [] args){
    
40.                 Manager boss = new Manager("Anna",80000);
    
41.                 boss.setBonus(5000);
    
42.                 Employee[] staff = new Employee[3];
    
43.                 staff[0] = boss;//由于boss是Manager类的，是Employee的子类，所以，是可以赋值给staff数组中的元素的
    
44.                 staff[1] = new Employee("Ben",50000);
    
45.                 staff[2] = new Employee("Jone",40000);
    
46.                 for(int i=0;i<staff.length;i++){
    
47.                         System.out.println("name = " + staff[i].getName() + ",salary = " + staff[i].getSalary());
    
48.                 }
    
49.         }
    
50. }
    

复制代码

7不要过多的使用反射

反射机制使得人们可以通过在运行是查看变量和方法，让人们能编写出更具有通用性的程序。这种功能对于便携系统程序来说极其实用，但是通常不适用于编写应用程序。反射是很脆弱的，即编译器很难帮助人们发现程序中的错误。任何错误只能在运行时才被发现，并导致异常。

楼主不占楼了？

顶                  

很好啊，以后可以用到的啊