02、类、对象 -- 面向对象的核心概念-优快云博客

本文链接：https://blog.youkuaiyun.com/butingdejiaobu/article/details/148028648

一、类（Class）

1、类的理解

类是一个模板或蓝图或 设计图纸，用于描述一类对象的共同的 属性（状态） 和 方法（行为）。
类（class）指定了如何构造对象。

如：
狗的状态有：颜色、名字、品种；
狗的行为有：摇尾巴、叫、吃等。

public class Dog {
    // 唯一编号
    String uniqueNumber;
    String breed;
    int size;
    String color;
    int age;
 
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}

2、类的定义

【修饰符】 class 类名 { …… }

二、类可用的修饰符

public 可与 final、abstract、strictfp 或 sealed 组合。
final 和 abstract 互斥：一个类不能同时被声明为 final 和 abstract。
sealed 类需指定子类：必须通过 permits 列出允许继承的子类。

1、访问控制修饰符

1.1、public

作用：类对所有其他类可见（跨包可见）。
限制：一个 Java 源文件中最多只能有一个public类，且文件名必须与public类名一致。

public class PublicClass { ... } // 其他包可访问

1.2、默认修饰符（包私有，无关键字）

作用：类仅在同一个包内可见。

class PackagePrivateClass { ... } // 仅同包内可访问

2、非访问控制修饰符：

2.1、final

作用：禁止类被继承（不可有子类）。

public final class ImmutableClass { ... } // 不能被继承

2.2、abstract

作用：定义抽象类，不能直接实例化，需被子类继承并实现其抽象方法。

public abstract class Shape {
    public abstract void draw(); // 抽象方法
}

2.3、static（仅用于嵌套类）

作用：声明静态嵌套类，不依赖外部类的实例，可直接访问外部类的静态成员。

public class Outer {
    static class NestedStaticClass { ... } // 静态嵌套类
}

2.4、strictfp

作用：确保类中所有浮点运算遵循 IEEE 754 标准，保证跨平台一致性。
使用位置：
类（类内所有方法的浮点运算均受约束。）。
接口（接口中所有默认方法和静态方法的浮点运算受约束。）。
方法（被修饰的方法有用）。

public /* strictfp */ class NonStrictCalculator {
    // 同一计算可能因平台不同而结果略有差异
    public /* strictfp */ double calculateCircleArea(double radius) {
        return Math.PI * radius * radius;
    }

    public static void main(String[] args) {
        NonStrictCalculator calc = new NonStrictCalculator();
        double area = calc.calculateCircleArea(2.5);
        System.out.println("圆的面积: " + area); 
        // 没有 strictfp 修饰的 类 / 方法：
            // 在某些平台上可能输出 19.634954084936208 。
            // 在其他平台上可能输出 19.634954084936204 。
    }
}

2.5、sealed（Java 17+）

作用：声明 密封类，明确允许哪些子类可以继承（需配合 permits 关键字）自己。
sealed 类：通过 permits 控制直接子类，增强代码安全性。
sealed 类的子类约束：
final：禁止扩展。即：该子类，功能完善了，不需要再有子类了。
sealed：继续封闭继承。即：子类本身也是 密封类，要用permits指定自己的子类。
non-sealed：开放扩展。即：修饰的子类，允许被子类 自由继承。

适用场景：需要精确控制继承层次时（如领域模型、API 设计）。

// 密封类：交通工具
public sealed class Vehicle permits Car, Bicycle, Truck {
    public abstract void start();
}

// final 子类：汽车
public final class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Car started with key");
    }
}

// sealed 子类：卡车，进一步限制子类
public sealed class Truck extends Vehicle permits HeavyTruck, LightTruck {
    @Override
    public void start() {
        System.out.println("Truck started with diesel");
    }
}

// Truck 的子类
public final class HeavyTruck extends Truck { ... }
public final class LightTruck extends Truck { ... }

// non-sealed 子类：自行车，允许自由扩展
public non-sealed class Bicycle extends Vehicle {
    @Override
    public void start() {
        System.out.println("Bicycle started by pedaling");
    }
}

// 自由继承 Bicycle
public class ElectricBicycle extends Bicycle {
    @Override
    public void start() {
        System.out.println("Electric bicycle started with battery");
    }
}

三、对象（Object）

对象是实际存在的类的个体，也称为实例（instance）/ 对象。
每个对象都拥有独立的 状态（属性值）和行为。

public static void main(String[] args) {
    Dog xlq = new Dog();
    // 唯一标识
    xlq.uniqueNumber = "xlq0001";
    xlq.breed = "小猎犬";
    xlq.size = 6;
    xlq.age = 6;
    xlq.color = "橘色";
    xlq.eat();

    Dog dnq = new Dog();
    // 唯一标识
    dnq.uniqueNumber = "dnq0001";
    dnq.breed = "斗牛犬";
    dnq.size = 3;
    dnq.age = 5;
    dnq.color = "浅灰色";
    dnq.eat();
}

1、对象的三个重要特性：

1、对象的行为（behavior）：可以对这个对象做哪些操作或者可以对这个对象应用哪些方法？
一个对象的行为由所能调用的方法来定义。

2、对象的状态（state）：调用那些方法时，对象会如何响应？
每个对象都会保存着描述当前状况的信息，这就是对象的状态。
对象的状态可能会随着时间而发生改变，但这种改变不是自发的。
对象状态的改变必然是调用方法的结果。
如果不经过方法调用就可以改变对象状态。这说明破坏了封装性。

3、对象的标识（identity）：如何区分可能有相同行为和状态的不同对象？
对象的状态并不能完全描述一个对象。
因为，每个对象都有一个唯一的标识（identity，或称身份）。

2、对象的状态会影响它的行为：

如果一个订单“已发货”或“已付款，就应该拒绝要求增删商品的方法调用。
反过来，如果订单是空的，即还没有订购任何商品，就不应该允许“发货”。

3、类与对象之间的关系

对象的抽象化是类，类的具体化就是对象。
类可以看成一类对象的模板 / 设计图纸，对象可以看成该类的一个具体实例。
可以将类想象成制作小甜饼的模具，将对象想象为小甜饼。

由一个类构造（construct）对象的过程称为创建这个类的一个实例（instance）/ 对象。