Java面向对象 访问控制权限

访问控制权限

访问控制权限⼜称为封装 ，它是⾯向对象三⼤特性中的⼀种，我之前在学习过程中经常会忽略封装，⼼想这不就是⼀个访问修饰符么，怎么就是三⼤特性的必要条件了？后来我才知道，如果你信任的下属对你隐瞒 bug，你是根本不知道的。

访问控制权限其实最核⼼就是⼀点：只对需要的类可⻅。

• Java中成员的访问权限共有四种，分别是 public、protected、default、private，它们的可⻅性如下

	private	default	protected	public
同一类	✔	✔	✔	✔
同一包中的类		✔	✔	✔
子类			✔	✔
其他包中的类				✔

• ✔表示是可以进行访问

继承

继承是所有 OOP(Object Oriented Programming) 语⾔和 Java 语⾔都不可或缺的⼀部分。只要我们创建了⼀个类，就隐式的继承⾃ Object ⽗类，只不过没有指定。如果你显示指定了⽗类，那么你继承于⽗类，⽽你的⽗类继承于 Object 类。

继承的关键字是 extends ，如上图所示，如果使⽤了 extends 显示指定了继承，那么我们可以说Father 是⽗类，⽽ Son 是⼦类，⽤代码表示如下

class Father{}

 class Son extends Father{}

• 继承双⽅拥有某种共性的特征

 class Father{
 public void feature(){
 System.out.println("⽗亲的特征");
  }
 }
 class Son extends Father {
 }

如果 Son 没有实现⾃⼰的⽅法的话，那么默认就是⽤的是⽗类的 feature ⽅法。如果⼦类实现了⾃⼰的 feature ⽅法，那么就相当于是重写了⽗类的 feature ⽅法，这也是我们上⾯提到的重写了。

多态

多态指的是同⼀个⾏为具有多个不同表现形式。是指⼀个类实例（对象）的相同⽅法在不同情形下具有
不同表现形式。封装和继承是多态的基础，也就是说，多态只是⼀种表现形式⽽已。

• 如何实现多态？多态的实现具有三种充要条件
  • 继承
  • 重写⽗类⽅法
  • ⽗类引⽤指向⼦类对象

⽐如下⾯这段代码

public class Fruit {
    int num;
    public void eat(){
        System.out.println("eat Fruit");
    }
 }
 public class Apple extends Fruit{
    @Override
    public void eat() {
        super.num = 10;
        System.out.println("eat " + num + " Apple");
    }
    public static void main(String[] args) {
        Fruit fruit = new Apple();
        fruit.eat();
    }
 }

你可以发现 main ⽅法中有⼀个很神奇的地⽅，Fruit fruit = new Apple()，Fruit 类型的对象竟然指向了 Apple 对象的引⽤，这其实就是多态 -> ⽗类引⽤指向⼦类对象，因为 Apple 继承于Fruit，并且重写了 eat ⽅法，所以能够表现出来多种状态的形式。

组合

组合其实不难理解，就是将对象引⽤置于新类中即可。组合也是⼀种提⾼类的复⽤性的⼀种⽅式。如果你想让类具有更多的扩展功能，你需要记住⼀句话多⽤组合，少⽤继承。

public class SoccerPlayer {
    
    private String name;
    private Soccer soccer;
    
}
 public class Soccer {
    
    private String soccerName;    
}

代码中 SoccerPlayer 引⽤了 Soccer 类，通过引⽤ Soccer 类，来达到调⽤ soccer 中的属性和⽅法。
组合和继承是有区别的，它们的主要区别如下。

代理

除了继承和组合外，另外⼀种值得探讨的关系模型称为 代理。代理的⼤致描述是，A 想要调⽤ B 类的⽅法，A 不直接调⽤，A 会在⾃⼰的类中创建⼀个 B 对象的代理，再由代理调⽤ B 的⽅法。例如如下代码

public class Destination {
    public void todo(){
        System.out.println("control...");
    }
 }
 public class Device {
    private String name;
    private Destination destination;
    private DeviceController deviceController;
    public void control(Destination destination){
        destination.todo();
    }
 }
 public class DeviceController {
    private Device name;
    private Destination destination;
    public void control(Destination destination){
        destination.todo();
    }
 }

向上转型

• 向上转型代表了⽗类与⼦类之间的关系，其实⽗类和⼦类之间不仅仅有向上转型，还有向下转型，它们
  的转型后的范围不⼀样
  向上转型 ：通过⼦类对象(⼩范围)转化为⽗类对象(⼤范围)，这种转换是⾃动完成的，不⽤强制。
  向下转型 : 通过⽗类对象(⼤范围)实例化⼦类对象(⼩范围)，这种转换不是⾃动完成的，需要强制
  指定。

static

static 是 Java 中的关键字，它的意思是 静态的 ，static 可以⽤来修饰成员变量和⽅法，static⽤在没有创建对象的情况下调⽤ ⽅法/变量。

• ⽤ static 声明的成员变量为静态成员变量，也成为类变量。类变量的⽣命周期和类相同，在整个应⽤程序执⾏期间都有效。

static String name = "ikvn";

• 使⽤ static 修饰的⽅法称为静态⽅法，静态⽅法能够直接使⽤类名.⽅法名 进⾏调⽤。由于静态⽅法不依赖于任何对象就可以直接访问，因此对于静态⽅法来说，是没有 this 关键字的，实例变量都会有 this 关键字。在静态⽅法中不能访问类的⾮静态成员变量和⾮静态⽅法，

static void printMessage(){
 System.out.println("cxuan is writing the article");
 }

static 除了修饰属性和⽅法外，还有静态代码块 的功能，可⽤于类的初始化操作。进⽽提升程序的性能。

public class StaicBlock {
 static{
 System.out.println("I'm A static code block");
    }
 }

由于静态代码块随着类的加载⽽执⾏，因此，很多时候会将只需要进⾏⼀次的初始化操作放在 static 代码块中进⾏。

final

• final 的意思是最后的、最终的，它可以修饰类、属性和⽅法。
  • final 修饰类时，表明这个类不能被继承。final 类中的成员变量可以根据需要设为 final，但是要注
    意 final 类中的所有成员⽅法都会被隐式地指定为 final ⽅法。
  • final 修饰⽅法时，表明这个⽅法不能被任何⼦类重写，因此，如果只有在想明确禁⽌该⽅法在⼦
    类中被覆盖的情况下才将⽅法设置为 final。
  • final 修饰变量分为两种情况，⼀种是修饰基本数据类型，表示数据类型的值不能被修改；⼀种是
    修饰引⽤类型，表示对其初始化之后便不能再让其指向另⼀个对象。