Java知识（010）--深入面向对象

深入面向对象

继承：从已有的类创建新类的过程，提供继承信息的类称为父类（超类、基类），得到继承信息的类称为子类（派生类、衍生类）。继承使用extends关键字，Java中的继承是单继承（一个类之只能有一个父类）。
多态：子类在继承父类的过程中可以对父类已有的方法进行重写，不同的子类给出不同的实现版本，那么同样类型的引用调用同样的方法将发生不同的行为，这就是多态。
相关概念
- 抽象类：被abstract关键字修饰的类，抽象类不能实例化（不能创建对象），专门为其他类提供继承信息。
- 抽象方法：如果一个方法没有方法体，就可以定义为抽象方法，也是用abstract关键字修饰，如果一个类有抽象方法，这个类必须被声明为抽象类。子类继承该抽象类时必须重写抽象方法。
- 终结类：被final关键字修饰的类，终结类不能被继承，工具类通常声明为终结类。
- 终结方法：被final关键字修饰的方法，子类中不能重写终结方法。
- 静态方法：被static修饰的方法，静态的方法和属性属于类，不属于对象，在内存中只有唯一的拷贝，静态方法和属性调用的方式是用类名调用，而不是通过对象的引用来调用。
接口：在Java中，接口是实现可插入特性的保证。定义接口的关键字是interface，实现接口的关键字是implements，一个类可以实现多个接口，接口之间的继承支持多重继承。
接口和抽象类的异同：
- 相同：抽象类和接口都不可以实例化；抽象类和接口中的方法都可以没有方法体；抽象类和接口的子类都可以强转成父类的类型；抽象类和接口的子类都必须实现父类中的抽象方法，除非子类也声明成抽象类或接口。
- 不同点：抽象类只能被单继承，接口可以多实现；接口中的变量必须是final的（如果没写，默认也是final的），抽象类则没有；抽象类中的方法可以有有方法体的，接口则不可以；接口在继承的时候使用implements关键字，表示实现，抽象类则用extends关键字，表示继承。
类/类和类/接口之间的关系
- IS-A关系：继承/实现
- HAS-A关系：关联/聚合（聚集）/合成
- USE-A关系：依赖
UML：统一建模语言（标准的图形化符号）
- 类图：描述类以及类和类之间关系的图形符号。
- 用例图：捕获需求。
- 时序图：描述对象交互关系。
面向对象的设计原则
- 单一职责原则（SRP）：类的设计要做到高内聚，一个类只承担单一的职责（不做不该它做的事情）。
- 开闭原则（OCP）：软件系统应该接受扩展（对扩展开放），不接受修改（对修改关闭）。要符合开闭原则：抽象是关键，封装可变性。
- 依赖倒转原则（DIP）：面向接口编程。声明变量的引用类型，声明方法的参数类型，声明方法的返回类型时，尽可能使用抽象类型而不是具体类型。
- 里氏替换原则（LSP）：用子类型替换父类型没有任何问题，用父类型替换子类型通常都是不行的。
- 接口隔离原则（ISP）：接口要小而专，不能大而全。
- 合成聚合复用原则（CARP）：优先考虑用强关联关系复用代码，而不是用继承关系复用代码。
- 迪米特法则（LoD）：对象之间尽可能少的发生联系。

package jerry;

import java.awt.Graphics;

/**
 * 能否在窗口上绘图的接口
 * @author HK
 *
 */
public interface Drawable {

    /**
     * 绘图接口
     * @param g 画笔对象
     */
    public abstract void draw(Graphics g);
}

package jerry;

import java.awt.Color;

/**
 * 几何图形(抽象类)
 * @author HK
 *
 */
public abstract class Shape implements Drawable {
    protected int x;            // 中心的横坐标
    protected int y;            // 中心的纵坐标
    protected Color color;      // 颜色

    /**
     * 计算面积
     * @return 图形的面积
     */
    public abstract double area();

    /**
     * 计算周长
     * @return 图形的周长
     */
    public abstract double perimeter();

    public void setColor(Color color) {
        this.color = color;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}

package jerry;

import java.awt.Graphics;

/**
 * 圆
 * @author HK
 *
 */
public class Circle extends Shape {
    private int radius;     // 半径

    /**
     * 构造器
     * @param radius 半径
     */
    public Circle(int radius) {
        this.radius = radius;
    }

    @Override
    public void draw(Graphics g) {
        g.setColor(color);
        g.drawOval(x - radius, y - radius,  * radius,  * radius);
    }
   /**
    *圆的面积
    */
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
    /**
    *
    *圆的周长
    */
    @Override
    public double perimeter() {
        return  * Math.PI * radius;
    }

}

package jerry;

import java.awt.Graphics;
/**
*
*四边形
*@author HK
*/
public class Rect extends Shape {
    private int width;      // 宽
    private int height;     // 高

    /**
     * 构造器
     * @param width 宽
     * @param height 高
     */
    public Rect(int width, int height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw(Graphics g) {
        g.setColor(color);
        g.drawRect(x - width / , y - height / , width, height);
    }
    /**
    *
    *四边形面积
    */
    @Override
    public double area() {
        return width * height;
    }
    /**
    *
    *四边形周长
    */
    @Override
    public double perimeter() {
        return (width + height) << ;
    }
}

package jerry;

import java.awt.Graphics;

/**
 * 等边三角形
 * @author HK
 *
 */
public class Triangle extends Shape {
    private int edge;//边长

    /**
     * 构造器
     * @param edge 边长
     */
    public Triangle(int edge) {
        this.edge = edge;
    }

