面向对象编程(OOP)

**面向对象的程序(oop)**是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。

传统的结构化程序设计通过**设计一系列的过程（即算法）**来求解问题。一旦确定了这些过程，就要开始考虑存储数据的方式。先要确定如何操作数据，然后再决定如何组织数据，以便于数据操作。而 OOP 却调换了这个次序，将数据放在第1位，然后再考虑操作数据的算法

1 类

类的要素：

类（ class) 是构造对象的模板或蓝图。
由类构造（construct) 对象的过程称为创建类的实例（instance )
对象中的数据称为实例域（ instance field )
操纵数据的过程称为方法（ method )，对于每个特定的类实例（对象）都有一组特定的实例域值
这些值的集合就是这个对象的当前状态（ state )

类的三大特征：

封装：实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互，这意味着一个类可以全面地改变存储数据的方式，只要仍旧使用同样的方法操作数据，其他对象就不会知道或介意所发生的变化
继承：在 Java 中，所有的类都源自于一个“ 神通广大的超类”，它就是 Object

1.1 类之间的关系

在类之间，最常见的关系有

依赖（“ uses-a”）
聚合（“ has-a”）
继承（“ is-a”）

如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。例如，Order 类使用 Account 类是因为 Order 对象需要访问 Account 对象查看信用状态。应该尽可能地将相互依赖的类减至最少。

聚合（aggregation ), 即“ has-a ” 关系，意味着类 A 的对象包含类 B 的对象。例如，一个 Order 对象包含一些 Item 对象

1.2 属性与方法

[public] class 类名{
    访问权限 类型 属性1;
    访问权限 类型 属性2;
    访问权限 类型 属性3;
    访问权限 类型 属性n;
    
    访问权限 返回值类型 方法名1(参数列表){
        方法体;
    }
    访问权限 返回值类型 方法名2(参数列表){
        方法体;
    }
}

public class Rect_V1 {
    public static void main(String[] args) {
        Rect r = new Rect();
        //记录矩形信息，宽和高分别3，4
        r.width = 3;
        r.height = 4;
        //输出矩形信息
        int x = r.area();
        System.out.println("矩形面积是" + x);

    }
}

class Rect{
    public int width;
    public int height;

    public int area(){
        return width * height;
    }
}

//对象的设置使用函数实现
public class Rect_V2 {
    public static void main(String[] args) {
        Rect02 r = new Rect02();
        r.setHeight(3);
        r.setWidth(4);

        System.out.println("矩阵面积是" + r.area());
    }
}

class Rect02{
    private int width;
    private int height;

    public void setHeight(int height) {
        this.height = height;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int area(){return height*width;}
}

2 当前对象

对象的三个主要特性：

对象的行为（behavior) —可以对对象施加哪些操作，或可以对对象施加哪些方法？
对象的状态（state ) —当施加那些方法时，对象如何响应？
对象标识（identity ) —如何辨别具有相同行为与状态的不同对象？

public class Rect_V3 {
    public static void main(String[] args) {
        Rect03 r1 = new Rect03();
        Rect03 r2 = new Rect03();

        //输出对象地址
        System.out.println(r1);
        System.out.println(r2);

        r1.setRect(3, 4);
        r2.setRect(5, 6);
        System.out.println(r1.height);
        System.out.println(r1.width);
        System.out.println(r2.height);
        System.out.println(r2.width);
    }
}

class Rect03{
    public int width;
    public int height;

    public void setRect(int w, int h){
        this.height = h;
        this.width = w;
    }
}

this表示当前对象

当前对象只存在于方法调用之中

3 static关键字

static关键字修饰的属性被称为静态属性或类属性

static关键字修饰的方法被称为静态方法或类方法

类方法的特点是可以使用类直接调用
类方法在调用时没有当前对象，在类方法中不能访问非static的成员

[public] class 类名{
    权限 static 数据类型 属性名;
    权限 static 返回值类型 方法名(){
        方法体;
    }
}

public class StaticKeyword {
    public static void main(String[] args) {
        RectStatic r1 = new RectStatic();
        RectStatic r2 = new RectStatic();

        r1.height = 3;
        r1.width = 4;
        r1.classnum = 1;
        r2.height = 5;
        r2.width = 6;
        r2.classnum = 2;

        System.out.println(r1.classnum);
        System.out.println(r2.classnum);
        System.out.println(RectStatic.classnum);
    }
}

class RectStatic{
    public int width;
    public int height;
    public static int classnum;
}

4 方法重载

在一个类中，可以声明多个方法名相同的方法，但是这些方法要有不同的参数列表。

如果是方法名和参数列表都相同，仅仅有返回值类型不同的情况下不可以重载。

public class FunOverLoad {
    public static void main(String[] args) {
        Rect06 r = new Rect06();

        r.fun1();
        r.fun2(1);
        r.fun3(1, 2);
    }
}
class Rect06{
    public void fun1(){
        System.out.println("this is fun1");
    }
    public void fun2(int x){
        System.out.println("this is fun2");
    }
    public void fun3(int x, int y){
        System.out.println("this is fun3");
    }
}

5 对象的初始化

5.1 属性的初始化

对象中各类变量的默认初始值

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-54dzL2T6-1672287257487)(C:\Users\ALANSHAO\AppData\Roaming\Typora\typora-user-images\image-20221013092728205.png)]$

两种属性初始化方式：

声明属性时直接使用等号初始化
使用构造函数初始化

5.2 构造方法

构造方法特点：

是类的成员方法
方法名与类名相同
没有返回值类型
创建对象时自动调用，且只能在创建对象时调用
没有写明构造函数的类会自动生成无参构造函数

5.2.1 无参构造方法

//无参构造方法
public class Constructor_V1 {
    public static void main(String[] args) {
        RectCons_v1 r = new RectCons_v1();

        System.out.println(r.height);
        System.out.println(r.width);
    }
}
class RectCons_v1{
    public int width;
    public int height;

    RectCons_v1(){
        width = 3;
        height = 4;
        System.out.println("调用无参构造函数");
    }
}

5.2.2 有参构造方法

构造函数可以带参数
构造方法支持重载
如果是有参构造方法，创建对象时要为构造方法传参
一旦类中显式的写出构造方法(无论是否有参)，那么默认的构造方法都会失效

public class Constructor_V2 {
    public static void main(String[] args) {
        RectCons_v2 r1 = new RectCons_v2();
        RectCons_v2 r2 = new RectCons_v2(5, 6);

        System.out.println(r1.width);
        System.out.println(r1.height);
        System.out.println(r2.width);
        System.out.println(r2.height);
    }
}
class RectCons_v2{
    public int width;
    public int height;

    RectCons_v2(){
        System.out.println("这是无参构造方法");
        width = 3;
        height = 4;
    }
    RectCons_v2(int x, int y){
        System.out.println("这是有参构造方法");
        width = x;
        height = y;
    }
}

    public int width;
    public int height;

    RectCons_v2(){
        System.out.println("这是无参构造方法");
        width = 3;
        height = 4;
    }
    RectCons_v2(int x, int y){
        System.out.println("这是有参构造方法");
        width = x;
        height = y;
    }
}