Java中面向对象的三大特征：继承、封装、多态

r囧r小猫 2022-01-29 08:27 341阅读 0赞

## 面向对象的三大特征 ##

继承、封装、多态

## 封装 ##

是对象和类概念的主要特征

封装：即把客观事物封装成抽象的类，并且类可以对自己的数据和方法进行权限控制，

封装就是指利用抽象数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象类型的内部，系统的其他部分只有通过包裹在数据外面的被授权的操作，才能够与这个抽象数据类型交流与交互！

### 封装的优点 ###

1.  将变化隔离
2.  便于使用
3.  提高安全性
4.  提高重用性

### 总结 ###

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

## 继承 ##

继承：  
继承是使用已存在的类的定义作为基础建立新的类，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大大的提高开发的效率。

继承的特点：

1.  子类拥有父类非private的属性和方法。
2.  子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3.  子类可以用自己的方式实现父类的方法。（重写）。

Father父类
    class Father {
        
        public String name;
        //父类的私有属性
        private int money;
    
        public Father() {
            this.name = "李明";
            this.money = 1000;
        }
    
        public String getName() {
            return name;
        }
    
        public Father setName(String name) {
            this.name = name;
            return this;
        }
    
        public int getMoney() {
            return money;
        }
    
        public Father setMoney(int money) {
            this.money = money;
            return this;
        }
    
        public void say(){
            System.out.println("我是父亲");
        }
    
        public void speak(){
            System.out.println("父亲是我");
        }
    }
    
    子类Son继承父类Father
    class Son extends Father{
            //子类自己的属性
            public String sonName;
    
            public Son() {
                this.sonName = "李小明";
            }
    
            //子类重写父类的方法
            @Override
            public void say(){
                //子列拥有父类的非private属性
                System.out.println("我的父亲是："+name+"他的存款我不知道...");
                //子类拥有父类非private的方法访问权限
                System.out.println("我的父亲是："+getName()+"但他的存折显示存款为："+getMoney());
            }
            //子类重载父类的方法
            public void speak(int age){
                System.out.println("我的名字是："+sonName+"，年龄："+age);
            }
    }
    
    public class Test{
    
        public static void main(String[] args){
            Son s = new Son();
            s.say();
            s.speak(20);
        }
    }

执行结果：

我的父亲是：李明,他的存款我不知道...
    我的父亲是：李明,但他的存折显示存款为：1000
    我的名字是：李小明，年龄：20

栗子分析：  
父类Father有自己的公有属性`name`，私有属性`money`，同时对外提供了所有属性的公有方法（get/set）

子类Son继承父类Father后，拥有父类所有非private的属性和方法的访问权限，子类Son同时还可以有自己的属性（sonName），儿子知道父亲的名字却不知道父亲具体的存款，但是可以通过从父类继承的getMoney()获取存折中的存款信息。

子类可以重写父类的方法，Son类对父类的say方法在保持方法名、参数列表、返回值不变的情况下，对具体的实现进行重写。

### 父类引用指向子类对象 ###

保持上边代码中Father、Son的内容不变，修改Test类的内容如下：

public class Test{
        public static void main(String[] args){
            //父类引用指向子类对象
            Father s = new Son();
            s.say();
            s.speak(20);//此处会报错
        }
    }

首先来分析下代码

`Father s = new Son();`: 是向上转型即父类引用指向子类对象，它是对Father的对象的方法的扩充，即Father的对象可访问Son从Father中继承来的和Son复写Father的方法，其它的方法都不能访问，包括Father中的私有成员方法。

`s.speak(20);`：此处报错，正是因为`speak(int age)`方法属于子类自己的方法而不是从父类继承而来，在向上转型过程中，父类对象s会遗弃子类中的该方法

### 总结 ###

继承实际上是存在于面向对象程序中的两个类之间的关系。当一个类拥有另一个类的所有数据和操作时，就称这两个类之间具有继承关系！

## 多态 ##

多态即同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果

多态分为编译时多态和运行时多态

1.  编译时多态也称为静态多态，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编译之后会变成两个不同的函数，在运行时谈不上多态。
2.  运行时多态称作动态多态，它是通过动态绑定来实现的，也就是我们所说的多态性，只有在运行期才知道是调用的那个类的方法。