    @Override
    public void draw(Graphics g) {
        int ax = x;
        int ay = (int) (y - edge * Math.cos(Math.PI / ) 
                + edge /  * Math.tan(Math.PI / ));
        int bx = x - edge / ;
        int by = (int) (y + edge /  * Math.tan(Math.PI / ));
        int cx = x + edge / ;
        int cy = (int) (y + edge /  * Math.tan(Math.PI / ));

        g.setColor(color);
        g.drawLine(ax, ay, bx, by);
        g.drawLine(bx, by, cx, cy);
        g.drawLine(cx, cy, ax, ay);
    }
    /**
    *
    *三角形的面积
    */
    @Override
    public double area() {
        double s = perimeter() / ;
        return Math.sqrt(s * Math.pow(s - edge, ));
    }
    /**
    *
    *三角形周长
    */
    @Override
    public double perimeter() {
        return  * edge;
    }

}

package jerry;

import java.awt.Color;

/**
 * 自定义工具类
 * @author HK
 *
 */
public final class MyUtil {

    private MyUtil() {
    }

    /**
     * 产生指定范围的随机整数
     * @param min 最小值(闭区间)
     * @param max 最大值(闭区间)
     * @return 指定范围的随机整数
     */
    public static int random(int min, int max) {
        return (int) (Math.random() * (max - min + ) + min);
    }

    /**
     * 生成随机颜色
     * @return Color对象
     */
    public static Color randomColor() {
        int r = random(, );
        int g = random(, );
        int b = random(, );
        return new Color(r, g, b);
    }
}

package jerry;

import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;

@SuppressWarnings("serial")
public class DrawingFrame extends JFrame implements ActionListener {
    private List<Shape> shapeList = new ArrayList<Shape>();//容器
    private List<Shape> redoList = new ArrayList<Shape>();

    private JButton circleButton, rectButton, triButton;// 按钮
    private JButton undoButton, redoButton, clearButton;

    private Shape shape = null;
    private String shapeType = "Circle";

    public DrawingFrame() {
        this.setSize(, );//窗口大小
        this.setResizable(false);//大小不可改
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);

        circleButton = new JButton("Circle");
        circleButton.addActionListener(this);
        rectButton = new JButton("Rectangle");
        rectButton.addActionListener(this);
        triButton = new JButton("Triangle");
        triButton.addActionListener(this);

        undoButton = new JButton("撤销");
        undoButton.addActionListener(this);
        redoButton = new JButton("恢复");
        redoButton.addActionListener(this);
        clearButton = new JButton("清空");
        clearButton.addActionListener(this);

        this.setLayout(new FlowLayout());
        this.add(circleButton);
        this.add(rectButton);
        this.add(triButton);
        this.add(undoButton);
        this.add(redoButton);
        this.add(clearButton);

        this.addMouseListener(new MouseAdapter() {

            @Override
            public void mousePressed(MouseEvent e) {
                if(shapeType.equals("Circle")) {
                    int radius = MyUtil.random(, );
                    shape = new Circle(radius);
                }
                else if(shapeType.equals("Rectangle")) {
                    int width = MyUtil.random(, );
                    int height = MyUtil.random(, );
                    shape = new Rect(width, height);
                }
                else if(shapeType.equals("Triangle")) {
                    int edge = MyUtil.random(, );
                    shape = new Triangle(edge);
                }

                if(shape != null) {
                    shape.setX(e.getX());
                    shape.setY(e.getY());
                    Color color = MyUtil.randomColor();
                    shape.setColor(color);
                    shapeList.add(shape);

                    repaint();
                }
            }
        });
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        for(Shape tempShape : shapeList) {
            tempShape.draw(g);
            g.drawString(
                String.format("周长: %.2f", tempShape.perimeter()), 
                tempShape.getX(), tempShape.getY());
            g.drawString(
                String.format("面积: %.2f", tempShape.area()), 
                tempShape.getX(), tempShape.getY() + );
        }
    }

    public static void main(String[] args) {
        new DrawingFrame().setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == circleButton) {
            shapeType = "Circle";
        }
        else if(e.getSource() == rectButton) {
            shapeType = "Rectangle";
        }
        else if(e.getSource() == triButton) {
            shapeType = "Triangle";
        }
        else if(e.getSource() == undoButton) {
            if(shapeList.size() > ) {
                Shape temp = shapeList.remove(shapeList.size() - );
                redoList.add(temp);
                repaint();
            }
        }
        else if(e.getSource() == redoButton) {
            if(redoList.size() > ) {
                Shape temp = redoList.remove(redoList.size() - );
                shapeList.add(temp);
                repaint();
            }
        }
        else if(e.getSource() == clearButton) {
            shapeList.clear();
            repaint();
        }
    }
}

Java知识（010）--深入面向对象

深入面向对象

继续阅读

算法设计与基础实验报告（一）java版

最新数组方法（包括es6）

【Java】16.面向对象之继承·上（概念、作用、语法、protected、final、类加载、继承类型）

你的时间有限，不要为别人而活！你的时间有限，不要为别人而活！

【android学习】泛型通配符extends与super区别

泛型限定符------extend和super

OC基础 -- 函数与方法的区别

矩阵分解笔记（Notes on Matrix Factorization）

torch.nn.BCELoss()=F.binary_cross_entropy()

编写高质量iOS和OS X代码的52个有效方法(笔记四）

编写高质量iOS与OS X代码的52个有效方法

做一个“懒惰”的程序员中心思想

java继承中new子类对象的执行顺序

Java装逼神器三部曲之枚举

QT解压缩文件