访问权限控制

访问权限控制称为封装，它是面向对象三大特征中的一种，访问控制权限最核心的是：只对需要的类可见。Java中的访问控制权限有四种：public、protected、default、private，特点如下：

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

一、继承

继承是所有面向对象编程语言（OOP，object oriented programming）和Java语言和重要的一部分。只要创建了一个类就隐式的继承了object父类，只是没有指定。如果指定了父类，那就继承于父类，父类继承于object类。

继承的关键字是extends，如果使用了extends显示指定了继承，father就是父类，而son就是子类。例如:

1 Class Father{}
2 
3 Class Son extends Father{}

继承双方拥有共性的特征

 1 package day05;
 2 
 3  
 4 
 5 class Father {
 6 
 7     public void feature() {
 8 
 9         System.out.println("父类的特点");
10 
11     }
12 
13 }
14 
15  
16 
17 class Son extends Father {
18 
19      
20 
21 }

如果Son没有实现自己的方法，那么默认就是用的父类的feature方法。如果子类实现了自己的feature方法，那么相当于重写了父类的feature方法。

二、多态

多态指的是同一个行为具有多个不同表现形式。一个类实例（对象）的相同方法在不同的情形下具有不同表现形式。封装和继承是多态的基础，即多态只是一种表现形式而已。

如何实现多态，实现多态有三种充要条件：

第一，继承

第二，重写父类方法

第三，父类引用指向子类对象

例如：

 1 package day05;
 2 
 3  
 4 
 5 public class Fruit {
 6 
 7     int num;
 8 
 9  
10 
11     public void eat() {
12 
13         System.out.println("吃水果");
14 
15     }
16 
17 }
18 
19  
20 
21 class Orange extends Fruit {
22 
23     @Override
24 
25     public void eat() {
26 
27         super.num = 18;
28 
29         System.out.println("吃了" + num + "个橘子");
30 
31     }
32 
33  
34 
35     public static void main(String[] args) {
36 
37         Fruit fruit = new Orange();
38 
39         fruit.eat();
40 
41     }
42 
43 }

执行结果；

可以看到main方法中Fruit fruit = new Orange();，Fruit类型的对象指向了orange对象的引用，这就是多态—》父类引用指向子类对象，因为Orange继承域Fruit，并且重写了eat方法，所以能表现出多态的形式。

三、组合

组合就是将对象引用置于新类中，它也是提高类的复用性的一种方式。如果想要类具有更多扩展功能，多用组合，少用继承。

 1 package day05;
 2 
 3  
 4 
 5 class MathTeacher {
 6 
 7     private String math;
 8 
 9     private Teacher teacher;
10 
11 }
12 
13  
14 
15 class Teacher {
16 
17     private String MathTeacher;
18 
19 }

MathTeacher引用了Teacher类，通过Teacher类来达到调用teacher中的属性和方法。组合和继承是有区别的，如下：

特征	组合	继承
关系	组合是一种has-a的关系，可以理解为有一个	继承是一种is-a的关系，可以理解为是一个
耦合性	组合的双方是一种松耦合关系	继承的双方是紧耦合
是否具有多态	组合不具有多态和向上转型	继承是多态的继承，可以实现向上转型
时期	组合是运行期绑定	继承是编译期绑定

四、代理

如果A想要调用B类的方法，A不能直接调用，A会在自己的类中创建一个B对象的代理，再由代理调用B的方法。例如：

 1 package day06;
 2 
 3  
 4 
 5  
 6 
 7 class Aim {
 8 
 9     public void todo(){
10 
11         System.out.println("控制");
12 
13     }
14 
15 }
16 
17  
18 
19 class Device {
20 
21     private  String name;
22 
23     private  DeviceControl deviceControl;
24 
25     private  Aim aim;
26 
27     public  void control (Aim aim){
28 
29         aim.todo();
30 
31     }
32 
33 }
34 
35  
36 
37 class DeviceControl{
38 
39     private Device name;
40 
41     private Aim aim;
42 
43     public void control (Aim aim){
44 
45         aim.todo();
46 
47     }
48 
49 }

五、向上转型

向上转型代表了父类和子类之间的关系，其实不仅父类和子类之间有向上转型，还有向下转型，两者的转型范围不一样。

向上转型：通过子类对象（小范围）转化为父类对象（大范围），这种转换是自动完成的，不用强制。
向下转型：通过父类对象（大范围）实例化子类对象（小范围），这种转换不是自动的，需要强制进行指定。

六、static

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

使用static声明的成员变量为静态成员变量，也称为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

Satic String name = “lucy”;

使用static修饰的方法叫做静态方法，静态方法可以直接用类名.方法名进行调用。由于静态方法不依赖于任何对象就可以直接访问，因此对静态方法来说，没有this关键字，实例变量都会有this关键字。在静态方法中不能访问类的非静态方法和非静态成员变量。

 1 public class Demo01 {
 2 
 3     static  void printImg(){
 4 
 5         System.out.println("1234");
 6 
 7     }
 8 
 9 }
10 
11 static除了修改方法和属性，还有静态代码块功能，可以用于类的初始化操作，进而提升程序的性能。
12 
13 public class staticBlock {
14 
15     static {
16 
17         System.out.println("123456");
18 
19     }
20 
21 }

由于静态代码块是随着类的加载执行，所以很多时候会将只需要进行一次的初始化操作放在static代码块中进行。

七、final

final是最终的、最后的意思，它可以修饰类、属性和方法。

final修饰类时，表明这个类不能被继承。final类中的成员变量可以根据需要设置为final，但是要注意final类中的所有成员方法都不会被隐式地指定为final方法。
final修饰方法时，表示这个方法不能被任何子类重写，所以若只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final。
fianl修饰变量分为两种，一种修饰基本数据类型，表示数据类型的值不能进行修改；一种是修饰引用类型，表示对其初始化之后不能再让它指向另一个对象。

欢迎批评指正，提出问题，谢谢！