关于面向对象以及三大特征的解释

关于面向对象以及三大特征的解释


面向对象:

              在C语言编程中是面向过程而在Java编程中是面向对象的面向过程更重要的是看重实现的具体过程,面向对象看重的是结果,不管其里面的具体过程,只看结果。

               举一个例子:我们从住的地方到公司去上班的方法:一个是自己开车一个是打车

                面向过程:就是相当于自己开车,自己需要去关注行驶的路线,同时还要自己开车。

                面向对象:就是相当于打车,自己不用关心具体怎么走,你只需要将地点告诉司机就可以了,只管最后到达公司。

             面向对象目前是流行的一种编程思想,它贴近于我们的生活,满足大自然的规律。面向对象有三大特征;封装、继承、多态。

封装:

            面向对象就是以封装为基本,封装就是对外只提供使用,对内部的方法和数据进行包装对面隐藏,能够保证模块的独立性。

详解:封装,就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问。通过这种方式,对象对内部数据提供了不同级别的保护,以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

继承:

            自己新写一个类可以从已有的类(基类)派生出来,派生出来的类是子类,基类是父类。子类可以从父类那里继承到方法和实例变量,并且可以修改和增加方法来满足当前的需要通过继承可以满足代码的重用性。继承分为类继承和实现接口。

     继承类:一个类只能继承一个类,这跟现实生活中也是一样的。有普通类和抽象类,继承抽象类必须实现里面的抽象方法;

     实现接口:实现接口必须实现里面所有的方法,一个类可以实现多个接口

    在这里有必要说一下接口和抽象方法的区别:

            接口:接口是一组行为规范的定义,通俗的说就是生产一个东西时要满足的功能。定义接口时里面的方法都是抽象方法,变量都是默认public static final,方法隐式指定为public abstract。可以实现多个接口。

         抽象方法:抽象方法是表示对象的根源通俗的说就是两个东西的祖宗是什么,比如说猫和狗都是动物。抽象方法可以部分方法是实现方法,部分是抽象方法,只能继承一个抽象类。


抽象方法和接口的比较如下:


在讨论它们之间的不同点之前,我们先看看抽象类、接口各自的特性。

抽象类

抽象类是用来捕捉子类的通用特性的 。它不能被实例化,只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。以JDK中的GenericServlet为例:

1
2
3
4
5
6
7
8
9
public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    // abstract method
    abstract void service(ServletRequest req, ServletResponse res);
 
    void init() {
        // Its implementation
    }
    // other method related to Servlet
}

HttpServlet类继承GenericServlet时,它提供了service方法的实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class HttpServlet extends GenericServlet {
    void service(ServletRequest req, ServletResponse res) {
        // implementation
    }
 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // Implementation
    }
 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // Implementation
    }
 
    // some other methods related to HttpServlet
}

接口

接口是抽象方法的集合。如果一个类实现了某个接口,那么它就继承了这个接口的抽象方法。这就像契约模式,如果实现了这个接口,那么就必须确保使用这些方法。接口只是一种形式,接口自身不能做任何事情。以Externalizable接口为例

1
2
3
4
5
6
public interface Externalizable extends Serializable {
 
    void writeExternal(ObjectOutput out) throws IOException;
 
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

当你实现这个接口时,你就需要实现上面的两个方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Employee implements Externalizable {
 
    int employeeId;
    String employeeName;
 
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        employeeId = in.readInt();
        employeeName = (String) in.readObject();
 
    }
 
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
 
        out.writeInt(employeeId);
        out.writeObject(employeeName);
    }
}


抽象类和接口的对比(速度 添加 默认 实现 访问Java main)

参数抽象类接口
默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现
实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器抽象类可以有构造器接口不能有构造器
与正常Java类的区别除了你不能实例化抽象类之外,它和普通Java类没有任何区别接口是完全不同的类型
访问修饰符抽象方法可以有publicprotecteddefault这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法抽象方法可以有main方法并且我们可以运行它接口没有main方法,因此我们不能运行它。
多继承抽象方法可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口
速度它比接口速度要快接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。
添加新方法如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法,那么你必须改变实现该接口的所有类。

什么时候使用抽象类和接口

  • 如果你拥有一些方法并且想让它们中的一些有默认实现,那么使用抽象类吧。(默认实现)
  • 如果你想实现多重继承,那么你必须使用接口。由于Java不支持多继承,子类不能够继承多个类,但可以实现多个接口。因此你就可以使用接口来解决它。(多重继承)
  • 如果基本功能在不断改变,那么就需要使用抽象类。如果不断改变基本功能并且使用接口,那么就需要改变所有实现了该接口的类。(基本功能不断变化)

Java8中的默认方法和静态方法

Oracle已经开始尝试向接口中引入默认方法和静态方法,以此来减少抽象类和接口之间的差异。现在,我们可以为接口提供默认实现的方法了并且不用强制子类来实现它。这类内容我将在下篇博客进行阐述。

参考博文:http://www.importnew.com/12399.html

多态:

     多态,是指一个类实例的相同方法不同情形有不同表现形式多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同对象的具体操作不同,但通过一个公共的类,它们(那些操作)可以通过相同的方式予以调用。

重写(覆盖)和重载:

重载(Overloading)

 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。

  重载Overloading是一个类中多态性的一种表现。

  Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。

 调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

 重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。


父类方法被默认修饰时,只能在同一包中,被其子类被重写,如果不在同一包则不能重写。

类的方法被protected修饰时,不仅在同一包中,被其子类被重写,还可以不同包的子类重写。

 

重写方法的规则

1)、参数列表必须完全与被重写的方法相同,否则不能称其为重写而是重载。

2)、返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载。

3)、访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)

4)、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如:

父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。

 

而重载的规则:

1)、必须具有不同的参数列表;

2)、可以有不同的返回类型,只要参数列表不同就可以了;

3)、可以有不同的访问修饰符;

4)、可以抛出不同的异常;


重载和重写(覆盖)的特点:


1. Override 特点

  1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配,才能达到覆盖的效果;

  2、覆盖的方法的返回值必须和被覆盖的方法的返回一致;

  3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;

  4、被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。

2.Overload 特点

  1、在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int, float), 但是不能为fun(int, int));

  2、不能通过访问权限、返回类型、抛出的异常进行重载;

  3、方法的异常类型和数目不会对重载造成影响;

  4、对于继承来说,如果某一方法在父类中是访问权限是priavte,那么就不能在子类对其进行重载,如果定义的话,也只是定义了一个新方法,而不会达到重载的效果。



总结:

override(重写)

   1、方法名、参数(参数个数和参数类型)、返回值完全相同。(自身特点)

   2、子类方法不能缩小父类方法的访问权限。(public > protected >private)

   3、子类方法不能抛出比父类方法更宽泛的异常(父类IOException,子类Exception(不行)但子类方法可以不抛出异常)。

   4、存在于父类和子类之间。

   5、方法被定义为final不能被重写。

 overload(重载)

  1、参数类型、个数、顺序至少有一个不相同。 (自身特点)

  2、不能重载只有返回值不同的方法名

  3、存在于父类和子类、同类中。

参考博文:https://blog.csdn.net/linzhaojie525/article/details/55213010

参考博文:https://blog.csdn.net/super_xiaoY/article/details/53484060

阅读更多
上一篇Java 集合Collection常见知识点汇总~
下一篇jvm gc垃圾回收机制和参数说明&&Java JVM 垃圾回收(GC 在什么时候,对什么东西,做了什么事情)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