面向对象的理解（三个特性：继承、封装、多态）

面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术 ， 发展到一定阶段后的产物。

面向对象：专指在程序设计中采用封装、继承、多态等设计方法

                                    

继承：

       1、面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。注意：在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。（继承是从已经有的类中派生出新的类，子类继承了父类的属性和行为，并且根据自己的需求扩展出新的行为，从而提高了代码的复用性）

       2、继承概念的实现方式有三类：实现继承（extends关键字）、接口继承和可视继承。

             （1）实现继承是指使用基类的属性和方法而无需额外编码的能力；java只允许单继承。

             （2）接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

             （3）可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

         例子：有学生类、老师类、员工类，他们三个类中存在着重复的代码，都有共同的属性：name、age；共同的方法：sleep；此时我们就可以把他们共同的属性和方法单独新建一个类，类的名称就叫Person,（这个可以怎么理解，学生、老师、员工都是人，他们都有名字、年龄，他们都要睡觉）Person类就是把他们的共性提取出来并把它封装起来。现在Person类提取出来了，那么怎么才能让它和学生、老师、员工的类有关系呢？这个时候就要使用继承了，他们继承关系如下：Person类就是父类(也有叫超类、基类、被拓展类)，学生、老师、员工都继承于Person类，这些叫子类(也有叫拓展类)，当子类集成父类之后，就具有父类的某些行为。由此可见，父类存放的是共性，而子类存放的是特性。从上面的列子可以看出，继承关系解决的是代码重复的问题。

 

封装：

        1、把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏，外界无法直接操作和修改。

            2、封装实际上有两个方面的含义: 把该隐藏的隐藏起来. 、把该暴露的暴露出来.。这两个方面都需要通过使用 Java 提供的访问控制符来实现。

                 Java 提供了 3 个访问控制符：private、protected、public

                                 private(当前类访问权限)：如果类里的一个成员(包括成员变量 / 方法 / 和构造器等)使用 private 访问控制符来修饰. 则这个成员只能在当前类的内部被访问. 很显然, 这个访问控制符用于修饰成员变量最合适. 使用它来修饰成员变量就可以把成员变量隐藏在该类的内部.

                              protected(子类访问权限)：同一个包中的其它类访问, 也可以被不同包中的子类访问， 在通常情况下, 如果使用 protected 来修饰一个方法, 通常是希望其子类来重写这个方法. 关于父类 / 子类 我以后会讲到。

                                    public(公共访问权限)：这是一个最宽松的访问控制级别.如果一个成员(包括成员变量 / 方法 / 和构造器等) 或者一个外部类使用 public 访问控制符修饰, 那么这个成员或外部类就可以被所有类访问,不管访问类和被访问类是否处于同一个包中, 是否具有父子继承关系。

 

多态： 

    Java多态性的概念也能够被说成“一个接口。多个方法”。     

Java中的多态性的实现方式：1：方法的重载和重写(覆盖)；  

          2：可以用父类的引用指向子类的具体实现，而且可以随时更换为其他子类的具体实现；

 

来个例子：我们先搞个父类Animal:

package com.java1234.chap03.sec13;
2  
3 public class Animal {
4  
5     public void say(){
6         System.out.println("我是一个动物");
7     }
8 }

再搞两个子类，分别是Dog和Cat类，重写父类方法say：

package com.java1234.chap03.sec13;
2  
3 public class Cat extends Animal{
4  
5     public void say(){
6         System.out.println("我是一个猫");
7     }
8 }

package com.java1234.chap03.sec13;
2  
3 public class Dog extends Animal{
4  
5     public void say(){
6         System.out.println("我是一个狗");
7     }
8 }

然后我们写个Test测试类：

package com.java1234.chap03.sec13;
 2  
 3 public class Test {
 4  
 5     public static void main(String[] args) {
 6         Dog dog=new Dog();
 7         dog.say();
 8          
 9         Cat cat=new Cat();
10         cat.say();
11     }
12 }

运行输出：

我是一个狗

我是一个猫

这个大家肯定能看明白 简单的子类继承 以及实例化对象 调用方法 ；

 

 

 

下面我来用多态测试，父类引用指向子类具体实现：

 

package com.java1234.chap03.sec13;
 2  
 3 public class Test {
 4  
 5     public static void main(String[] args) {
 6         // 父类引用指向Dog子类的具体实现
 7         Animal animal=new Dog();
 8         animal.say();
 9          
10         // 更换实现
11         animal=new Cat();
12         animal.say();
13     }
14 }

 

运行输出：

我是一个狗

我是一个猫

 

对象的转型：

向上转型：子类对象->父类对象 安全

向下转型：父类对象->子类对象 不安全

 

比如上面的实例：Animal animal=new Dog(); 就是后面的new Dog() 子类对象 向上 Animail animal 转型 是安全的；

 

向下转型 是父类对象强制转换成子类对象：我们来改下Test类：

package com.java1234.chap03.sec13;
 2  
 3 public class Test {
 4  
 5     public static void main(String[] args) {
 6         // 父类引用指向Dog子类的具体实现
 7         Animal animal=new Dog();
 8         animal.say();
 9          
10         // 向下转型
11         Dog dog=(Dog) animal;
12         dog.say();
13          
14         // 向下转型  因为animal指向的是Dog具体实现 所以会报错
15         Cat cat=(Cat)animal;
16         cat.say();
17     }
18 }

运行报错：

我是一个狗

我是一个狗

Exception in thread "main" java.lang.ClassCastException: com.java1234.chap03.sec13.Dog cannot be cast to com.java1234.chap03.sec13.Cat

at com.java1234.chap03.sec13.Test.main(Test.java:15)

 

转换异常 所以说向下转型是不安全的，我们必须知道具体的实现类；

我们上面用的继承方式演示了多态 其实在实际开发中 更多的是用接口

 

 

总的来说：同一个消息可以根据发送对象的不同而采用多种不同的行为方式。

 

   

转载于:https://www.cnblogs.com/Jones-dd/p/8831311.html