### 多态实现形式 ###

基于继承的多态，基于接口的多态，下面分别给出栗子：

1.  基于继承的多态

class Father {
            public void say(){
                System.out.println("我是父亲");
            }
        }
    
        class Son extends Father{
    
            //子类重写父类的方法
            @Override
            public void say(){
                System.out.println("我是儿子");
            }
        }
    
        class Daughter extends Father{
    
            //子类重写父类的方法
            @Override
            public void say(){
                System.out.println("我是女儿");
            }
        }
    
        public class Test{
    
            public static void main(String[] args){
                Father f = new Father();
                Son s = new Son();
                Daughter d = new Daughter();
                f.say();
                s.say();
                d.say();
            }
        }

执行结果：

我是父亲
    我是儿子
    我是女儿

通过基于继承来实现多态其实是子类对父类的方法进行了重写，以至于在程序执行时不同的子类对同一个方法会有不同的执行结果

2.基于接口的多态：

public interface Animal {
        public void say();
    }
    
    
    public class Dog implements Animal {
    
        @Override
        public void say() {
            System.out.println("狗：汪汪汪");
        }
    }
    
    public class Cat implements Animal {
    
        @Override
        public void say() {
            System.out.println("猫：喵喵喵");
        }
    }
    public class Test{
    
            public static void main(String[] args){
                Dog dog = new Dog();
                Cat cat = new Cat();
                dog.say();
                cat.say();
            }
        }

执行结果：

狗：汪汪汪
    猫：喵喵喵

通过实现Animal接口，不同的对象会有不同的实现，在程序执行时同样也会有不一样的执行结果。

### 多态迷魂阵 ###

继承和多态关系密接，多态是基于继承，继承和多态的理解每个人都各有不同，下面可以看下一个非常有趣的题目，被称为`多态迷魂阵`

出自博客: [https://blog.csdn.net/thinkGhoster/article/details/2307001][https_blog.csdn.net_thinkGhoster_article_details_2307001]

优先级由高到低依次为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
    
    public class A {
        public String show(D obj) {
            return ("A and D");
        }
    
        public String show(A obj) {
            return ("A and A");
        }
    
    }
    
    public class B extends A{
        public String show(B obj){
            return ("B and B");
        }
    
        public String show(A obj){
            return ("B and A");
        }
    }
    
    public class C extends B{
    
    }
    
    public class D extends B{
    
    }
    
    public class Test {
        public static void main(String[] args) {
            A a1 = new A();
            A a2 = new B();
            B b = new B();
            C c = new C();
            D d = new D();
    
            System.out.println("1--" + a1.show(b));
            System.out.println("2--" + a1.show(c));
            System.out.println("3--" + a1.show(d));
            System.out.println("4--" + a2.show(b));
            System.out.println("5--" + a2.show(c));
            System.out.println("6--" + a2.show(d));
            System.out.println("7--" + b.show(b));
            System.out.println("8--" + b.show(c));
            System.out.println("9--" + b.show(d));  
        }
    }
    
    执行结果：
    
            System.out.println("1--" + a1.show(b)); 	A and A
            System.out.println("2--" + a1.show(c));		A and A
            System.out.println("3--" + a1.show(d));		A and D
            System.out.println("4--" + a2.show(b));		B and A
            System.out.println("5--" + a2.show(c));		B and A
            System.out.println("6--" + a2.show(d));		A and D
            System.out.println("7--" + b.show(b));		B and B
            System.out.println("8--" + b.show(c));		B and A
            System.out.println("9--" + b.show(d));      A and D

### 参考感谢 ###

面向对象的本质是什么?封装，继承，多态是到底用来做什么的：[https://bbs.csdn.net/topics/50019051][https_bbs.csdn.net_topics_50019051]  
多态迷魂阵：[https://blog.csdn.net/thinkGhoster/article/details/2307001][https_blog.csdn.net_thinkGhoster_article_details_2307001]

[https_blog.csdn.net_thinkGhoster_article_details_2307001]: https://blog.csdn.net/thinkGhoster/article/details/2307001
[https_bbs.csdn.net_topics_50019051]: https://bbs.csdn.net/topics/50019051