Java三大特性：封装、继承、多态

每个特性围绕含义、目的、知识点记录：

封装

1、含义：

将对象的状态信息隐藏在内部，不允许外部程序直接访问，通过该对象的类所提供的方法进行访问。

2、目的：

• 1、限制不合理的访问
• 2、保证对象信息的完成性，便于修改，提高可维护性
• 设计类的原则是，高内聚（功能尽量在内部独立完成），低耦合（暴露尽量少的方法供外部使用）

3、知识点：

访问权限表：

	private	default	protected	pubulic
同一个类中	$\surd$	$\surd$	$\surd$	$\surd$
同一个包中		$\surd$	$\surd$	$\surd$
子类中			$\surd$	$\surd$
全局范围内				$\surd$

继承

1、含义：

继承是子类可以使用父类的成员变量和方法，从上表可以看出，继承的是protected和public的成员变量和方法。

2、目的：

提高代码的复用性，提高开发效率。

3、知识点：

• 1、Java用extends关键字继承，只能继承一个类。
• 2、子类中与父类同名方法，会发生重写，重写要遵循“两同两小一大”的原则。
  • 两同：函数名相同、形参列表相同
  • 两小：返回值类型、抛出异常类型 更小或相同
  • 一大：访问权限比父类方法更大或相同
• 3、重写与重载的区别：重写是子类覆盖父类的方法，而重载是同一个类同，方法名相同，而形参列表不同，根据输入的参数，执行对应的方法。
• 4、要实现多继承，在Java中要用到接口
  • 接口继承用extends，支持多继承
  • 类实现接口用implements，可以实现多个接口
  • 接口中，只有抽象方法、类方法、默认方法，定义的成员变量是常量。默认方法可以由子类的实例调用，它不是类方法，默认方法的作用是：如果只有抽象方法，那么修改一个方法所有的子类都要修改，有了默认方法之后，可以只修改默认方法，所有的子类就同时修改了。
• 5、this和super
  • this总是指向调用该方法的对象，主要有两个用途，一是不用生成新的对象，可以在类的一个方法中调用另一个方法。二是当局部变量与类的成员变量同名时，可以通过this调用类的成员变量。
  • super：当子类重写了父类的方法时，子类的方法可以通过super来调用父类中被重写的方法。调用变量和方法是super.xx，而调用父类的构造器是super(形参)。

多态

含义：

多态指的是根据不同的语义会产生不同的结果。Java中有两种多态机制，编译时的多态和运行时的多态。其中编译时的多态是通过重载实现的，根据输入的形参执行对应的方法。而运行时的多态是通过重写实现的，编译时的类型和执行时的类型不同产生了多态。

目的：

多态可以使程序有良好的扩展，并可以对所有类的对象进行通用处理，让程序的编写更加灵活。

知识点

编译时的多态比较简单，以下的知识点都是运行时多态的知识点：

• 1 运行时的多态的三个条件：

  • 重写
  • 继承
  • 父类的引用指向子类的对象

• 2 多态的执行顺序：

  • 1、this.f(o) 现在子对象中寻找f方法
  • 2、super.f(o) 再在父类中寻找f方法
  • 3、this.f(super(o)) 在子对象中，寻找输入的对象o向上转型为父类对象super(o)的方法
  • 4、super.f(super(o))，找父类中，向上转型后的方法。
  • 其中1、3的执行是有条件的，必须是子类重写了父类的方法，也就是必须存在super.f(o)才能执行this.f(o)，不然会往下一级找。
  • 总体的执行顺序就是，现在子类中找，再在父类中找，然后向上转型，再重复子类->父类的查找顺序。

• 通过一个程序例子说明多态的执行顺序：

class A{
    protected int pA = 5;
    public String show(A obj){
        return ("A and A");
    }
    public String show(D obj){
        return ("A and D");
    }
    public String show(C obj){
        return ("A and C");
    }
    public String show(E obj){
        return ("A and E");
    }

}

class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    public String show(A obj){
        return ("B and A");
    }
}

class C extends B{
}

class D extends B{
}

class E{
}

class F extends E{
}

public static void main(String[] args) {
        A ab = new B();
        B bb = new B();
        C cc = new C();
        F ff = new F();

        // 按照执行顺序是 this.show(o), super.show(o),
        // this.show(super(o)), super.show(super(o))
        // 但是有条件，子类的方法必须在父类中出现

        // 此时的输出是 B and A
        // 这是 A的引用（命名），B的实例，满足多态的条件
        // 按照顺序，先找this.show(o) 即 B(B) 但是（B）在父类A(B)中未出现
        // 所以找super.show(o) 即 A(B)，也没有所以找 this.show(super(o)) 即B（A）
        System.out.println(ab.show(bb));
        // 输出 B and A

        // this.show(o)找不到，找super.show(o) 所以是A(C)
        System.out.println(ab.show(cc));
        // 输出 A and C

        // 输出 A and E，最后到super.show(super(o)) 也就是 A(E)
        System.out.println(ab.show(ff));
    }