Java基础-学习笔记06

**06 访问修饰符 封装 继承 多态 **

访问修饰符

• public 公开级别，对外公开
  
• protected 受保护级别，对子类和同一个包中的类公开
  
• default 默认级别，无修饰符，向同一个包的类公开
  
• private 私有级别，只有类自己可以访问，不对外公开
  

修饰符可以用来修饰类中的属性，成员方法以及类
只有默认和public才能修饰类

封装 encapsulation

好处：
1）隐藏实现细节
2）可以对数据进行验证，保证安全合理

封装的实现步骤

• 将属性进行私有化 private，使得外部不能直接修改属性
  
• 提供一个公共的（public）set方法，用于对属性判断并赋值
  

1. public void setXxx(类型 参数名)
2. {
3.   //加入数据验证的业务逻辑
4.   属性 = 参数名；
5. }

复制代码

• 提供一个公共的（public）get方法，用于获取属性的值
  

1. public XX getXxx()
2. {
3.   //权限判断
4.    return Xx;
5. }

复制代码

继承 extends

好处：
代码复用，提高扩展性和维护性

细节：

• 子类继承了全部的属性和方法，但是私有/默认属性和方法不能在子类直接访问，要通过公共的方法去访问；
  （很多环境子类和父类在同一个包内，默认权限也可以直接访问）
  
• 子类必须调用父类的构造器，完成父类的初始化
  （在创建子类对象时，不管使用子类的哪个构造器，默认环境下总会去调用父类的无参构造器（默认执行super()），如果父类没有提供无参构造器，则必须在子类的构造器中用super去订定使用父类的哪个构造器完成对父类的初始化工作，否则编译不通过）
  
• 如果希望指定去调用父类的某个构造器，则显式的调用：super(参数列表)
  （super在使用时，需要放在构造器第一行）
  
• super() 和 this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器。（有this()时，系统不会默认执行super()）
  
• Java的全部类都是Object类的子类，Object是全部类的基类
  
• 父类构造器的调用不限于直接父类。将一致网上追溯直到Object类
  
• 子类最多只能（直接集成）一个父类，即单继承机制
  

继承的本质分析
例：

1. public class Test
2. {
3.   public static void main(String[] args)
4.   {
5.     Son son = new Son(); //分析内存的布局
6.   }
7. }
9. class GrandPa
10. {
11.   String name = "大头爷爷"；
12.   String hobby = "旅游";
13. }
15. class Father extends(GrandPa)
16. {
17.   String name = "大头爸爸";
18.   int age = 39;
19. }
21. class Son extends Father
22. {
23.   String name = "大头儿子";
24. }

复制代码

• 起首在方法区加载父类信息：Object类、Grandpa类、Father类、Son类
  
• 然后在堆中分配地址空间给son：
  * 起首给Grandpa类的属性（name和hobby）分配空间；
  * 再继续给Father类的属性（name和age）分配空间 [注：重名属性name不会冲突,是独立空间] ；
  * 末了还会给Son类的属性分配空间name
  
  
• 末了把堆中的地址返回给栈中的对象名son
  
  

1. System.out.println(son.name);   //大头儿子
2. System.out.println(son.age);   //39
3. System.out.println(son.hobby);   //旅游

复制代码

按照查找关系来返回信息

起首看子类是否有该属性
如果子类有这个属性而且可以访问：则返回信息；
（若是private，内存中也会有这个属性，不外无法直接通过子类访问，则会报错）

如果子类没有这个属性：
则看父类有没有这个属性，
如果父类有该属性而且可以访问：就返回信息；
否则继续向上查找直到Object类

super关键字

• super代表父类的引用，用于访问父类的属性、方法、构造器（private属性和方法除外）；
  
• 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super；如果没有重名，使用super、this、直接访问是一样的结果；
  
• super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷的成员；如果多个上级类中都有同名的成员，则遵循就近级原则（同上查找关系）；
  
  
  
  

多态

方法重写/覆盖

• 方法重写/覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说这个子类的这个方法覆盖了父类的那个方法
  
• 子类的方法的参数、方法名，要和父类方法的参数、方法名一样
  
• 子类方法的返回类型和父类方法返回类型一样，大概是父类返回类型的子类
  
• 子类方法不能缩小父类方法的访问权限
  

方法重写和重载的比较

多态：方法或对象具有多种形态。多态是建立在封装和继承之上的。

详细体现：

• 方法的多态：重写和重载就体现多态
  
• 对象的多态：
  （1）一个对象的编译类型和运行类型可以不一致
  （2）编译类型再定义对象时，就确定了，不能改变
  （3）运行类型是可以变化的
  （4）编译类型看定义时 =号 的左边，运行类型 =号 的右边
  例：
  

1. //父类的引用可以指向子类的对象
2. Animal animal = new Dog(); //animal编译类型是Animal，运行类型是Dog
3. animal.cry(); // 输出的是Dog里重写过的cry
4. animal = new Cat(); // animal的运行类型变成了Cat，编译类型仍是Animal
5. animal.cry(); // 输出的是Cat里重写过的cry
6. animal.catchMouse();//error！这是Cat的特有方法，无法调用！

复制代码

细节：

• 前提：两个对象（类）存在继承关系
  
• 多态的向上转型
  
  
  
  • 本质：父类的引用指向了子类的对象
    
  • 语法：父类类型 引用名 = new 子类类型()
    
  • 特点：编译类型看左边，运行类型看右边
    
  • 调用规则：
    * 可以服从访问权限调用父类中的全部属性和成员，但是不能调用子类的特有属性和方法，因为在编译阶段，能调用哪些成员是由编译类型来决定的。
    * 最终运行结果看子类的详细实现，与前面查找关系规则一致。
    
  
  
• 多态的向下转型
  
  
  
  • 语法：子类类型 引用名 = （子类类型）父类引用
    Cat cat = (Cat) animal
    （相当于有cat、animal两个引用指向这个子类对象了）
    
  • 只能强转父类的引用，不能强转父类的对象
    
  • 求父类的引用必须指向的是当前目的类型的对象
    
  • 向下转型后，可以调用子类类型中全部的成员
    
  
  
• 属性没有重写之说，属性的值看编译类型
  例：
  
  

1. public class Test
2. {
3.   public static void main(String[] args)
4.   {
5.     Base base = new Sub();
6.     System.out.println(base.cout); // 10
7.     Sub sub = new Sub();
8.     System.out.println(base.cout); // 20
9.   }
10. }
12. class Base // 父类
13. {
14.   int count = 10; // 属性
15. }
16. class Sub extends Base //子类
17. {
18.   int count = 20; // 属性
19. }

复制代码

• instanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型
  

Java的重要特性：动态绑定机制

• 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
  
• 当调用对象属性时，没有动态绑定机制，那边声明，那边使用
  例：
  

1. // main中
2. A a = new B(); // 向上转型
3. System.out.println(a.sum()); // 30
4. System.out.println(a.sum1()); // 20
5. //父类
6. class A
7. {
8.   public int i = 10;
9.   public int sum()
10.   {
11.     return getI()+10;   // getI()是方法，调用时，与运行类型绑定
12.   }
13.   public int sum1()
14.   {
15.     return i + 10;      // i 是属性，在A类里，或者说作用域就近原则，对应就是10
16.   }
17.   public int getI()
18.   {
19.     return i;
20.   }
21. }
22. //子类
23. class B extends A
24. {
25.   public int i = 20;
26.   public int getI()
27.   {
28.     return i;
29.   }
30. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。