精华内容
下载资源
问答
  • 封装继承多态

    2020-10-20 10:44:46
    封装继承多态 封装 封装(数据的隐藏)禁止直接访问一个对象中 数据的直接表示,而应通过操作接口访问,称为信息隐藏。 属性私有 get/set get/set 方法 1.提供操作这些属性的方法 2.提供public 的 get/set 方法 ...

    封装继承多态


    封装

    1. 封装(数据的隐藏)禁止直接访问一个对象中 数据的直接表示,而应通过操作接口访问,称为信息隐藏。
    2. 属性私有 get/set
      在这里插入图片描述

    get/set 方法

    1.提供操作这些属性的方法

    2.提供public 的 get/set 方法
    在这里插入图片描述

    继承


    extends
    在这里插入图片描述


    object类

    object是所有类的父类

    super

    1.super调用父类的构造方法,必须在构造方法的第一个

    2.super 必须只能出现在子类的方法或构造方法中

    3.super和this 不能同时调用构造方法

    this

    this:本身调用这个对象

    没有继承也可以使用

    this(); 本类的构造

    super:代表父类对象的引用

    只能在继承条件下使用

    super();父类的构造

    在这里插入图片描述

    方法重写
    1. 需要有继承关系,子类重写父类的方法
    2. 方法名必须相同
    3. 参数列表必须相同

    在这里插入图片描述


    多态

    同一方法可以根据发送对象的不同采取不同的行为方式
    1. 多态是方法的多态,属性没有多态
    2. 父类 和子类 有联系
    3. 存在条件: 继承关系,方法需要重写,父类引用指向子类对象 Father f1 = new son();

    在这里插入图片描述

    展开全文
  • 封装 继承 多态

    2015-12-08 14:04:43
    封装 继承 多态 面向对象的里面的三大特征 OC里面没有多继承 只有单继承、多级继承。 可以使用类目(category)来弥补不能使用多继承 1.封装:把所有有共性的东西放到一起 好处:1 代码清晰  2.模块化方便使用...
    封装 继承 多态  面向对象的里面的三大特征
    OC里面没有多继承
    只有单继承、多级继承。
    可以使用类目(category)来弥补不能使用多继承
    1.封装:把所有有共性的东西放到一起
    好处:1 代码清晰 2.模块化方便使用 3.复用性高 便于维护
    2.继承
    主要是子类、父类(超级类)
    子类父类的关系:
    1 父类有的方法子类可以使用
    2 父类有的属性 子类可以使用
    3父类所有公开的方法和属性子类都可以使用
    子类独有的方法父类不能使用
    3.多态:同一种方法的不同实现

    如果方法值声明不实现
    当调用的时候找不到这个方法的实现就会崩溃
    为什么使用import 不适用@class
    @class只是用类名 不使用类里面的方法属性
    #import 可以导入整个.h文件 使用里面的方法属性
    展开全文
  • C#封装继承多态

    2014-11-05 10:29:54
    这是关于C#封装继承多态的一个简单的例子,对于深入学习C#中封装继承多态将很有帮助!
  • 详解java封装继承多态

    2020-08-26 04:46:57
    主要介绍了java封装继承多态,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • python封装继承多态笔记,python封装继承多态笔记,python封装继承多态笔记适合初学者学习!
  • 封装继承 多态

    2019-06-21 10:58:45
    封装 将变量与函数制作成一个模板 继承 把父类的方法给子类用 多态 在子类中重写父类的方法

    封装 将变量与函数制作成一个模板
    继承 把父类的方法给子类用
    多态 在子类中重写父类的方法
    私有属性只是把名字改了改成了 a._类名__属性

    展开全文
  • 封装继承多态总结

    2013-12-06 09:29:22
    封装继承多态总结
  • 主要介绍了JavaScript使用prototype原型实现的封装继承多态,涉及javascript prototype与面向对象程序设计相关操作技巧,需要的朋友可以参考下
  • OC封装继承多态演示

    2017-04-07 21:49:26
    只是一个简单的小例子,演示了OC中的封装继承多态,在Windows下打成的zip压缩包
  • 安老师 的一个例子,c++ 的封装继承多态例子
  • java封装继承多态

    千次阅读 多人点赞 2018-12-20 16:04:19
    java封装继承多态 面向对象 面向对象的三个特征: 封装(Encapsulation); 继承(Inheritance); 多态(Polymorphism)。 我的总结: 面向过程:强调的是具体的功能实现;(执行者) 面向对象:强调的是具备...

    java封装继承多态

    1. 面向对象

    面向对象的三个特征:
    封装(Encapsulation);
    继承(Inheritance);
    多态(Polymorphism)。

    我的总结:
    面向过程:强调的是具体的功能实现;(执行者)
    面向对象:强调的是具备功能的对象。(管理者)

    2、类
    类(class)是Java 语言的最小编程单位,也是设计和实现Java 程序的基础,本部分将深入介绍类的相关知识。
    类的概念
    类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述,是按照面向对象技术进行设计时最小的单位,也是组成项目的最基本的模块。类的概念是抽象的,类似于建筑设计中的图纸,是对于现实需要代表的具体内容的抽象。类只包含框架结构,而不包含具体的数据。所以类代表的是总体,而不代表某个特定的个体。

    我的总结:类是抽象的,对象是具体的,实实在在的!

    类的定义:
    [修饰符] class 类名{
    1~n个构造方法;
    0~n个字段;
    0~n个方法
    }
    定义类,其实就是定义类里面的对象

    对象包含:
    状态;(属性)
    功能、行为;(方法)
    通过类来描述对象;
    状态——–成员变量;
    功能、行为——方法;

    class Person{
    //属性
    private String name;
    private int age;
    private int sal;
    //方法
    public void show(){
    System.out.println(“个人情况:”+name+age+sal);
    }
    }
    3、构造方法
    构造方法:用来构造类的实例(每一个类都默认有一个无参的构造方法,得使用new调用)
    字段:类或对象所包含的数据,对类状态的一种描述;
    方法:类或对象的特征或行为

    作用:
    给类中的字段进行初始化,可以用来创建对象。

    特点:
    方法名与类名相同
    不用定义返回值类型
    不需要写return语句

    我的总结:
    注意:
    默认构造方法的特点。
    多个构造方法是以重载的形式存在的。

    构造方法的重载:(需要哪个就去适配哪个,调用哪个)
    this([实参]);调用当前类的构造方法
    注意: this([实参]);必须放在构造器的第一行;

    对象的产生格式:
    类名称 对象名 = new 类名称();
    因为有(),所以是方法,实际上它就是构造方法,并且是非私有的构造方法。
    如:CellPhone cp = new CellPhone();

    class Person{
        private String name;
        private int age;
        private int sal;
    
        public void show(){
            System.out.println("个人情况:"+name+age+sal);
        }
    
        public Person(String name) {
            super();
            this.name = name;
        }
    
        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    
    
        public Person(String name, int age, int sal) {
            super();
            this.name = name;
            this.age = age;
            this.sal = sal;
        }
    }
    

    4、static关键字
    特点:
    随着类的加载而加载
    优先于对象存在
    被所有对象所共享
    可以直接被类名调用
    使用注意:
    静态方法只能访问静态成员
    但是非静态成员可以访问静态成员;
    静态方法中不可以使用this,super关键字
    主方法(main)是静态的(可以利用类名去调用静态的main方法,很正常!但是会陷入死循环,导致内存溢出,jvm自动停止!)
    public static void main(String[] agrs){}

    可修饰字段,方法。
    用static 修饰的成员表示它属于这个类共有,而不是属于该类的单个实例。
    static 修饰的字段 == 类字段
    static 修饰的方法 == 类方法

    没使用static修饰的字段和方法,成员属于类的单个实例,
    不属于类。
    没有static 修饰的字段 == 实例字段
    没有static 修饰的方法 == 实例方法

    类和实例访问字段和方法的语法:
    访问类成员: 类.字段 类.方法
    访问实例成员: 实例.字段 实例.方法

    我的总结:
    static 修饰的字段和方法,既可以通过类调用,也可以使用实例调用;
    没static 修饰的字段和方法,只能使用实例来调用(建议使用:类名来调用; 其实在底层,对象调用类成员,也会转换类名调用)
    static关键字不能与this,super同时连用!

    5、匿名对象
    一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量;
    特点:
    对方法或字段只进行一次调用时;
    可作为实际参数进行传递;
    只在堆里面开辟存储区域,
    只能使用一次, 使用完就被销毁了;
    何时使用?只拿来用一次!!
    new Person();表示匿名对象,没有名字的对象
    new Person().age = 17;//使用一次之后就被销毁了

    6、this关键字
    特点:this表示当前对象。
    当前对象 ←→ 当前正在调用实例成员的对象
    换言之:谁调用了方法,谁就是当前对象。

    什么时候使用this关键字呢?
    方法间的相互调用;
    this.字段;
    构造器中相互调用,但是此时this([参数])必须写在构造方法第一行。
    this不能用在static修饰的方法里和static修饰的代码块里;

    Eg:构造方法中的this.name = name;

    7、面向对象之封装
    封装的两个含义:
    1.把对象的状态和行为看成一个统一的整体,将二者存放在一个独立的模块中(类);
    2.”信息隐藏”, 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;

    封装机制在程序中的体现是:把描述对象的状态用字段表示,描述对象的行为用方法表示,把字段和方法定义在一个类中,并保证外界不能任意更改其内部的字段值,也不允许任意调动其内部的功能方法。

    程序中的一种体现:通常将类中的成员变量私有化(private),通过对外提供方法(setXxx,getXxx),可对该变量(xxx)进行访问。
    boolean 类型的变量没有getXX,只有 isXX;

    class Person1{
        private String name;
        private int age;
        private int sal;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    8、访问修饰符
    private 类访问权限:本类内部可以访问,不能继承到子类;
    default 什么都不写,包访问权限:本类内部可以访问,同包其他类也可以访问,同包可继承;
    protected 子类访问权限:本类内部可以访问,不同包的子类也可以访问,同包其他类也可以访问,能继承到子类;
    public 公共访问权限:任何地方都可以访问,能继承到子类;

    9、类的设计分析
    分析思路:
    根据要求写出类所包含的字段;
    所有的字段都必须私有化;
    封装之后的字段可通过setter和getter设值和取得;
    按需求可添加若干构造方法;
    根据需求可添加相应的方法;
    类中的所有方法都不要直接处理(输出打印),而是交给调用者去处理。

    10、面向对象之继承
    首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类;
    也就是说:继承是一种从一般到特殊的关系;

    特点:
    1、提高了代码的复用性。
    2、让类与类之间产生关系,有了这个继承关系才有了多态的特性。
    3、Java语言中只支持单继承(有别于C语言)。
    因为多继承容易带来安全隐患(父类多了, 功能相同的话,就会出现调用不确定性吗,覆写一个方法,到底覆写的谁的?)。
    ps:接口可以实现多继承
    4、Java支持多层继承,object是每个类的超类,实现树形结构。

    我的总结:
    继承是多态的前提。
    对类而言,只支持单继承。

    格式:
    [修饰符] class SubClass extends SuperClass

    按照这种关系,我们把SuperClass类称为父类或基类,把SubClass称为子类或派生类或拓展类;

    我的总结:
    java.lang.Object是所有类的父类,
    Object要么是直接父类要么是间接父类。

    Eg:
    学生属于人的一种特殊情况,此时我把人的共性写在Person类里面,为了让学生拥有这些共性(别的比如老师也可以有这些共性),然后我就让学生来拓展Person类。

    我的总结:
    子类与父类的关系:
    子类拓展父类(子类是父类的一种特殊情况)
    主要是以父类为基础,然后添加属于自己的字段和方法。

    父类的私有成员子类不能继承到;父类的构造方法不能被继承;
    Java只支持单继承,不支持多继承;//不然的话,比如show方法,继承了多个,不知道到底调用那一个。
    一个类有且只有一个直接父类;
    一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;
    Student 的直接父类是Person,Object类也是Student类的父类,但是是间接父类;
    一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消;
    Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类,Object要么是直接父类要么是间接父类。

    子类对象实例化过程
    在继承操作中,对于子类对象的实例化:
    子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

    11、子类访问父类和方法覆写
    子类不能直接访问父类的私有成员;
    但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。
    Person类中有私有字段name,Student继承Person
    new Sudent().name; ×
    new Student().getName(); √

    子类拓展父类(子类是父类的一种特殊情况)
    主要是以父类为基础,然后添加属于自己的字段和方法。

    方法覆写产生原因:
    当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.
    判断必杀技:子类方法前加上@Override能编译通过,表明是方法的覆写。
    调用被覆盖的父类方法:使用super.方法名(实参);
    方法覆写时应遵循的原则(一同两小一大):
    (一同):方法签名必须相同;
    (两小):
    子类方法的返回值类型比父类方法的返回值类型更小或相等
    子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;
    (一大):子类方法的访问权限应比父类方法更大或相等;

    子类需要覆写父类方法。
    当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。

    12、super关键字和调用父类构造方法
    表示父类对象的默认引用
    如果子类要调用父类被覆盖的实例方法,可用super作为调用者调用父类被覆盖的实例方法。
    使用super调用父类方法
    使用super调用父类的构造方法

    调用构造方法
    本类中调用另一个重载构造方法用this(参数列表)
    子类构造方法调用父类构造方法用super(参数列表)
    子类调用父类的构造方法时:
    super必须放在第一句
    Java在执行子类的构造方法前会先调用父类无参的构造方法,其目的是为了对继承自父类的成员做初始化操作。
    子类在创建对象的时候,默认调用父类的无参构造方法,要是子类构造方法中显示指定调用父类其他构造方法,就调用指定的父类构造方法,取消调用父类无参构造方法。

    package reviewDemo;
    
    class A{
        String name;
        A(){
            System.out.println("父类默认隐式的构造方法!");
        }
    
        A(String name){
            System.out.println("父类显式的构造方法!");
        }
    }
    class B extends A{
    
        B(){
            super(null);
            System.out.println("子类默认隐式的构造方法!");
        }
    }
    public class Demo10 {
        public static void main(String[] args) {
            new B();
        }
    }
    

    13、面向对象之多态
    多态:指同一个实体同时具有多种形式
    好比,你去面馆吃面,说我要吃面,那么;老板给我牛肉面,鸡蛋面等都可以,
    这就是说”面”有多种形态,也就是说实体有多种形态;
    编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。
    如果编译时类型和运行时类型不同,就出现多态。

    Eg:
    前提:Student extends Person:

    Person p = new Person(); 
    Student s = new Student(); 
    Person p = new Student();//多态
    

    引用关系:父类变量指向子类实例对象

    实现多态的机制:
    父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用变量的类型中定义的方法。

    多态的作用:
    把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化。
    只修改方法的实现,不必修改方法的声明
    继承是多态产生的前提条件;

    分类:
    编译时多态:方法重载
    运行时多态:方法覆写

    package test;
    
    class Dog{
        void eat(){
            System.out.println("一般的狗吃一般的狗粮!");
        }
    }
    class HashDog extends Dog{
        void eat(){
            System.out.println("哈士奇吃哈士奇的狗粮!");
        }
    }
    class ZangAoDog extends Dog{
        void eat(){
            System.out.println("藏獒吃藏獒的狗粮!");
        }
    }
    

    //定义一个动物园喂的方法

    class Zoo{
    
        void feed(Dog d){
            d.eat();
        }
    
    }
    public class Demo11 {
        public static void main(String[] args) {
    
            Dog hd = new HashDog();
    
            Dog zd = new ZangAoDog();
    
            Zoo z = new Zoo();
            z.feed(hd);
            z.feed(zd);
        }
    }
    

    输出:
    哈士奇吃哈士奇的狗粮!
    藏獒吃藏獒的狗粮!

    14、引用变量类型转换
    向上转型(子类→父类):(自动完成)
    父类名称 父类对象 = 子类实例 ;

    向下转型(父类→子类):(强制完成)
    子类名称 子类对象 = (子类名称)父类实例 ;

    对象名 instanceof 类

    判断指定的变量名此时引用的真正类型是不是当前给出的类或子类;
    我的总结:对象的类型和类必须有继承关系

    class A extends B{}
    
    B = new A();
    If(b instanceof A){ ...
    }
    
    展开全文
  • 封装 继承 多态 对象有三大特性:封装继承多态。 对象 Java是一门面向对象的语言,对象,在java中表达的形式就是类(class),包含了数据,行为的一个独立的编程单元。 也就是说,Java编程语言是建基于Class...
  • OC 封装 继承 多态

    2016-08-16 18:45:50
    OC 封装 继承 多态封装:隐藏内部实现,稳定外部接口.封装就是定义类 定义属性 定义方法属性封装了setter get方法 @property(nonatomic,retain)NSString *name,*sex;类封装了实例变量和方法#import ...
  • 一直觉得很奇怪,为啥我们讲到面向对象的时候总会有两种说法 一种是三大特性,一种是说四大特性,原因如下 抽象这个概念是一个非常通用的设计思想,并不单单用在面向对象编程中,也可以用来指导架构设计等。...
  • 封装 继承 多态 抽象的理解
  • C++三大特性封装继承多态

    千次阅读 2017-08-01 20:11:40
    C++三大特性封装继承多态,继承方式方法,多态实现的必要条件 , 函数重载、覆盖(重写),隐藏(重定义)的区别。
  • 怎么理解封装继承多态 理解封装:将类的属性和操作属性的方法封装起来,访问的时候,访问自己封装的接口。 理解继承: 子类从父类继承所有信息,但不能访问父类私有属性和方法; 子类可有新的属性和方法;也可以...
  • C++封装继承多态总结

    千次阅读 2016-04-07 16:09:42
    C++封装继承多态总结 面向对象的三个基本特征 面向对象的三个基本特征是:封装、继承、多态。其中,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码...
  • python——类——封装 继承 多态

    千次阅读 2017-04-28 10:08:02
    python——类——封装 继承 多态
  • JAVA基础之封装继承多态 文章目录系列文章目录前言一、封装二、继承三、多态总结 前言 封装,继承,多态是JAVA面向对象的三大特性,也是最基本的知识 提示:以下是本篇文章正文内容,下面案例可供参考 一、封装 ...
  • 个人对于封装继承多态的理解

    千次阅读 2020-04-06 19:40:13
    学的差不多了,是时候对于学习的内容弄个总结,在这里写一下对于封装继承多态的理解,本人小白,有说的不对和不详细的地方勿喷,主要是对自己的一个总结 一.封装 本人觉得封装就像是一种包装,将类的内部的一些隐藏...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,838
精华内容 58,735
关键字:

封装继承多态