精华内容
下载资源
问答
  • java的四大特性

    2019-04-19 20:57:00
    java的四大特性是:封装.继承.多态,抽象. 转载于:https://www.cnblogs.com/qingmuchuanqi48/p/10738739.html

    java的四大特性是:封装.继承.多态,抽象.

    转载于:https://www.cnblogs.com/qingmuchuanqi48/p/10738739.html

    展开全文
  • Java的四大特性

    千次阅读 2018-02-03 19:57:57
    Java的特点有3个,继承,封装,多态 但是我发现有些说法是有四大特性,可能是特性和特点有所区别吧。 四大特性是:继承,封装,抽象,多态。 继承:类似于父子关系,儿子有一些父亲的属性,但又有自己的特性。...

    Java的特点有3个,继承,封装,多态

    但是我发现有些说法是有四大特性,可能是特性和特点有所区别吧。

    四大特性是:继承,封装,抽象,多态。

    继承:类似于父子关系,儿子有一些父亲的属性,但又有自己的特性。继承就是子类获得了父类的所有属性和行为。

    封装:把对象的属性和行为以某种关系整合到一个集合内,就叫做封装。通常封装是通过类来实现的。

    抽象:就是把一类事物的共同特性给整理出来,封装成一个抽象类。所以抽象类并不能实例化一个对象,就比如水果是苹果,香蕉,梨等一类事物抽象出来的。

    多态:即允许以统一的风格来编写程序(比如父类和子类具有相同的方法名称),以处理种类繁多的已经存在的类。重写和重载就是多态的一个体现。

    展开全文
  • Java基础之java的四大特性 首先说下,编程语言分为面向过程和面向对象,而java就是一种面向对象的编程语言。 什么是面向过程编程呢?就是一流程为单位,注重最后的结果。比如小明要从郑州去北京,他第一步就是要先...

     

    首先说下,编程语言分为面向过程和面向对象,而java就是一种面向对象的编程语言。

    什么是面向过程编程呢?就是一流程为单位,注重最后的结果。比如小明要从郑州去北京,他第一步就是要先买火车票,然后去火车站乘车,坐火车到北京。这就是面向过程编程,必须每一步都做到,才会有最后的结果。

    这样一来面向过程编程的缺点就很明显了:1、不利于程序的维护   2、功能之间有很强的关联性,就是说你每一次改动一步,可能就会涉及到好几步的更改。

    那么什么又是面向对象变成呢?就是把一个事物看做一个整体,从事物的属性和功能两方面进行描述

    面向对象编程的特点就是:

    1、面向对象的编程思想更贴近人的正常思维模式

    2、面向对象的编程来源于生活服务于生活

    3、面向对象的编程思想中肯定会用到面向过程的思想

    4、面向对象的特征:抽象、封装、继承、多态

    这就要来了解下什么是对象了。

    任何一个具体的事物都是一个对象,在《java编程思想》中讲到:万事万物皆对象

    任何一个对象都是唯一的,即使两个相近或者相似的事物都是两个不同的对象,就像世界上找不到两片相同的树叶一样,任何一个对象一旦创建就会唯一的存在。而且对象也不一定是一个切实存在的实物,任何一项法规、政策、虚拟物品等都是一个对象。

    抽象      

    就是对同一个事的共有的属性(特征)和方法(功能/行为)进行抽取、归纳、总结。如:汽车都有轮子、发动机等这些就是汽车的属性,汽车能跑、能载人载物等这些就是汽车的功能。这样就可以把汽车的这些功能与属性抽取出来写在一个类中,供汽车这一类事物使用。

    封装  

    在抽象中将属性与方法写在一个类中就是封装,而封装就是为了保证抽象出来的特征和方法的安全性,封装就是包装的过程,注意封装不是绝对的封装,如果其他程序要获取已经封装好的数据,就要通过程序指定的接口或方法才能获取。

    继承

            特点:继承要有一定的层次结构,还要具备一定的可传递性

         子类继承父类的属性和方法,但是私有属性和构造方法除外

         子类除了拥有从父类继承过来的属性和方法外,子类还可以拥有属于自己的属性和方法

         在java中只支持单一继承(也就说一个子类只能有一个父类,但一个父类可以有多个子类)

         判断两个类的继承关系是否成立,可以通过“is-a”(是一个)开判断

    子类不能继承父类的构造方法:父类的构造方法创建的是父类的对象,以为继承要有一定的层次结构,而且要具备一定的额可传递性,如果子类继成父类的构造方法就违反了这一条,所以子类不能继承父类的构造方法。

    如何实现继承

     在java中通过extends关键字来实现继承,语法

    【访问修饰符】  class   子类    extends  父类{   }

    继承的作用

    提高代码的重用性

    一个源文件中可以包含多个类,但只能有一个类带public,而且带public访问修饰符的类的类名要和源文件的文件名相同,main方法也要写在带public的类中。

    当创建子类对象时,那么一定会先执行父类的构造方法创建父类对象,然后在调用子类的构造方法创建子类的对象。而且在创建子类的对象时无论是调用有参数还是无参数的构造方法,JVM都会默认的代用父类的无参数的构造方法创建父类的对象。

    多态

    多态就是指同一种事物在不同的情况下的多种表现形式

    多态的表现形式有:方法重写,方法重载,接口和接口的继承,类和类的继承

    方法的重载:在同一个类中,有多个方法名相同,但参数列表不同的方法,这就是方法的重载,参数列表的不同包括:参数个数,类型,顺序的不同。普通方法和构造方法都可重载,方法重载会根据传递的参数来决定调用哪个方法,返回值不同,其他都相同的情况是构不成方法的重载

    方法的重写:发生在子类继承父类的关系中,父类中的方法被子类继承,方法名,返回值类型,参数完全一样,但是方法体不一样那么说明父类中的该方法被子类重写了。

    目的:当父类中方法,无法满足子类的需求时,那么子类可以对父类的方法进行扩展

    注意:方法重写子类的访问修饰符的范围不能缩小

    展开全文
  • (1)Java的四大特性

    千次阅读 2017-09-12 11:08:11
    Java的四大特性抽象、继承、封装、多态的一个小结

        Java1.7已经出来很长时间了,1.8版本的推出,相比于1.7又增加了很多很多内容,现在又有1.9出来了,所以还是从0开始记录一下自己对Java的理解吧
        Java的定义我就不提了,自己百度哦,就说自己的理解吧,首先它是经典的面向对象的程序设计语言,现在各种面向对象语言层出不穷,之所以Java没有没落的原因,我认为是它在不断的更新自己的内容
        像Java最早诞生的时候有JavaSE,JavaME,JavaEE,但是现在还记得在塞班机上的JavaME的还有多少呢?
        最近这几年比较火的原因是因为各种企业版本的迭代吧 ,先是SSH,然后SSM,再加上spring4的出现,然后又开始炒起了大数据,emmmmm..废话有点多了
    首先写一下Java的四大特性吧

    1.抽象(abstract)

        说到抽象的话就得提一下四个作用范围, public, protected, private
        public 声明的你可以在任何可以引用到的地方进行使用,protected只有其子类可以使用,private是自己玩着用,默认的话同一个package下可以使用。
        我想把抽象和接口都定义为一种概括性吧,抽象使用的是abstract,在类上面使用abstract的话,1.7版本及以下是不能有构造方法的也就是说不能构造的,1.8的时候就允许有构造方法了,举个例子
        
        实际中的抽象常见的情况就是下面这些吧:


    在1.7中我们定义一个NeedShow抽象类,构造函数是不被允许的
    public abstract class NeedShow{
        /**
         * 是否执行成功
         */
        protected boolean execute_flag;
    
        /**
         * 获取执行是否成功
         * @return 执行成功返回为true 执行失败返回为false
         */
        public boolean isExecute_flag() {
            return execute_flag;
        }
    
    
        /**
         * 设置是否执行成功
         * @param execute_flag 执行成功设置为true 不成功设置为false
         */
        public void setExecute_flag(boolean execute_flag){
            this.execute_flag = execute_flag;
        }
    }
    

    但是在1.8中我们可以这样写是允许的
    public abstract class NeedShow{
    	/**
         * 是否执行成功
         */
        protected boolean execute_flag;
    
    
    	/**
         * 获取执行是否成功
         * @return 执行成功返回为true 执行失败返回为false
         */
        public boolean isExecute_flag() {
            return execute_flag;
        }
    
    
    	public NeedShow(boolean flag)
    	{
    	this.execute_flag=flag
    	}
    }


    这样写有这样写的好处,但是同时其子类也必须override这个构造方法,各有利弊吧


    或者你可以考虑将方法抽象了,抽象的方法在其非抽象的子类中是必须实现的,如果其子类是抽象的也可以不实现


    public abstract class NeedShow{
    	/**
         * 是否执行成功
         */
        protected boolean execute_flag;
    
    
    	/**
         * 获取执行是否成功
         * @return 执行成功返回为true 执行失败返回为false
         */
        public abstract boolean isExecute_flag();
    
    
    	public NeedShow(boolean flag)
    	{
    	 this.execute_flag=flag
    	}
    }




    从个人理解的意义上来看接口也是一种抽象吧 1.8 以前的版本是不允许在接口中实现方法的,因此抽象和接口各种相互交织起来产生了各种设计模式不知道接口和抽象类这种具体实现会不会对相应的设计模式也有所改进吧


    举个例子在1.7的时候我们通常声明一个接口大概是长成这样的


    public interface SendEmailMessage extends SendMessage{
    
         /**
          * 发送一个信息
          * @param str
          * @return
          * @throws Exception 因为不同的发送接口抛出的异常不一样,因此使用的是Exception发送消息
          */
         String sendEmailMessage(String str) throws Exception;
    
    
         /**
          * 设置发送给邮箱的信息
          * @param theEmailMessage 被发送的信息
          */
         void setTheEmailMessage(String theEmailMessage);
    
    
         /**
          * 获取发送给邮箱的信息
          * @return
          */
         String getTheEmailMessage();
    
    
         /**
          * 添加一个邮箱
          * @param email  被添加的邮箱
          */
         void addAnEmailReveiver(String email);
    }
    
    


    但是在1.8的时候呢 我们可以这样写:
    public interface  Support<T extends NeedShow>{
    	 
    	 static int count=0;
        /**
         * 判断一个数据的类型
         * @param columnType 需要被判断的类型
         * @param needType 需要的类型
         * @return 如果被判断的类型包括需要的类型返回值为true 其他情况返回为false
         */
        static boolean JudgeType(String columnType,String needType)
        {
            boolean flag=false;
            needType=needType.toUpperCase();
            if(columnType.contains(needType))
            {
                flag=true;
            }
            return flag;
        }
    
    
        default boolean Judge()
        {
          return false;
        }
    }
    


    接口直接写方法,之后的子类没有实现这个方法的必要了,相对会简洁一些吧?
    当然抽象类本身就可以写实际实现的方法,何必再使用default来进行声明呢?


    抽象类已经越来越没有地位了............


    2.继承

       继承是一种对类功能的加强,如果需要对对象加强的话用适配器模式哦。
       我认为在Java种,继承的方式有好多种比如说一个接口继承另一个接口,一个类继承另一个类,而一个实体类去实现一个接口,可能说也是一种继承的体现吧。
       继承使用的关键字是extends 这个关系可以使用在类对类或者接口对接口上
       就像上文中的

    public interface SendEmailMessage extends SendMessage{
    
         /**
          * 发送一个信息
          * @param str
          * @return
          * @throws Exception 因为不同的发送接口抛出的异常不一样,因此使用的是Exception发送消息
          */
         String sendEmailMessage(String str) throws Exception;
    
    
         /**
          * 设置发送给邮箱的信息
          * @param theEmailMessage 被发送的信息
          */
         void setTheEmailMessage(String theEmailMessage);
    
    
         /**
          * 获取发送给邮箱的信息
          * @return
          */
         String getTheEmailMessage();
    
    
         /**
          * 添加一个邮箱
          * @param email  被添加的邮箱
          */
         void addAnEmailReveiver(String email);
    }
    
    

       SendMessage就是一个接口,这样写的话一个类实现SendEmailMessage的时候是不是也需要同时实现SendMessage中的方法,就不用在implements后面跟两个接口了呢?
       上文中写到的NeedShow就是一个抽象的类,如果需要继承的话可以这样写
       
    public  class Information extends NeedShow implements Cloneable,Serializable{
        /*... 省略具体代码了  实际上 Cloneable,Serializable这两个接口中没有方法的  是两个标记性质的接口....*/
        /**
         * 获取执行是否成功
         * @return 执行成功返回为true 执行失败返回为false
         */
        public boolean isExecute_flag() {
            return execute_flag;
        }
       }

       偷个小懒......上面的代码中既有对抽象类的继承,也有对接口的实现......

    3.封装

       如果说抽象,继承提供了一种概念性的东西,而封装的话提供了一种结合吧,外面的使用者只需要知道它提供了什么,而不需要管它怎么实现的,
       在使用的时候就可以很方便的将各个模块分工,而且也不需要客户知道细节,虽然有一种东西叫做反编译不上代码了啊,.......哈哈

    4.多态

       这个东西吗...
       这个东西在代码上就是对于继承或者使用封装的体现吧。


       在引用上是父类的引用但是实际上的实现是其子类的实现方式


       具体举个例子吧


      class DML{
        public void update()
        {
            System.out.println("DML UPdate");
        }
    }
    
    class Insert extends DML{
        public void update()
        {
            System.out.println("Insert Update");
        }
    }
    
    class Update extends DML{
        public void update()
        {
            System.out.println("Update Update");
        }
    }
    
    class Delete extends DML{
        public void update()
        {
            System.out.println("delete update");
        }
    }
    
    class Main{
        public static void main(String args[])
        {
            DML insertdml=new Insert();
            DML updatedml=new Update();
            DML deletedml=new Delete();
            insertdml.update();
            updatedml.update();
            deletedml.update();
        }
    }
    




    这个例子中所有的update方法都重写了父类的update方法
    运行结果如下:
    Insert Update
    Update Update
    delete update




    还有一个很类似的东西叫做重载 就是相同的方法名称,不同的参数长度或是参数类型

    修改DML类如下:


    修改Main类如下:


    class Main{
        public static void main(String args[])
        {
            DML insertdml=new Insert();
            DML updatedml=new Update();
            DML deletedml=new Delete();
            insertdml.update();
            insertdml.update(1);
            insertdml.update(1.1);
            updatedml.update();
            updatedml.update(2);
            updatedml.update(2.1);
            deletedml.update();
            deletedml.update(3);
            deletedml.update(3.1);
        }
    }

    运行结果如下:
    Insert Update
    DML update int:1
    DML update double:1.1
    Update Update
    DML update int:2
    DML update double:2.1
    delete update
    DML update int:3
    DML update double:3.1

    ----------------------------------
    emm....大概就想到这么多了 就先写到这里了

    展开全文
  • Java的四大特性的理解

    千次阅读 2017-11-10 18:57:57
    工作几年再回头聊这些三大特性感觉很easy,的确这是Java的入门知识,但是要把这几个特性说清楚及平时怎么使用,估计好多人含糊其辞,大家估计都是心里明白,爱在心中口难开。这其实是我们对Java的三大特性理解不深,...
  • 面向对象java的四大特性之抽象 抽象就是有点模糊的意思,还没确定好的意思。 就比如,要定义一个方法和类。但还没确定怎么去实现它的具体一点的子方法,那我就可以用抽象类或接口。具体怎么用,要做什么,我不用...
  • 多态:体现在父类可以引用不同子类对象,从而表现出不同行为 多态还表现为重写、重载和泛型 重写是运行时多态,属于引用类型多态。 重载是编译时多态,属于方法多态。 重写需要保持方法名、参数列表和...
  • 封装:java面向对象基础,将对象属性和行为都封装到类中,是现实生活抽象表达,比较关键点是分配属性和行为。比如说“人开车”,车与人都是对象,但是车行驶行为是给车本身而不是人。 优点:模块化、减少...
  • 那天去面试, 面试官问过我一个问题, 说说Java的四大特性吧. hhhh~~~, 所以博主我来回答啦. 封装 封装就是将对象的属性及方法封装成一个整体. 并为对象的方法及属性加上访问权限符(public、private、protected),...
  • Java的四大基础特性

    2019-09-28 05:46:40
    Java的四大基础特性 一、抽象 父类为子类提供一些属性和行为,子类根据业务需求实现具体的行为。 抽象类使用abstract进行修饰,子类要实现所有的父类抽象方法否则子类也是抽象类。 二、封装 把对象的属性和行为...
  • java:四大特性

    2019-09-02 22:33:16
    防止类中方法访问属性,防止对象间交互,提高Java程序安全性。 3.继承:子类和父类之间继承关系,子类可以获取到父类属性和方法。 4.多态:同一消息可以根据发送对象不同而采用多种不同...
  • java 事务四大特性

    2020-01-12 21:35:10
    表示在一次事务操作执行过程中,任意一个操作失败,即导致已成功操作回滚到操作之前状态。 三、隔离性 定义:Isolation: Concurrently executing transactions see the stored information as if they were.....
  • java四大特性

    千次阅读 2016-03-09 11:44:24
    概述:java四大特性包括:抽象、封装、继承、多态,作为java开发者,对这四个特性理解在你职业生涯中贯穿一生,理解透彻程度,将决定你写出代码质量。下面是我个人对这四个特性理解,希望对您有所帮助。...
  • JAVA事务的四大特性

    千次阅读 2018-05-03 22:01:49
    事务的四大特性(ACID): 1、原子性(Atomicity): 事务中所有操作是不可再分割的原子单元。事务中所有操作要么都执行成功,要么都执行失败。 2、一致性(Consistency): 事务执行后,数据库状态与其他业务规则保持一致。...
  • java四大特性详解

    2019-10-03 06:26:44
    Java的四大基础特性一、抽象父类为子类提供一些属性和行为,子类根据业务需求实现具体的行为。抽象类使用abstract进行修饰,子类要实现所有的父类抽象方法否则子类也是抽象类。二、封装把对象的属性和行为(方法)...
  • java 四大特性

    2019-08-17 16:08:57
    类:是一类事物特征抽象集合,表示一个共性产物, 类中包括 属性(静态属性) 和 方法(动态属性) 注: 类中属性和方法也可以没有!!! 对象 :是类实例, 是抽象具体化, 类定义完成后不能直接使用, 如果要使用,必须在...
  • 什么是事务? 事务是逻辑上的一组操作,要么都执行,要么都不执行。 事务最经典也经常被拿出来说例子...事物的四大特性(ACID) 事物的特性 原子性(Atomicity): 事务是最小的执行单位,不允许分割。事务的原子性确保动
  • 秋招面试时经常被问到 「Java有哪些基本特性?面向对象特征有哪些?谈谈对Java中多态理解?在项目中哪些地方用到过多态?」,这个问题还是比较基础,但基础问题不见得每个人都能回答很好,最重要还是要...
  • Java面向对象的四大特性: 一. 抽象:把一类事物共有的属性和行为提出来,形成一个模板。 二. 封装:把抽象出的数据或者对数据操作封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的方法才能够被...
  • 面向对象软件系统 OOPS的四大主要特征: 封装 Encapsulation 继承 Inheritance 多态 Polymorphism 抽象 Abstraction 封装 Encapulation 多态 Polymorphism 多态指的是使用相同的接口来应对不同的底层形式的能力。 ...
  • java——事务四大特性

    2020-07-05 17:36:09
    事务四大特性(ACID): 1、原子性(Atomicity):化学中原子指不可再分基本微粒,数据库中原子性强调事务是一个不可分割整体,事务开始后所有操作要**么全部成功,要么全部失败,不可能停滞在中间某个环节。*...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 984
精华内容 393
关键字:

java的四大特性

java 订阅