面向对象入门理解

学习Java，入门期不可避免一定要掌握面向对象的意义。首先要清楚类和对象的关系，以及他们数据成员和成员函数的意义，我通常用下图描述：

　　其中，创建类的对象的语法为  类名 对象名 = new 构造函数(参数);  // 注意类名和构造函数名字一定一样，参数就是构造函数的参数。在创建对象的时候，自动调用构造函数。

　　（学过函数重载都知道，由于函数可以重载，因此同一个函数名可以有不同的方法）

不过

　　入门不可以高谈阔论大谈概念，人的正确思想来自于实践。以上概念未免太过抽象，通俗描述之前，先来一个实例感受一下：

　　例如需要定义一只猫，需要的定义几个属性（也就是类的变量）：这只猫的名字，这只猫的品种等等，猫会做出的行为，喵喵叫，和跑，那么用程序定义如下：

public class Cat {

    // ================定义成员变量，描述实体Cat==========
    private String name;  // 名字
    private String variety;  // 品种
    
    // ============定义动作=============
    // 跑
    public void move() {
        System.out.println(this.name + "跑了");
    }
    
    // 喵喵叫
    public void cry() {
        System.out.println(this.name+"表示喵喵喵");
    }


    public static void main(String[] args) {
        Cat cat1 = new Cat("小花", "土猫");
        System.out.println("小猫的名字为："+cat1.name);
        cat1.cry();
        
        Cat cat2 = new Cat("小黑", "野猫");
        System.out.println("小猫的品种为"+cat2.variety);
        cat2.move();
    }
}

运行如下：

小猫的名字为：小花
小花表示喵喵喵
小猫的品种为野猫
小黑跑了

　　但是这是一个不完整的面向对象程序，通常来说，一个完整的面向对象程序，还应该包含构造函数，描述字段，getter，setter。

　　构造函数：用来初始化类的变量，在这个类的对象被创建的时候，定义这个对象应有的特征。比如这只猫叫做小花，品种是土猫。

    public Cat(String name, String variety) {
        super();
        this.name = name;
        this.variety = variety;
    }
        在主函数中就是
    public static void main(String[] args) {
        Cat cat1 = new Cat("小花", "土猫");
    }

　　描述字段：就是一个返回字符串的方法，这个字符串以通俗易懂的语言描述了这个类的对象，比如”Cat [名字=小花, 品种=土猫]“。

public String toString() {
        return "Cat [名字=" + name + ", 品种=" + variety + "]";
    }

　　getter和setter：一般来说，类的对象不希望任何程序都能访问，因为需要封装的很安全，因此类的变量通常加上修饰符private，这样就只有本类的对象能够访问了，访问的时候就是用getter，例如getName(); 但是类的变量在程序运行中可能需要动态修改，比如猫改名为小黑，就使用setName("小黑");

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
主函数中就是
        cat1.setName("小黑");

此时cat1.name就从"小花"变为了"小黑"

还是用这个猫举例子吧

public class Cat {

    // ================定义成员变量，描述实体Cat==========
    private String name;  // 名字
    private String variety;  // 品种
    
    public Cat(String name, String variety) {
        super();
        this.name = name;
        this.variety = variety;
    }
    
    // ============定义动作=============
    // 跑
    public void move() {
        System.out.println(this.name + "跑了");
    }
    
    // 喵喵叫
    public void cry() {
        System.out.println(this.name+"表示喵喵喵");
    }
    
    // ===============
        // getter
    public String getName() {
        return name;
    }
        // setter
    public void setName(String name) {
        this.name = name;
    }

    public String getVariety() {
        return variety;
    }

    public void setVariety(String variety) {
        this.variety = variety;
    }

    // ============定义描述字段================
    @Override
    public String toString() {
        return "Cat [名字=" + name + ", 品种=" + variety + "]";
    }
    
    public static void main(String[] args) {
        Cat cat1 = new Cat("小花", "土猫");
        System.out.println(cat1.toString());
        cat1.cry();
        System.out.println(cat1.name+"改名了");
        cat1.setName("小黑");
        System.out.println(cat1.toString());
        System.out.println();
        Cat cat2 = new Cat("小桔", "野猫");
        System.out.println(cat2.toString());
        cat2.move();
    }

}
    

运行如下：

Cat [名字=小花, 品种=土猫]
小花表示喵喵喵
小花改名了
Cat [名字=小黑, 品种=土猫]

Cat [名字=小桔, 品种=野猫]
小桔跑了

　　果然还是太抽象了，都是学过线性代数的人，那就举一个常见的例子。

　　矩阵：定义矩阵需要其行数，列数，元素值。矩阵通常会转置，求行列式。那么定义就如下：

package matrix;

import java.util.Arrays;

public class Matrix {

    public int row;  // 行数
    public int column;  // 列数
    public double[][] elements;  // 元素值
    
    // 创建矩阵的时候元素值都是0
    public Matrix() {
        this.elements = new double[this.row][this.column];
        for (int i = 0; i < this.row; i++) {
            for (int j = 0; j < this.column; j++) {
                this.elements[i][j] = 0;
            }
        }
    }
    
    // 函数重载，创建矩阵的时候给定元素值
    public Matrix(double[][] elements) {
                // 初始化行数列数，初始化元素值
        this.row = elements.length;
        this.column = elements[0].length;
        this.elements = new double[this.row][this.column];
        for (int i = 0; i < this.row; i++) {
            for (int j = 0; j < this.column; j++) {
                this.elements[i][j] = elements[i][j];
            }
        }
    }
    
    // 求行列式
    public double det()  {
        // 省略内容
    }

　　　// 矩阵转置
    public void transpose() {
　　　　// 省略
　　}

    public static void main(String[] args) {
        double[][] matrix = {
                {11, 5, 25},
                {32, 25, 65},
                {94, 65, 289},
        };
        // 定义一个矩阵
        Matrix m = new Matrix(matrix);
        // 求行列式
        System.out.println(m.det());
    }
}

 这下应该就入门了面向对象了！