乐趣区

Java-Core四对象与类

jiezi

四. 对象与类

4.1 面向对象程序设计概述

4.1.4 类之间的关系

  • 分类：依赖（uses a），聚合（has a），继承（is a）

  • 依赖

    • 一个类的方法操纵另一个类的对象
    • 最常见的关系，最明显的关系
    • 设计中应该遵循尽可能减少依赖，依赖越低，耦合越低

  • 聚合

    • 一个类中包含着另一个类

4.2 使用预定义类

4.2.1 对象与对象变量

1. 对象变量

  • 定义：引用变量的部分

  • 注意

    • 一个对象变量不包含对象，仅仅引用一个对象

4.3 用户自定义类

4.3.4 构造器

  • 规则

    • 构造器与类同名
    • 每个类可以有一个及以上的构造器
    • 构造器可以有 0 至多个参数
    • 构造器没有返回值
    • 构造器随着 new 操作符的执行被调用，无法通过构造器重新设置实例域

4.3.5 隐式参数与显式参数

  • 隐式参数：方法名面前的类对象，使用 this 关键字代表

  • 显式参数：传入方法的参数

    <!– 实现 –>

    public void raise(double ByPercent){double raise = this.salary * ByPercent;}
/* conclusion
1.ByPercent 为显式参数
2.this 为隐式参数，代表类对象
*/

4.3.6 封装的优点

1. 域访问器

  • 定义：返回实例域值的机器

  • 组成

    • 私有数据域
    • 公有的域访问器方法
    • 公有的域更改器方法

  • 格式：public 修饰，返回值为实例域值

    <!– 实现 –>

    // 需求：返回薪水值
public class Worker{private int salary;}
// 域访问器
public int getSalary(){return salary;}

  • 优势

    • 支持修改内部实现，不影响其他代码
    • 支持执行错误检查 <!– 比如判断传入数据是否为空 –>

  • 注意

    • 如果需要返回一个可变数据域的拷贝，使用 clone()

      <!– 实现 –>

      class E{
    ...
    public Date getH(){return (Date)hire.clone();}
}

4.4 静态域和静态方法

4.4.1 静态域

  • 定义：被 static 修饰的域
  • 特点：静态域属于类，不属于对象。也就是所有对象共享一个静态域

4.4.2 静态常量

  • 常用的静态常量

    • Math.PI

      <!– 实现 –>

      // 定义
public class Math {public static final double PI = 3.123453454354535345;}
// 使用
public class TestMath {public static void main(String[] args) {
        int l = 5;
        double circle = l*l*Math.PI;
        System.out.println(circle);
    }
}
    • System.out

4.4.3 静态方法

  • 定义：不能向对象实施操作的方法（静态方法是没有 this 参数的方法）

  • 使用场景

    • 方法不需要访问对象状态，所需参数都是通过显示参数提供 <!– 比如 Math.pow–>
    • 方法只需要访问类的静态域 <!– 比如返回静态域内容的 get 方法 –>

4.4.4 工厂方法

  • 定义：静态方法模式，支持返回预期的对象

  • 步骤

    • 创建抽象产品类，定义公共的接口 <!– 需要获得工厂中多种对象，返回方法的变量类型能够统一 –>
    • 创建具体产品类
    • 创建工厂类，创建静态方法来返回具体产品类

    • 外部类调用工厂类中的静态方法获得相应的产品对象

      <!– 实现 –>

      // 抽象产品类，方便产生多种产品类型
abstract class Product {protected abstract void show();
}
      // 具体产品类 1
public class Product1 extends Product {@Override public void show() {System.out.println("Product1");
    }
}

// 具体产品类 2
public class Product2 extends Product {@Override public void show() {System.out.println("Product2");
    }
}

// 具体产品类 3
public class Product3 extends Product {@Override public void show() {System.out.println("Product3");
    }
}
      // 工厂类，根据传入参数类型返回相应的对象
public class ProductFatory {public static Product getProduct(String s){switch (s){
            default:return null;
            case "a" :return new Product1();
            case "b" :return new Product2();
            case "c" :return new Product3();}
    }
}
      // 测试类
public class TestFactory {public static void main(String[] args) {ProductFatory.getProduct("a").show();
        ProductFatory.getProduct("b").show();
        ProductFatory.getProduct("c").show();}
}
/* output 
Product1
Product2
Product3
*/

  • Pros

    • 创建实例和使用实例解耦

  • Cons

    • 工厂类出现错误时，整个系统受到影响
    • 违背“开放 - 关闭原则”，新增类需要修改工厂逻辑，工厂类将冗杂

4.5 方法参数

  • 规则：java 按值调用，方法得到的是所有参数值的拷贝

    • 无法修改基本数据类型的值。

      <!– 实现 –>

      // 修改值的方法
public class Method {public void changeNum(int num){num = num * 3;}
}

// 测试类
public class TestMethodParam {public static void main(String[] args) {
        int n = 5;
        Method method = new Method();
        System.out.println(n);
        method.changeNum(n);
        System.out.println(n);
    }
}
/* output
5
5
*/

/* conclusion
因为 num 被初始化为 n 值的拷贝，因此修改 num 不会影响 n 的值
*/
    • 支持修改对象参数的状态

      原因：形参是对 对象引用的拷贝，因此指向的是对象，当发生修改时，会修改对象中的值

    • 不支持让对象参数引用一个新的对象

      原因：形参是对象引用的拷贝，修改引用无法对原引用造成影响

      原理图：

4.6 对象构造

4.6.1 重载

1. 方法的签名

  • 格式：方法名以及参数类型

    <!– 实现 –>

    indexOf(int)

4.6.6 调用另一个构造器

  • 格式：在类中的构造器中使用 this 关键字调用另一个构造器

    <!– 实现 –>

    public class TestCons {
    private int age;
    private String name;

    private TestCons(int aAge) {this.age = aAge;}

    private TestCons(int aAge , String aName) {this(5);
        this.name = aName;
    }

    public static void main(String[] args) {TestCons testCons = new TestCons(4,"Toyz");
        System.out.println(testCons.age);
        System.out.println(testCons.name);
    }
}

4.6.7 初始化数据的方法

  • 方法

    1. 在构造器中设置值

      <!– 实现 –>

      private TestCons(int aAge) {this.age = aAge;}

    2. 在声明中赋值

      <!– 实现 –>

      private int age = 5;

    3. 在初始化块中赋值（不常见，通常可以在构造器中实现）

      <!– 实现 –>

      {int age = 5;}

  • 执行顺序

    1. 所有数据域初始化为默认值
    2. 根据在类中的声明顺序，执行初始化语句（上述方法 2）和初始化域（上述方法 3）
    3. 执行构造器（上述方法 1）

4.10 类设计技巧

  • 一定要保证数据私有性
  • 一定要对数据初始化
  • 不要在类中使用过多的基本类型（使用其他类来代替）
  • 不是所有域都需要独立的域访问和修改器
  • 对职责过多的类进行分解（不然会导致耦合过高）
  • 类名和方法名能够体现职责
  • 优先使用不可变的类
退出移动版