Java 学习之路——面向对象及类的成员-阿里云开发者社区

Java 学习之路——面向对象及类的成员

面向过程（POP）与面向对象（OOP）

二者都是一种思想，面向对象是相对于面向过程而言的。

面向过程（Procedure Oriented Programming）：强调的是功能行为，以函数为最小单位，考虑怎么做。

面向对象（Object Oriented Programming）：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如：抽象、分类、继承、聚合、多态等。

面向对象的三大特征：

封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）

面向对象的思想概述

程序员从面向过程的执行者转化成了面向对象的指挥者。

面向对象分析方法分析问题的思路和步骤：

根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

Java 语言的基本元素：类和对象

**类（Class）和对象（Object）**是面向对象的核心概念：

类是对一类事物的描述，是抽象的、概念上的定义。
对象是实际存在的该类事物的每个个体，因而也被称为实例（instance）。

“万事万物皆对象”。

面向对象的思想概述：

可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人。
面向对象程序设计的重点是类的设计。
类的设计其实就是类的成员的设计。

Java 类及类的成员

Java 代码世界是由诸多个不同功能的类构成的。

Java 中用类 class 来描述事物。常见的类的成员有：

属性：对应类中的成员变量。
行为：对应来中的成员方法。

3.Field = 属性 = 成员变量；Method = （成员）方法 = 函数。

4.创建类的对象 = 类的实例化 = 实例化类。

package test;
public class Testm {
    public static void main(String[] args) {
//        创建person类的对象
        Person p1 = new Person();
//        调用对象的结构：属性、方法
//        调用属性：“对象.属性”
        p1.name = "Tom";
        p1.isMale = true;
        System.out.println(p1.name);
//        调用方法：“对象.方法”
        p1.eat();
        p1.sleep();
        p1.talk("English");
    }
}
class Person{
    //属性
    String name;
    int age = 1;
    boolean isMale;
    // 方法
    public void eat(){
        System.out.println("人可以吃饭");
    }
    public void sleep() {
        System.out.println("人可以睡觉");
    }
    public void talk(String language) {
        System.out.println("人可以说话,使用的是："+language);
    }
}

5.如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非 static 的）。意味着：如果我们修改了一个对象的属性 a ，则不影响另外一个对象属性 a 的值。

6.对象的创建和使用：内存解析

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference 类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

7.属性（成员变量） vs 局部变量

相同点：

定义变量的格式：数据类型变量名 = 变量值。
先声明，后使用。
变量都有其对应的作用域。

不同点：

在类中生命的位置不同。属性：直接定义在类的一对{}内；局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。

关于权限修饰符的不同。属性：可以在声明属性时，指明其权限，使用权限修饰符，常用的权限修饰符：private、public、缺省、protected；局部变量：不可以使用权限修饰符。

默认初始化值的情况不同。属性：类的属性根据其类型都有默认初始化值；局部变量：没有默认初始化值，意味着，我们在调用局部变量之前，一定要显式赋值，特别的：形参在调用时，我们赋值即可。

类型（属性）	初始化默认值
整型（byte、short、int、long）	0
浮点型（float、double）	0.0
字符型（char）	0（或'\u0000'）
布尔型（boolean）	false
引用数据类型（类、数组、接口）	null

在内存中加载的位置。属性：加载到堆空间中（非 static）；局部变量：加载到栈空间。

类中方法的声明和使用

方法：描述类应该具有的功能。

举例：

public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

2.方法的声明：权限修饰符返回值类型方法名(形参列表){ 方法体 }。

3.说明：

关于权限修饰符：

Java 规定的 4 种权限修饰符：private、public、缺省、protected。

返回值类型：有返回值 vs 没有返回值

如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用 return 关键字来返回指定类型的变量或常量。
如果方法没有返回值，则方法声明时，使用 void 来表示。通常没有返回值的方法中，就不需要使用 return 。但是，如果使用的话，只能“return;”表示结束此方法的意思。（return 之后不可以声明表达式）。

