Java中的封装，继承，多态

封装的体现：

封装的使用细节：

类的属性的处理：

1.一般使用private访问权限

2.提供相应的get、set方法来访问相关属性，这些方法通常是public修饰的。以提供对属性的赋值与读取操作。（注意！boolean变量的get方法是is开头。）

3.一些只用于本类的辅助性方法，可以使用private修饰，希望其他类调用的方法用public修饰。

优点：

1.提高代码的安全性，对象的属性提供专门的方法来修改，而且也可以在set方法里面做一些限制，防止一些非法设置。

2.提高代码的复用性

3.“高内聚”：封装细节，便于修改内部代码，提高可维护性

4.“低耦合”：简化外部调用，便于调用者使用，便于扩展和写作。

在自己的代码中如何体验这样的过程：

生成token密钥，Algorithm algorithm = Algorithm.HMAC256(SECRET);SECRET是一定不能暴露给外部的，只用提供给外部生成密钥的方法。

加密过程中的key的生成都是不能暴露给外部的，但是通过这个key生成的加密字符串的这样的过程需要提供给外部使用

pojo类中，对所有的属性都需要提供给外部set，get方法，以供外部的调用和修改。

限定符号的记忆：

1. 如果不提供任何访问权限修饰词，则意味着它是包访问权限。

默认访问权限没有任何关键字，但通常是指包访问权限（有时也表示为friendly）。这意味着包中所有其他类都可以访问这个成员或方法，但是这个包之外的所有类不可以访问。

2. 使用public关键字，就意味着被声明的成员或方法对所有人都是可以访问的。

3. 使用private关键字，就意味着被声明的成员或方法，除了本类，其他任何类都无法访问。

4. protected新类（称之子类或派生类）通过继承可以复用一个现有类（称之父类或基类），然后扩展基类的成员、方法。有时，基类的创建者会希望某个特定成员，将它的访问权限赋予派生类而不是所有类。public无法做到这一点，为此，引入了protected来完成这一工作。protected也提供包访问权限，也就是说，派生类以及相同包内的其他类都可以访问protected成员或方法。

多态：

多态体现为父类引用变量可以指向子类对象。多态要有继承。多态要有方法的重写

多态好处：

可扩展性。增加新的子类不影响已存在类的多态性，继承性，以及其他特性的运行和操作，实际上新增功能更容易获得多态功能。
接口性。多态是超类通过方法签名。向子类提供一个共同接口，由子类来完善或者覆盖它而实现的。（在方法作为参数很方便）

向上向下转型：

向上转型：子类转为父类

Father f=new Child();//实际的类型应该是子类的类型，调用instanceof（Child）true

f. get()//调用的是子类的方法

正确的向下转型方式：父类转为子类

Chilf c=(Child)f;

c.get();调用的仍然是子类的方法

像下转型错误的方式：（编译无措，但运行出错）

Child c=new Child();

Father f=(Father)c;

f.get();//运行的时候会报错

多态的底层原理：

Java 的方法调用有两类，动态方法调用与静态方法调用。

静态方法调用是指对于类的静态方法的调用方式，是静态绑定的；而动态方法调用需要有方法调用所作用的对象，是动态绑定的。

类调用 (invokestatic) 是在编译时就已经确定好具体调用方法的情况。

实例调用 (invokevirtual)则是在调用的时候才确定具体的调用方法，这就是动态绑定，也是多态要解决的核心问题。

JVM 的方法调用指令有四个，分别是 invokestatic，invokespecial，invokesvirtual 和 invokeinterface。前两个是静态绑定，后两个是动态绑定的。本文也可以说是对于JVM后两种调用实现的考察。

方法表和方法的调用：

class Person { 
 public String toString(){ 
    return "I'm a person."; 
     } 
 public void eat(){} 
 public void speak(){} 
    
 } 
 
 class Boy extends Person{ 
 public String toString(){ 
    return "I'm a boy"; 
     } 
 public void speak(){} 
 public void fight(){} 
 } 
 
 class Girl extends Person{ 
 public String toString(){ 
    return "I'm a girl"; 
     } 
 public void speak(){} 
 public void sing(){} 
}

在3个类被载入到JVM以后，元空间就包含了各自的类的信息。

对于Girl和Boy类，像eat()没有重写的方法还是指向父类的方法代码，speak()重新的就指向自己重写的方法

如果子类改写了父类的方法，那么子类和父类的那些同名的方法共享一个方法表项。

因此，方法表的偏移量总是固定的。所有继承父类的子类的方法表中，其父类所定义的方法的偏移量也总是一个定值。
Person 或 Object中的任意一个方法，在它们的方法表和其子类 Girl 和 Boy 的方法表中的位置 (index) 是一样的。这样 JVM 在调用实例方法其实只需要指定调用方法表中的第几个方法即可。

 class Party{ 
 void happyHour(){ 
 Person girl = new Girl(); 
 girl.speak(); }

（1）在常量池（这里有个错误，上图为ClassReference常量池而非Party的常量池）中找到方法调用的符号引用。
（2）查看Person的方法表，得到speak方法在该方法表的偏移量（假设为15），这样就得到该方法的直接引用。
（3）根据this指针得到具体的对象（即 girl 所指向的位于堆中的对象）。
（4）根据对象得到该对象对应的方法表，根据偏移量15查看有无重写（override）该方法，如果重写，则可以直接调用（Girl的方法表的speak项指向自身的方法而非父类）；如果没有重写，则需要拿到按照继承关系从下往上的基类（这里是Person类）的方法表，同样按照这个偏移量15查看有无该方法。

简单描述就是，父类和子类同一个方法的偏移量是相同的，先从父类中找偏移量，再去调用子类的这个偏移量的方法，判断子类有没有重写这个方法。

对于接口调用，方法表的偏移量是不同的,就不能用偏移量的方式去找方法了

interface IDance{ 
   void dance(); 
 } 
 
 class Person { 
 public String toString(){ 
   return "I'm a person."; 
} 
 public void eat(){} 
 public void speak(){} 
    
 } 
 
 class Dancer extends Person implements IDance { 
 public String toString(){ 
   return "I'm a dancer."; 
  } 
 public void dance(){} 
 } 
 
 class Snake implements IDance{ 
 public String toString(){ 
   return "A snake."; } 
 public void dance(){ 
 //snake dance 
     }

Java 对于接口方法的调用是采用搜索方法表的方式，如，要在Dancer的方法表中找到dance()方法，必须搜索Dancer的整个方法表。

因为每次接口调用都要搜索方法表，所以从效率上来说，接口方法的调用总是慢于类方法的调用的。

参考：

https://blog.csdn.net/SEU_Calvin/article/details/52191321

java中的深浅拷贝：

https://blog.csdn.net/u011289652/article/details/80722187

posted @ 2019-04-10 11:00 LeeJuly 阅读(184) 评论(0) 收藏举报

刷新页面返回顶部

peter_lee