Java 基础之面向对象【封装和多态】

曾经终败给现在 2023-09-29 18:30 10阅读 0赞

## 6. 封装 ##

面向对象三大特性：继承、封装、多态

*  原则：将属性隐藏起来，若要访问，提供某个公共方法对其访问
 *  作用：适度的封装，可以使代码更易维护和理解，也加强了代码的安全性

**步骤**

*  `private` 关键字修饰成员变量
 *  对需要访问的成员变量，提供一对一的公共方法，如：`getName、setName`

### 6.1 private 关键字 ###

*  表示最小权限
 *  可修饰成员变量和成员方法
 *  被修饰的成员变量或方法仅在本来中才能访问

public class Student {
        
        private int age;	// 修饰成员变量
        
        // 对外提供公共方法，用于修改年龄
        public void setAge(int age) {
        
            this.age = age;	
        }
    }

### 6.2 this 关键字 ###

`this` 代表所在类的当前对象的引用（地址值），即对象自己的引用，它可以解决成员变量被隐藏的问题：

this.成员变量

> 注意：方法被哪个对象调用，方法中的 `this` 就代表那个对象。即谁在调用，`this` 就代表谁。

### 6.3 构造方法 ###

对象被创建时，构造方法用来初始化该对象，给对象的成员变量赋初始值，分为有参数和无参数，同一个类可以有多个：

// 构造方法名 与类名同名
    修饰符 构造方法名(参数列表){
        
    	// 方法体
    }
    
    public class Student {
        
        private String name;
        private int age;
        
        // 无参数构造方法
        public Student() {
        }
        
        // 有参数构造方法
        public Student(String name,int age) {
        
            this.name = name;
            this.age = age;
    	}
    }

## 7. 多态 ##

### 7.1 Override 覆写 ###

在继承关系中，子类如果定义了一个与父类**方法签名**完全相同的方法，被称为覆写（`Override`）：

class Person {
        
        public void run() {
        
            System.out.println("Person.run");
        }
    }
    
    // 子类定义了一个一样的 run 方法
    class Student extends Person {
        
        @Override
        public void run() {
        
            System.out.println("Student.run");
        }
    }

**方法签名**

方法声明的两个组件构成了方法签名 ——**方法的名称**和**参数类型**，如：

public double calculateAnswer(double wingSpan, int numberOfEngines,
                                  double length, double grossTons) {
        
        //do the calculation here
    }

以上方法签名是：

calculateAnswer(double, int, double, double)

--------------------

**Override 和 Overload 的区别**

*  `Override`：方法签名相同，并且返回值也相同，`@Override` 可以帮助检查是否正确覆写
 *  `Overload`：方法签名不同

class Person {
        
        public void run() {
        
            System.out.println("Person.run");
        }
    }
    
    // 子类定义了一个一样的 run 方法（方法签名不同）
    class Student extends Person {
        
        @Override
        public void run(String name) {
        
            System.out.println("Student.run");
        }
    }

以上会编译报错，因为 `Student` 和 `Person` 类的 `run()` 方法方法签名不同，即使返回值相同，但愿不能算是正确覆写。

> 注意：方法名相同，方法参数相同，但方法返回值不同，也是不同的方法。在Java程序中，出现这种情况，编译器会报错

### 7.2 多态 ###

指同一行为，具有多个不同表现形式；比如跑的动作，小猫、小狗和大象，跑起来是不一样的，同一行为，通过不同的事物，可以体现出来的不同的形态。

应用在代码中，指的是**针对某个类型的方法调用**，其**真正执行的方法**取决于运行时期**实际类型**的方法，而非**变量的声明类型**，如下所示：

public class Main {
        
        public static void main(String[] args) {
        
            // 实际类型为  Student、引用类型为 Person 的变量
            Person p = new Student();
            p.run(); 	// Student.run
        }
    }
    
    class Person {
        
        public void run() {
        
            System.out.println("Person.run");
        }
    }
    
    class Student extends Person {
        
        @Override
        public void run() {
        
            System.out.println("Student.run");
        }
    }

以上根据多态的特性来推断，`p.run()` 真正的调用的应该是 `Student.run()` 方法。

