【JAVA设计模式第一课】面向对象特性及原则回顾

【JAVA设计模式-第一课】面向对象特性及原则回顾

---

• 面向对象特性

Everybody都知道在JAVA面向对象编程中有三个很重要的特性：封装、继承、多态。

封装：其实就是对类的属性进行私有化(private)，外部不能直接访问。当然外部要访问此类的属性也不是不可能，只不过就是通过一些方法。约定俗成的就是设置一些get/set访问器/构造器来访问设置。

比如在类Ball中,name,price被封装。但其他类可以通过get/set方法来访问.

public class Ball {
    private String name;
    private double price;
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the price
     */
    public double getPrice() {
        return price;
    }
    /**
     * @param price the price to set
     */
    public void setPrice(double price) {
        this.price = price;
    }
    
}

继承:就是一个类(子)扩展另一个类(父)。子类只能有一个父类，但父类可以有多个子类。当子类为非abstract类时，若继承的是父类为abstract类，那么子类拥有父类的属性及已实现的方法（可以重写父类方法-多态），并且子类必须实现父类中所有的abstract方法，且子类中在实现父类方法时必须是方法名相同、返回类型、参数个数和类型要保持一致。当然若子类为abstract的话，就拥有了父类的所有属性和方法，可以实现父类中的abstract方法也可以不实现，当然子类还可重写父类已存在(实现)的方法。如下面代码中，类Teacher和Student是子类，父类为Person。

public class Person {
    private String sex;
    private String name;
    private int age;
    /**
     * @return the sex
     */
    public String getSex() {
        return sex;
    }
    /**
     * @param sex the sex to set
     */
    public void setSex(String sex) {
        this.sex = sex;
    }
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }
    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }
    
    /**
     * @param sex
     * @param name
     * @param age
     */
    public Person(String sex, String name, int age) {
        super();
        this.sex = sex;
        this.name = name;
        this.age = age;
    }
    public String getInfo(){
        return "name:"+name+",sex:"+sex+",age:"+age;
    }
}

public class Teacher extends Person{
    /**
     * @param sex
     * @param name
     * @param age
     */
    public Teacher(String sex, String name, int age) {
        super(sex, name, age);
        // TODO Auto-generated constructor stub
    }
    
    /*重写父类方法
     * (non-Javadoc)
     * @see com.wjq.model.obj.back.Person#getInfo()
     */
    @Override
    public String getInfo() {
        System.out.print("我是老师--");
        return super.getInfo();
    }

public class Student extends Person{

    /**
     * @param sex
     * @param name
     * @param age
     */
    public Student(String sex, String name, int age) {
        super(sex, name, age);
        // TODO Auto-generated constructor stub
    }
    
    /* (non-Javadoc)
     * @see com.wjq.model.obj.back.Person#getInfo()
     */
    @Override
    public String getInfo() {
        System.out.print("我是学生--");
        return super.getInfo();
    }
}

---

public class PersonTest {
    public static void main(String[] args) {
        Person person = new Person("男/女", "M.W", 0);
        Person teacher = new Teacher("男","Mr.Tam",47);
        Person student = new Student("女","Jill",21);
        System.out.println(person.getInfo());
        System.out.println(teacher.getInfo());
        System.out.println(student.getInfo());
    }
}

 测试结果:

name:M.W,sex:男/女,age:0
我是老师--name:Mr.Tam,sex:男,age:47
我是学生--name:Jill,sex:女,age:21

注：这里必须特别注意重写和重载的概念。重写是针对子类与父类之间的关系，也就是重写的是父类的方法。重写产生的结果就是如果有多个子类，那么在使用上转型对象调用同一个方法时，如果重写了父类的方法的子类，将执行重写后的方法。而没有重写父类的方法的子类，调用的将是父类原有的方法。这种结果也就是一种多态的形式。而重载指的是每个类可以自己多个同名字的方法，这些方法名字必须是相同的，但是方法的参数个数、类型及参数类型的顺序是不一样的。比如在一个类中很常见的重载就是该类的构造函数。

•  面向对象基本原则

1. 面向抽象原则：抽象类和接口的应用及面向抽象编程。
2. 开-闭原则：设计对可扩展的部分开放，对修改的部分关闭。
3. 多组合少继承原则：继承与复用(白盒模式)、组合与复用(黑盒模式Has-A:将对象作为类的属性，当然这样将导致系统对象过多)
4. 高内聚-低耦合原则：类中的一些方法是一组相关行为，就是高内聚，这便于类自身维护。而反之，若类中的方法没有相关行为，则成为低耦合，不利于类的管理。低耦合中尽量要求不要让一个类含有太多其他类的实例引用，避免在系统修改时，由一部分而影响到其他部分。总之，尽量少用其他类的实例化，方法与其他的类的直接关联越少越好管理类。

 下一课：【JAVA设计模式-第二课】UML建模简介