方法名：属于标识符，遵循标识符的规则和规范，“见名知意”。

形参列表：方法可以声明 0 个，1 个或多个形参。

格式：数据类型1 形参1,数据类型2 形参2,...

方法体：方法功能的体现。

4.方法的使用中，可以调用当前类的属性或方法。特殊的：方法 A 中又调用了方法 A （递归方法）。方法中不可以定义方法。

对象数组题目练习

问题：定义类 Student，包含三个属性：学号 number(int)、年级state(int)、成绩 score(int)。创建 20 个学生对象，学号为 1 到 20 ，年级和成绩都由随机数确定。

问题一：打印出 3 年级(state 值为 3)。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息。

提示：

生成随机数：Math.random()；返回值类型 double 。
四舍五入取整：Math.round(double d)；返回值类型 long 。

package test;
public class Testm {
    public static void main(String[] args) {
        Student[] stus = new Student[20];
        for (int i = 0;i < stus.length;i++) {
            // 给数组元素赋值
            stus[i] = new Student();
            // 给属性赋值
            stus[i].number = (i + 1);
            // 年级[1,6]
            stus[i].state = (int)(Math.random() * (6-1+1)+1);
            // 成绩
            stus[i].score = (int)(Math.random() * (100-1+1));
        }
        // 遍历学生数组
        for (int i = 0;i < stus.length;i++) {
            // System.out.println(stus[i].number + "," + stus[i].state + "," + stus[i].score);
            System.out.println(stus[i].info());
        }
        System.out.println("*************************************");
        // 打印出 3 年级(state 值为 3)。
        for (int i = 0;i < stus.length;i++) {
            if (stus[i].state == 3) {
                System.out.println(stus[i].info());
            }
        }
        System.out.println("*************************************");
        // 使用冒泡排序按学生成绩排序，并遍历所有学生信息。
        for (int i = 0;i < stus.length - 1;i++) {
            for (int j = 0;j < stus.length - 1;j++) {
                if (stus[j].score > stus[j + 1].score) {
                    Student temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }
        // 遍历学生数组
        for (int i = 0;i < stus.length;i++) {
            System.out.println(stus[i].info());
        }
    }
}
class Student {
    int number; // 学号
    int state;  // 年级
    int score;  // 成绩
    // 显示学生信息的方法
    public String info() {
        return "学号：" + number + "，年级：" + state + "，分数：" + score;
    }
}

代码优化

package test;
public class Testm {
    public static void main(String[] args) {
        Student[] stus = new Student[20];
        for (int i = 0;i < stus.length;i++) {
            // 给数组元素赋值
            stus[i] = new Student();
            // 给属性赋值
            stus[i].number = (i + 1);
            // 年级[1,6]
            stus[i].state = (int)(Math.random() * (6-1+1)+1);
            // 成绩
            stus[i].score = (int)(Math.random() * (100-1+1));
        }
        // 遍历学生数组
        Testm test = new Testm();
        test.print(stus);
        System.out.println("*************************************");
        // 打印出 3 年级(state 值为 3)。
        test.serachState(stus,3);
        System.out.println("*************************************");
        // 使用冒泡排序按学生成绩排序，并遍历所有学生信息。
        test.sort(stus);
        // 遍历学生数组
        test.print(stus);
    }
    /**
     * @Author CoderMeng
     * @Description 遍历学生数组。
     * @Date 16:49 2022/2/2
     * @Param stus 需要打印的数组。
     * @return void
     **/
    public void print(Student[] stus) {
        for (int i = 0;i < stus.length;i++) {
            System.out.println(stus[i].info());
        }
    }
    /**
     * @Author CoderMeng
     * @Description 查找 student 数组中指定年级的学生信息。
     * @Date 16:48 2022/2/2
     * @Param stus 要查找的数组。
     * @Param state 要查找的年级。
     * @return void
     **/
    public void serachState(Student[] stus,int state) {
        for (int i = 0;i < stus.length;i++) {
            if (stus[i].state == state) {
                System.out.println(stus[i].info());
            }
        }
    }
    /**
     * @Author CoderMeng
     * @Description
     * @Date 16:49 2022/2/2
     * @Param stus 需要排序的数组。
     * @return void
     **/
    public void sort(Student[] stus) {
        for (int i = 0;i < stus.length - 1;i++) {
            for (int j = 0;j < stus.length - 1;j++) {
                if (stus[j].score > stus[j + 1].score) {
                    Student temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }
    }
}
class Student {
    int number; // 学号
    int state;  // 年级
    int score;  // 成绩
    // 显示学生信息的方法
    public String info() {
        return "学号：" + number + "，年级：" + state + "，分数：" + score;
    }
}

return 关键字的使用

使用范围：使用在方法体中。

作用：

结束方法。
针对于有返回值类型的方法，使用“return 数据”方法返回所要的数据。

3.注意点：return 关键字后面不可以声明执行语句。

理解“万事万物皆对象”

在 Java 语言范畴中，都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。

Scanner，String 等。
文件：File 。
网络资源：URL 。

涉及到 Java 语言与前端 HTML 、后端的数据库交互时，前后端的结构在 Java 层面交互时，都体现为类、对象。

匿名对象的使用

理解：创建对象时没有显式得赋给一个变量名，即为匿名对象。

特征：匿名对象只能调用一次。

// 匿名对象
new Phone().sendEmail();
new Phone().playGame();

类的成员之二：方法(method)

自己封装 array 的常用方法：

package test;
public class Testm {
    /**
     * @return int
     * @Author CoderMeng
     * @Description 获取最大值。
     * @Date 21:55 2022/2/2
     * @Param arr
     **/
    public int getMax(int[] arr) {
        int maxValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (maxValue < arr[i]) {
                maxValue = arr[i];
            }
        }
        return maxValue;
    }
    /**
     * @return int
     * @Author CoderMeng
     * @Description 获取最小值。
     * @Date 21:55 2022/2/2
     * @Param arr
     **/
    public int getMin(int[] arr) {
        int minValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (minValue > arr[i]) {
                minValue = arr[i];
            }
        }
        return minValue;
    }
    /**
     * @return int
     * @Author CoderMeng
     * @Description 求和。
     * @Date 22:01 2022/2/2
     * @Param arr
     **/
    public int getSum(int[] arr) {
        int sumValue = 0;
        for (int i = 0; i < arr.length; i++) {
            sumValue += arr[i];
        }
        return sumValue;
    }
    /**
     * @return int
     * @Author CoderMeng
     * @Description 获取平均值。
     * @Date 21:59 2022/2/2
     * @Param arr
     **/
    public int getAvg(int[] arr) {
        return getSum(arr) / arr.length;
    }
    /**
     * @return void
     * @Author CoderMeng
     * @Description 反转数组。
     * @Date 22:03 2022/2/2
     * @Param arr
     **/
    public void reverse(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
    }
    /**
     * @return int[]
     * @Author CoderMeng
     * @Description 复制数组。
     * @Date 22:04 2022/2/2
     * @Param arr
     **/
    public int[] copy(int[] arr) {
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }
    /**
     * @return void
     * @Author CoderMeng
     * @Description 数组排序(冒泡排序)。
     * @Date 11:03 2022/2/3
     * @Param arr
     **/
    public void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    /**
     * @return void
     * @Author CoderMeng
     * @Description 遍历数组。
     * @Date 22:05 2022/2/2
     * @Param arr
     **/
    public void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
    /**
     * @return int
     * @Author CoderMeng
     * @Description 查找指定元素。
     * @Date 22:06 2022/2/2
     * @Param arr
     * @Param dest
     **/
    public int getindex(int[] arr, int dest) {
        for (int i = 0; i < arr.length; i++) {
            if (dest == arr[i]) {
                return i;
            }
        }
        return -1;  // 返回一个负数，表示没有找到。
    }
}

再谈方法

一、方法的重载

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。（参数个数或参数类型）。调用时，根据方法参数列表的不同来区别。

示例：

// 返回两个整数的和
int add(int x, int y) {
  return x + y;
}
// 返回三个整数的和
int add(int x, int y, int z){
  return x + y + z;
}
// 返回两个小数的和
double add(double x, double y){
  return x + y;
}

4.判断是否是重载：

跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。

5.在通过对象调用方法时，如何确定某一个指定的方法：

方法名 ——> 参数列表

二、可变个数的形参

概念：JavaSE 5.0 中提供了 Varargs(variable number of arguments) 机制，允许直接定义能和多个实参相匹配的形参。从而可以用一种更简单的方式，来传递个数可变的形参。

可变个数形参的格式：

// 数据类型... 变量名
public void show(String... strs) {
}

3.可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。

4.可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间构成重载(即二者不能共存)。

5.可变个数形参在方法的形参中，必须声明在末尾。

6.可变个数形参在方法的形参中，最多只能声明一个可变形参。

三、方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数。
实参：方法调用时实际传给形参的参数值。

Java 的实参值如何传入方法呢？

Java 里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参。
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参。

四、递归（recursion）方法

递归方法：一个方法体内调用它自身。

方法递归包含了一种隐式的循环，他会重复执行某段代码，但这种重复执行无需循环控制。

递归一定要向已方向递归，否则这种递归就变成了无穷递归，类似于死循环。

// 计算 1-100 之间的所有自然数的和
public int sum(int num) {
  if(num == 1) {
    return 1;
  } else {
    return num + sum(num - 1);
  }
}

练习：斐波那契数列

package test;
public class Testm {
    public static void main(String[] args) {
        Testm test = new Testm();
        System.out.println(test.getNum(10));
    }
    public int getNum(int n) {
        if (n == 1) {
            return 1;
        } else if (n == 2) {
            return 1;
        } else {
            return getNum(n - 1) + getNum(n - 2);
        }
    }
}

类的结构之三：构造器（或构造方法）的使用

构造器的作用：

创建对象
初始化对象的属性

构造器的特征：

具有与类相同的名称。
不声明返回值类型。
不能被 static 、finally、 synchronized 、abstract、 native 修饰，不能有 return 语句返回值。

说明

如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
定义构造器的格式：权限修饰符类名(形参列表) {}。
一个类中定义的多个构造器，彼此构成重载。
一旦显式定义了构造器，系统就不再提供默认的空参构造器了。

public class PersonTest {
    public static void main(String[] args) {
        Person a1 = new Person();
        a1.say();
    }
}
class Person {
    int age = 3;
    // 构造器
    public Person() {
        System.out.println("构造函数被调用了");
    }
    // 方法
    public void say() {
        System.out.println("我可以说话");
    }
}

属性赋值的先后顺序

默认初始化。
显示初始化。
构造器中初始化。
通过”对象.方法“或”对象.属性“的方式赋值。

拓展知识：JavaBean

JavaBean 是一种 Java 语言写成的可重用组件。

所谓 JavaBean 是指符合如下标准的 Java 类：

类是公共的。
有一个无参的公共的构造器。
有属性，且有对应的 get、set 方法。

 public class Person {
   private int age;
   private String name;
   public Person() {
   }
   public void setAge(int age) {
     this.age = age;
   }
   public int getAge() {
     return age;
   }
   public String getName() {
     return name;
   }
   public void setName(String name) {
     this.name = name;
   }
 }

用户可以使用 JavaBean 将功能、处理、值、数据库访问和其他任何可以用 Java 代码创造的对象进行打包，并且其他的开发者可以通过内部的 JSP 页面、Servlet、其他 JavaBean、applet 程序或者应用来使用这些对象。用户可以认为 JavaBean 提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

拓展知识：UML 类图

总结

面向对象中类和对象的理解，并指出二者的关系。

类：抽象的、概念上的内容。
对象：实实在在存在的一个个体。
对象是由类派生出来的。

类的方法内可以：

定义变量。
调用属性。
调用方法。
不可以定义方法。

Java 学习之路——面向对象及类的成员