继承&封装

扩展一个已有的类，并且继承该类的属性和行为这种方式成为继承。

实例

public class Polygon {
    public int sides;
    public double area;
    public int getNumberOfSides() {
        System.out.println(sides);
        return sides;
    }
/**重写toString*/
    @Override
    public String toString() {
        return "边数为：" + this.sides;
    }
/**构造方法*/
    public Polygon(int a) {
        this.sides = a;
        System.out.println("在Polygon的构造器中");
    }

}
Triangle 继承 Polygon

public class Triangle extends Polygon {
    public int base;
    public int height;
    public double area;

    /**
     * 构造方法
     * 
     * @param base三角形底边
     * @param height三角形高
     */
    public Triangle(int base, int height) {
        super(3);
        this.base = base;
        this.height = height;
        System.out.println("在Triangle类的构造器中");
    }

    @Override
    /**
     * 重写String完成输出
     */
    public String toString() {
        return "三角形底：" + this.base + "     三角形高：" + this.height;
    }

    /**
     * 三角形面积计算
     * 
     * @return三角形面积
     */
    public double getArea() {

        return (this.base) * (this.height) / 2;
    }
}

public class areaTest {

    public static void main(String[] args) {
        Polygon a = new Polygon(3);
        System.out.println(a.getNumberOfSides());// 添加方法输出
        System.out.println(a.toString());// 重写String

        Triangle b = new Triangle(4, 3);
        System.out.println(b.toString());
        System.out.println(b.getArea());

    }

}

上图为简单的继承用法，

注意当继承中，子类对象创建前必须通过super();调用父类的构造方法产生父类对象，一般super();是默认默认调用无参的构造方法，如果父类中没有提供无参构造方法，必须通过

super(实参)；进行显示调用。实例中，父类构造方法Polygon中传入参数sides,所以子类Triangle继承了父类后，显示调用了super();

方法的重写

方法的重写发生在父类和子类之间，方法的的参数列表，返回类类型必须相同，调用优先调用子类重写的方法。关键词@Override

实例中重写了toString，实现输出字符串。

注意构造方法会初始化成员变量

封装

public class Television {

    private int channel = 2;
    private int volume;

    /**
     * 频道
     * @param channel获取频道
     */
    public void SetChannel(int channel) {
        if (channel > 1000 || channel < 1) {
            return;
        } else {
            this.channel = channel;
        }
    }

    /** 频道访问器 */
    public int GetChannel() {
        return this.channel;
    }

    /**
     * 音量
     * 
     * @param volume获取音量
     */
    public void SetVolume(int volume) {
        if (volume >= 0 && volume <= 10) {
            this.volume = volume;
        } else {
            return;
        }
    }

    /** 音量访问器 */
    public int GetVolume() {
        return this.volume;
    }

    /**
     * 构造器
     * 
     * @param channel
     *            频道
     * @param volume
     *            音量
     */
    public Television(int channel, int volume) {
        this.SetChannel(channel);
        this.SetVolume(volume);
    }
    /**重写*/
    @Override
    public String toString()
    {
        return "频道："+GetChannel()+"
音量："+GetVolume();
    }
}

public class WatchTelevision {

    public static void main(String[] args) {
        String c = JOptionPane.showInputDialog(null, "请输入频道");
        String v = JOptionPane.showInputDialog(null, "请输入音量");
        int channel = Integer.parseInt(c);
        int volume = Integer.parseInt(v);
        Television t = new Television(channel, volume);
        System.out.println(t);
    }
}

实例为封装一个音量和频道在Television的类中，音量和频道作为参数传入Television类中，并且重写toString进行输出。