### 7.3 多态的好处 ###

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展  
性与便利。

多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码：

// 利用多态特性给一个具有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税
    public class PolymorphicClass {
        
        public static void main(String[] args) {
        
            Income[] incomes = new Income[]{
        
                    new Income(3000),
                    new Salary(7500),
                    new StateCouncilSpecialAllowance(25000)
            };
            System.out.println(totalTax(incomes));	// 800
        }
    	
        // totalTax 完全不用关心传入参数类型，它会自动根据其实际类型去调用不同类的 getTax() 方法计算税
        public static double totalTax(Income... incomes) {
        
            double total = 0;
            for (Income income : incomes) {
        
                total = total + income.getTax();
            }
            return total;
        }
    }
    
    // 定义一种收入，需要纳税，比例 10%
    class Income {
        
        protected double income;
    
        public Income(double income) {
        
            this.income = income;
        }
    
        public double getTax() {
        
            return this.income * 0.1;
        }
    }
    
    // 工资收入：超过 5000，20% 比例
    class Salary extends Income {
        
        public Salary(double income) {
        
            super(income);
        }
    
        @Override
        public double getTax() {
        
            if (income < 5000) {
        
                return 0;
            }
    
            return (income - 5000) * 0.2;
        }
    }
    
    // 享受国务院特殊津贴，不用纳税
    class StateCouncilSpecialAllowance extends Income {
        
        public StateCouncilSpecialAllowance(double income) {
        
            super(income);
        }
    
        @Override
        public double getTax() {
        
            return 0;
        }
    }

利用多态，`totalTax()`方法只需要和`Income`打交道，即使需要新增一种收入纳税，只需集成 `Income`，再覆写 `getTax()` 方法，再把新类型传给 `totalTax()` 即可，完全不需要修改任何代码。

### 7.4 覆写 Object ###

所有的 `class` 都继承自 `Object`，同时它也提供了很多方法供我们使用，当提供的功能不能满足时，可以选择覆写：

*  `toString()`：把 `instance` 输出为`String`
 *  `equals()`：判断两个`instance`是否逻辑相等
 *  `hashCode()`：计算一个`instance`的哈希值

import sun.security.timestamp.TSRequest;
    
    public class OverrideObject {
        
        public static void main(String[] args) {
        
            TestOverrideObject t = new TestOverrideObject("rose");
            TestOverrideObject t2 = new TestOverrideObject("lila");
    
            System.out.println(t.toString());   // TestOverrideObject:name = rose
            System.out.println(t.equals(t2));   // false
            System.out.println(t.hashCode());   // 3506511
        }
    }
    
    class TestOverrideObject {
        
        private String name;
    
        public TestOverrideObject(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "TestOverrideObject:name = " + name;
        }
    
        @Override
        public boolean equals(Object o) {
        
            // 比较是否相等，当且仅当o为 TestOverrideObject 类型:
            if (o instanceof TestOverrideObject) {
        
                TestOverrideObject t1 = (TestOverrideObject) o;
                // 并且name字段相同时，返回true
                return this.name.equals(t1.name);
            }
            return false;
        }
    
        // 计算 hash
        @Override
        public int hashCode() {
        
            return this.name.hashCode();
        }
    }

### 7.5 super ###

`super` 在子类的覆写方法中，调用父类中被覆写的方法：

class Person {
        
        public void run() {
        
            System.out.println("Person.run");
        }
    }
    
    class Student extends Person {
        
        @Override
        public void run() {
        
            super.run();	// 调用父类被覆写的方法
        }	
    }

### 7.6 final ###

被 `final` 修饰的方法，不能被覆写：

class Person {
        
        // run() 不能被覆写
        public final void run() {
        
            System.out.println("Person.run");
        }
    }

被 `final` 修饰的类，不能被继承：

final class Person {
        
       
    }

被 `final` 修饰的成员变量，初始化后，不能被修改：

class Person {
        
        public final String name = "rose";
    }
    
    // 不能直接重新赋值
    Person p = new Person();
    p.name = "New Name"; 
    
    // 不过可以通过构造方法重新赋值
    class Person {
        
        public final String name = "rose";
        
        public Person(String name) {
        
            this.name = name;
        }
    }