java回忆录—java的三大特性

朴灿烈づ我的快乐病毒、 2022-09-25 00:28 168阅读 0赞

我记得，在第一篇文章就简单介绍了下java的三大特性——封装、继承、多态

今天我们再来学习这三大特性。

**封装**

是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。

使用封装有四大好处：

1、良好的封装能够减少耦合。
    
               2、类内部的结构可以自由修改。
    
               3、可以对成员进行更精确的控制。
    
               4、隐藏信息，实现细节。

封装原则：

将不需要对外提供的内容都隐藏起来。   
    
              把属性隐藏，提供公共方法对其访问。

**继承**

在java中使用extends关键字来表示继承关系。当创建一个类时，总是在继承，如果没有明确指出要继承的类，就总是隐式地从根类Object进行继承。

如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。
    
      在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。

1.子类继承父类的成员变量  
　　  
　　当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：  
　　  
　　1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；  
　　  
　　2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；  
　　  
　　3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

例子：

![这里写图片描述][20160804003112962]

2.子类继承父类的方法  
　　  
　　同样地，子类也并不是完全继承父类的所有方法。  
　　  
　　1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；  
　　  
　　2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；  
　　  
　　3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

3.构造器  
　　  
　　子类是不能够继承父类的构造器。

**多态**

某一个事物，在不同时刻表现出来的不同状态，**父类型的引用可以指向子类型的对象。**

多态前提和体现

——有继承关系(必须)  
    
       ——有方法重写(可有可没有)   
    
       ——有父类引用指向子类对象(必须)

多态中成员访问的特点：

——成员变量
                                   编译看左边，运行看左边
    
       ——成员方法
                                   编译看左边，运行看右边
    
       ——静态方法
                                   编译看左边，运行看左边（静态和类相关，算不上重写，所以，访问还是左边的）

例子：

public class Test2 {
    
        public static void main(String[] args) {
            Animal a = new Cat();
            System.out.println(a.age);
            a.eat();
            a.sleep();
        }
    }
    class Animal {
        int age;
    
        public void eat() {
            System.out.println("吃食物");
        }
        public static void sleep() {
            System.out.println("动物睡觉");
        }
    }
    class Cat extends Animal {
        int age = 10;
        String name;
        public void eat() {
            System.out.println("猫吃鱼");
        }
        public static void sleep() {
            System.out.println("猫在睡觉");
        }
    
        public void zhua() {
            System.out.println("猫抓老鼠");
        }
    }

结果：

![这里写图片描述][20160804010241414]

我们来看看这是为什么？

首先 Animal a = new Cat(); 这行代码中左边为父类，右边为子类，  
System.out.println(a.age); **访问** age **成员变量**的时候，编译的时候只能看到父类的 age ，运行之后为 0 是默认值，所以是父类的。编译时看左边，运行时看右边（**简称左左）**

然后 a.eat(); **访问**的是**方法**，并且子类中重写了这个方法。编译时看左边为父类的eat 方法，而运行的时候则是看的是子类的 eat 方法，就这是多态的体现。**简称左右**

a.sleep（）; **访问**的**静态方法**，因为编译只能看左边的，所以编译时只能看到父类的方法，那么运行的的时候呢，它并不会像重写方法那样，因为静态方法是类相关的，那么就也看父类的。**简称左左。**

Cat 中还有 zhua（） 方法是访问不到的，这也就是多态的弊端：不能访问到子类特有的功能。

那么要如何才能访问得到呢？只有向下转型了。

多态中的转型问题：

——向上转型（Animal a = new Cat()）
    
      从子到父（父类引用指向子类对象）
    
       ——向下转型（Cat c = (Cat)a）
    
      从父到子（父类引用转为子类对象）

将 Animal 对象转成 Cat 对象。就能访问到子类特有的方法了。

[20160804003112962]: /images/20220719/05b8e3a13d5d467daf38d74c34fbfc60.png
[20160804010241414]: /images/20220719/3178e09c21a24170a929021ead9efd88.png