精华内容
下载资源
问答
  • Java面向对象三大特征

    千次阅读 2020-09-26 21:21:24
    Java面向对象三大特征 1.重写 ​ **概念:**子类继承父类的以后,可以对父类中同名参数的方法进行覆盖的操作。 ​ 应用: 重写以后,创建子类对象后,子类调用父类中同名同参数的方法时,实际上调用的是子类重写后的...

    Java面向对象三大特征

    1.重写

    ​ **概念:**子类继承父类的以后,可以对父类中同名参数的方法进行覆盖的操作。

    应用: 重写以后,创建子类对象后,子类调用父类中同名同参数的方法时,实际上调用的是子类重写后的方法。

    ​ **注意:**子类重写的方法的方法名和形参列表要与父类的保持一致;

    ​ 子类重写方法的访问修饰符不小于父类中被重写的访问修饰符;

    ​ 子类不能重写父类中private修饰的方法;

    ​ 子类重写的方法返回值类型要与父类的相同或者是父类中返回类型的子类;

    ​ 子类重写的方法抛出的异常类型不大于父类父类被重写的方法抛出的异常类型。

    2.多态性

    1. 对象的多态性:父类的引用指向子类的对象。
    2. 编译看左边,运行看右边。
    3. 多态的使用前提是:类的继承关系;方法的重写

    虚方法

    子类定义的与父类同名同参数的方法,在多态的情况下,将此时父类的方法称为虚方法。

    final 关键字

    1. final可以修饰的结构:类 、方法、变量
    2. 修饰类,此类不可以被其他类继承,如String类、System类、StringBuffer类等。
    3. 修饰方法,此方法不可以被重写。
    4. 修饰变量,此变量可以看做是常量。

    static 关键字

    1. static 可以修饰:属性、方法、代码块、内部类。
    2. 静态变量的加载要早于对象的创建。
    3. 静态方法中,只能调用静态的方法或属性。

    abstract关键字

    1. abstract不能用来修饰属性、构造器
    2. 不能修饰私有的方法、静态方法、final的方法、final的类

    接口

    1. 使用interface来定义
    2. jdk7及以前,只能定义全局常量和抽象方法。全局常量public static final 的,但是书写时可以省略不写;抽象方法:public abstract的。jdk8后还可以定义静态方法、默认方法。
    3. 接口不能定义构造器意味着接口不可以实例化。
    4. 接口通过让类去实现(implements)的方式来使用接口。实现类如果没有覆盖接口中所以的抽象方法,则此实现类仍为抽象类。
    5. java类可以实现多个接口,弥补了java单一继承的局限性。
    6. 接口与接口可以继承。
    展开全文
  • java面向对象三大特征及五大原则

    千次阅读 2019-12-28 17:36:56
    一、java面向对象三大特征 1、封装(Encapsulation) 封转是指属性私有化 根据需要提供setter和getter方法来访问属性 隐藏具体属性和实现细节,仅对外开放接口 控制程序中属性的访问级别 目的:增强数据安全性,不...

    java面向对象

    一、java面向对象的三大特征

    1、封装(Encapsulation)

    封转是指属性私有化

    • 根据需要提供setter和getter方法来访问属性
    • 隐藏具体属性和实现细节,仅对外开放接口
    • 控制程序中属性的访问级别

    目的:增强数据安全性,不能让其他用户随意访问和修改数据,简化编程,使用者不必在意具体实现细节,而只是通过外部接口即可访问类的成员

    2、继承(Extend)

    继承是指将多个相同的属性和方法提取出来,新建一个父类

    • java中一个类只能继承一个父类,且只能继承访问权限非private属性和方法
    • 子类可以重写父类中的方法,命名与父类中同名的属性

    目的:代码复用

    3、多态

    多态(Polymiorph)可以分为两种:设计时多态、运行时多态

    设计(编译)时多态:即重载(Overload),是指java允许方法名相同而参数不同(返回值可以相同也可以不同),同一个类中允许存在一个或多个以上的同名函数,只要参数类型或参数个数不同即可

    运行时多态:即重写(Override)必须是在继承体系中,子类重写父类方法,JVM运行时根据调用该方法的类型决定调用那个方法

    目的:增加代码的灵活度

    总结:

    1、java中应尽量减少继承关系,以降低耦合度

    2、使用多态时,父类在调用方法时,优先调用子类的方法,如果子类没有重写父类的方法,则再调用父类的方法

    3、java访问控制符作用范围表:

    本类 本包 子类 外部包
    public
    protected X
    default X X
    private X X X

    ✓:可以访问 X:不可访问

    二、java面向对象的五大原则

    单一职责原则:一个类,最好只做一件事,只有一个引起它变化。每个类应该实现单一的职责,如果不是,那就把类拆分

    开放封闭原则:对扩展开放,对修改封闭

    里氏替换原则:子类必须能够替换其基类,里氏替换原则中说,任何基类可以出现的地方,子类一定可以出现

    依赖倒置原则:依赖于抽象接口,不要依赖于具体实现,简单来说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户于与实现模块间的耦合

    接口隔离原则:使用多个小的专门接口,而不是使用一个大的接口

    展开全文
  • java面向对象三大特征 — 封装

    万次阅读 2017-04-26 21:59:41
    java中比较两个字符串内容是否一致?不要使用==,要使用equals(); 规范:在显示开发中一般实体类的所有成员属性(成员变量)都要封装起来。 实体类:实体类就是用于描述一类事物的就称为实体类。 工具类...

    权限修饰符:控制变量等其他东西的可见范围。

    public :公共的。public修饰的成员变量或方法任何人都可以访问。
    
    private :私有的。private修饰的成员变量或者方法只能在本类中直接进行访问。
    

    封装的步骤:

     1. 使用private修饰需要被封装的属性。
     2. 提供一个公共的方法设置或者获取该私有的成员属性。
         命名规范:
             set 属性名();
             get属性名();
    

    补充:
    java中比较两个字符串内容是否一致?不要使用==,要使用equals();
    

    规范:在显示开发中一般实体类的所有成员属性(成员变量)都要封装起来。
    实体类:实体类就是用于描述一类事物的就称为实体类。   
    
    工具类(Arrays 数组的工具类)
    
    类一般分为2大类:实体类 、 工具类。
    

    封装的好处:
    
     1. 提高数据的安全性;
     2. 操作简单;
     3. 隐藏了实现。
    

    展开全文
  • Java面向对象编程三大特征 - 封装

    千次阅读 多人点赞 2020-03-25 20:45:49
    本文关键字:Java面向对象三大特征、封装。封装是面向对象编程中的三大特征之一,在对封装性进行解释时我们有必要先了解一些面向对象的思想,以及相关的概念。

    写在前面:博主是一只经过实战开发历练后投身培训事业的“小山猪”,昵称取自动画片《狮子王》中的“彭彭”,总是以乐观、积极的心态对待周边的事物。本人的技术路线从Java全栈工程师一路奔向大数据开发、数据挖掘领域,如今终有小成,愿将昔日所获与大家交流一二,希望对学习路上的你有所助益。同时,博主也想通过此次尝试打造一个完善的技术图书馆,任何与文章技术点有关的异常、错误、注意事项均会在末尾列出,欢迎大家通过各种方式提供素材。

    • 对于文章中出现的任何错误请大家批评指出,一定及时修改。
    • 有任何想要讨论和学习的问题可联系我:zhuyc@vip.163.com。
    • 发布文章的风格因专栏而异,均自成体系,不足之处请大家指正。

    Java面向对象编程三大特征 - 封装

    本文关键字:Java、面向对象、三大特征、封装


    封装是面向对象编程中的三大特征之一,在对封装性进行解释时我们有必要先了解一些面向对象的思想,以及相关的概念。当我们想要去描述一系列的关系时我们要用到的最基本结构就是类,其中存在着成员变量和方法,用于记录属性和表达行为,相关知识请进传送门:Java中的基本操作单元 - 类和对象

    一、名词解读

    为了解释封装的概念和作用,需要先来了解一下几个相关的概念,这有助于我们接下来的理解。

    1. 权限修饰符

    当我们在一个类中定义成员变量时,会指定一个变量的类型,除此之外,还会有修饰符的部分,在此给出定义成员变量的规范格式:

    // 定义变量
    [修饰符] 变量类型 变量名称;
    [修饰符] 变量类型 变量名称 = 初始值;
    

    修饰符起到的作用从字面就可以解释,起到一个修饰和限定的作用,可以使用在成员变量之前的修饰符可以是:publicprotectedprivate、final、static。
    修饰符与修饰符之间的顺序没有强制要求,其中public、protected、private被称为权限修饰符,可以用来限定类的属性和方法的访问权限,指明在哪些包的哪些类中能够调用到这些属性或方法,是一种一定会存在的修饰符。需要注意的是,这三个单词不能同时出现,当这三个单词都不出现的时候会被认为是默认访问权限,所以权限修饰符一共有四种:private、默认、protected、public。

    2. 权限对应关系表

    • private:私有权限,只能在定义的类中访问,在其他类中创建的实例均无法访问
    • 默认:同包可访问权限,在没有声明权限修饰符时为默认权限,允许在同包的其他类访问
    • protected:受保护权限,允许有继承关系的子类访问
    • public:公共权限,允许任何类访问

    3. 属性访问

    由于权限修饰符在封装特性中的作用只是实现封装性的一种途径,所以在这里只演示private与public的作用,权限修饰符的其他作用将在后续的文章中继续介绍。

    src
    └──edu
        └──sandtower
            └──bean
                │    Person.java
            └──test
                │    Test.java
    

    以上为实体类与测试类所在的目录结构,Person实体类所在包:edu.sandtower.bean,Test测试类所在包:edu.sandtower.test,相应代码如下:

    package edu.sandtower.bean;
    
    public class Person{
        // 声明公开属性
        public String name;
        // 声明私有属性
        private double money;
    }
    
    package edu.sandtower.test;
    
    import edu.sandtower.bean.Person;
    
    public class Test{
        public static void main(String[] args){
            // 在test包中的Test类中创建Person实例
            Person person = new Person();
            person.name = "小张";// 编译通过,可以访问name属性
            person.money = 500.0;// 编译失败,无法访问money属性
        }
    }
    

    从上面的例子可以看出,虽然依然是使用Person自己的实例在进行属性的调用,但是我们是在另外一个包中的类发生的调用,所以是不能够访问到private修饰的属性的,在刚开始学习时一定要注意区分。

    二、概念阐释

    1. 封装有什么用

    通过使用权限修饰符,我们可以限定类的成员的被访问权限,那为什么要这样做呢?在很多场景下,我们需要确保我们对属性值的操作均是有效操作,不能违背某些规则。
    比如,我们定义了一个Person类,具有name和money两个属性,在买东西时需要扣掉相应的金额,原始写法如下:

    public class Person{
        public String name;
        public double money;
    }
    
    public class Test{
        public static void main(String[] args){
            Person person = new Person();
            person.money = 500;// 初始金额500元
            System.out.println("购买一张桌子,花费200元");
            person.money -= 200;
            System.out.println("购买二手PSP,花费350元");
            person.money -= 350;
            System.out.println("目前余额为:" + person.money);// -50
        }
    }
    

    可以看到,经过代码操作以后可能会导致money的属性为负。看官甲:你自己不加判断赖代码?没错,这个问题我们可以增加判断代码来解决,由于这个操作是对money属性值的操作,我们将它封装成一个方法写在实体类中,于是有了改进之后的代码:

    public class Person{
        public String name;
        public double money;
    
        // 定义一个方法,用于设置money属性的值
        public void setMoney(double money){
            if(money >= 0){
                this.money = money;
            }
        }
    }
    
    public class Test{
        public static void main(String[] args){
            Person person = new Person();
            person.money = 500;// 初始金额500元
            System.out.println("购买一张桌子,花费200元");
            person.setMoney(person.money - 200);
            System.out.println("购买二手PSP,花费350元");
            person.setMoney(person.money - 350);
            System.out.println("目前余额为:" + person.money);// 300
        }
    }
    

    经过上面的改进,我们可以确保money的值不为负数,同时可以看到,当在实体类中定义方法后,使用者需要修改属性值时直接调用方法就可以保证不出问题。但是由于属性值依然可以被直接访问,还不能保证万无一失,于是我们利用权限修饰符使得变量不能被直接访问,同时需要定义一个能够取得属性值的方法。

    public class Person{
        public String name;
        // 声明money属性为private权限
        private double money;
    
        // 定义一个方法,用于设置money属性的值
        public void setMoney(double money){
            if(money >= 0){
                this.money = money;
            }
        }
        // 定义一个方法,用于获取money属性的值
        public double getMoney(){
            return this.money;
        }
    }
    
    public class Test{
        public static void main(String[] args){
            Person person = new Person();
            person.money = 500;// 初始金额500元
            System.out.println("购买一张桌子,花费200元");
            person.setMoney(person.getMoney() - 200);
            System.out.println("购买二手PSP,花费350元");
            person.setMoney(person.getMoney() - 300);
            System.out.println("目前余额为:" + person.getMoney());// 300
        }
    }
    

    通过以上的案例,我们可以看到进行封装有以下几个作用:

    • 防止类的属性被外部代码随意的修改和访问,保证数据的完备性
    • 将对属性的操作转换为方法,更加灵活和安全
    • 使用封装可以隐藏实现的细节:使用者只需要作用,不需要知道过程
    • 在类的定义结构中修改,提高了代码的可维护性,同时又可以不影响外部的使用
    • 通过封装方法可以有效减少耦合
      • 耦合:模块与模块之间,代码与代码之间的关联程度,对属性封装后,和调用相关的代码就会变得相对简单,可以降低耦合

    2. 如何进行封装

    在进行封装时都是出于对属性保护的考虑,可以按照以下两个步骤来进行:

    • 使用权限修饰符
      • 使用private作用在属性上,关闭直接访问的入口
      • 使用public作用在方法上,提供调用的入口
    • 定义与属性存取相关的方法

    在属性关闭后,我们需要通过方法来获取属性的值以及对属性值进行修改。由于有了方法结构,我们就可以对存入的数据进行判断,对不符合逻辑的数据进行处理。

    3. 常规封装方法

    明白了封装的作用后,我们可以通过自定义方法的方式完成对属性的封装。封装方法和类中定义的其他方法在结构上没有任何的区别,同样都是普通的方法,区别主要在于体现在用途方面:

    • 普通方法主要表达该类所能产生的行为
    • 封装方法主要为属性的访问和使用提供了一个入口,作用相对单一

    在进入到框架的学习之后,很多对实体类属性自动赋值的操作都是通过调用封装方法实现的,所以我们必须要知道常规封装方法的名称定义和类型设置规则。
    对于属性来说我们只会进行两种操作:存和取。那么相应的封装方法应该有一对儿

    • get代表取用:既然是取值,那么就要把属性值进行返回,方法的返回值类型与属性类型相同
    • set代表存储:既然是存值,那么就要在参数列表中接收想要存入的值,类型与属性类型相同

    对于命名方面只要遵从驼峰命名法就好,以get或set开头,大写属性名称的首字母,其余不变,看下面一个例子:

    public class Person{
        // 使用private声明属性
        private String name;
        private double money;
    
        // 使用public声明方法,作为操作属性的入口
        public void setName(String name){
            this.name = name;
        }
        public String getName(){
            return this.name;
        }
        public void setMoney(double money){
            // 如有需要,可以在方法中可以自定义其他逻辑
            this.money = money;
        }
        public double getMoney(){
            return this.money;
        }
    }
    

    由于常规封装方法定义的格式和名称都相对固定,所以一般的编译器都自带自动生成封装方法的功能,这样既方便又能降低出错率,大家一定要掌握。

    • Eclipse:

    属性定义完成后,选择source菜单 -> Generate Getters and Setters…
    在这里插入图片描述
    点击Select All(选择所有属性) -> Generate
    在这里插入图片描述

    • IDEA:

    与Eclipse类似,在定义好类的私有属性后,使用快捷键:Alt + Insert

    可以一次性选择多个属性 -> 点击OK

    扫描下方二维码,加入官方粉丝微信群,可以与我直接交流,还有更多福利哦~

    在这里插入图片描述

    展开全文
  • Java面向对象编程三大特征 - 继承

    千次阅读 多人点赞 2020-03-31 18:24:08
    本文关键字:Java面向对象三大特征、继承。继承是面向对象编程的三大特征之一,继承将面向对象的编程思想体现的更加淋漓尽致,允许类和类之间产生关联。
  • Java面向对象编程三大特征 - 多态

    千次阅读 多人点赞 2020-04-06 11:43:48
    本文关键字:Java面向对象三大特征、多态。多态是面向对象编程的三大特征之一,是面向对象思想的终极体现之一。在理解多态之前需要先掌握继承、重写、父类引用指向子类对象的相关概念。
  • Java面向对象三大特征——多态

    千次阅读 2013-12-17 12:00:13
    Java面向对象三大特征——多态 一、引言  Java面向对象的三大特征:继承、封装、多态。其中继承和封装我们平时用的做广泛,但是多态用到的却不多,这是因为多态是一种建立在不同设计模式基础之上的特征。要使用多态...
  • Java面向对象三大特征

    万次阅读 2021-01-26 17:37:44
    Java面向对象三大特征为:封装、继承和多态。 1.封装 Java中的封装是指一个类把自己内部的实现细节进行隐藏,只暴露对外的接口(setter和getter方法)。封装又分为属性的封装和方法的封装。把属性定义为私有的,...
  • Java面向对象三大特征总结

    万次阅读 多人点赞 2017-07-09 14:13:36
    JAVA面向对象三大特征:  面向对象具有继承性(Inheritance)  面向对象具有多态性(Polymorphism)  面向对象具有封装性(Encapsulation) 一、继承  多个类具有共同的属性(成员变量)与行为(成员...
  • Java面向对象三大特征以及理解

    万次阅读 多人点赞 2018-05-26 16:01:36
    Java面向对象三大特征为:封装、继承和多态,本文说说我对三大特性的理解。1.封装Java中的封装是指一个类把自己内部的实现细节进行隐藏,只暴露对外的接口(setter和getter方法)。封装又分为属性的封装和方法的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 644,100
精华内容 257,640
关键字:

java面向对象三大特征

java 订阅