继承 订阅
按照法律或遵照遗嘱接受死者的财产、职务、头衔、地位等。 展开全文
按照法律或遵照遗嘱接受死者的财产、职务、头衔、地位等。
信息
词    目
继承
拼    音
jì chéng
基本解释
依法承受等
词    性
动词
用    法
谓语等
组    词
~权,~人等
继承基本信息
【词目】继承【拼音】jì chéng【基本解释】泛指把前人的作风、文化、知识等接受过来。
收起全文
精华内容
参与话题
问答
  • 继承 多态

    2019-07-04 14:05:38
    java有三大特性:封装,继承多态。 封装就是将类的信息隐藏在类内部,不允许外部程序直接访问,而是通过该类的方法实现对隐藏信息的操作和访问。主要通过访问控制符实现,详见修饰符 继承是类与类的一种关系,...

    java大特性:封装,继承和多态。

    1. 封装就是将类的信息隐藏在类内部,不允许外部程序直接访问,而是通过该类的方法实现对隐藏信息的操作和访问。主要通过访问控制符实现,详见修饰符
    2. 继承是类与类的一种关系,比较像集合中的从属于关系。比如说,狗属于动物。就可以看成狗类继承了动物类,那么狗类就是动物类的子类(派生类),动物类就是狗类的父类(基类)。在Java中是单继承的,也就是说一个子类只有一个父类。
    3. 多态指的是对象的多种形态。多态有两种:引用多态和方法多态。继承是多态的实现基础。

    1.引用多态 

    父类的引用可以指向本类的对象(即向上转型,向上转型的引用只能调用父类中存在的方法,而不能调用子类中新加的方法)

    2. 方法多态

    创建父类对象时,调用的方法为父类方法;

    创建子类对象时,调用的方法是子类重写的方法或继承自父类的方法;

    • 继承
    1. 定义:继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。子类又被称为派生类,父类被称为超类
    2. 继承的目的:继承是为了降低代码重复率,提高代码复用性,提高可维护性
    3. 特性:
      1. 子类拥有父类非private(应该也有非default吧)的属性、方法。为了访问父类的私有属性,可以在父类中写publicsettinggetting方法,子类通过调用这两种方法访问该私有属性。
      2. 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
      3. 子类可以用自己的方式实现父类的方法。
      4. Java的继承是单继承,但是可以多层继承(其实就是和C++中的继承多个类一样,只是换了种方式),单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。
      5. 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。
    4. 继承关键字:

    继承可以使用 extends implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

    1. final 关键字:

    final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:

    :实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final(没有子类当然就不能被重写),但是实例变量并不是 final

    1. 构造器

    子类不能继承父类的构造器(构造方法或者构造函数),如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。super调用父类构造时,一定要放在构造方法的首行上。

    如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。

    在继承关系之中,如果要实例化子类对象,会默认先调用父类构造,为父类之中的属性初始化,之后再调用子类构造,为子类之中的属性初始化,即:默认情况下,子类会找到父类之中的无参构造方法。

    • 多态(子类重写父类的方法)
    1. 定义:

    多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口,使用不同的实例而执行不同操作。当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

    1. 分类:

    多态一般分为两种:重写式多态和重载式多态。

        1. 重载式多态,也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道,方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时,通过传入不同的参数最后得到不同的结果。
        2. 但是这里是有歧义的,有的人觉得不应该把重载也算作多态。因为很多人对多态的理解是:程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,这种情况叫做多态。 这个定义中描述的就是我们的第二种多态重写式多态。并且,重载式多态并不是面向对象编程特有的,而多态却是面向对象三大特性之一(如果我说的不对,记得告诉我。。)。
        3. 我觉得大家也没有必要在定义上去深究这些,我的理解是:同一个行为具有多个不同表现形式或形态的能力就是多态,所以我认为重载也是一种多态,如果你不同意这种观点,我也接受。
        4. 重写式多态,也叫运行时多态。这种多态通过动态绑定(dynamic binding)技术来实现,是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。也就是说,只有程序运行起来,你才知道调用的是哪个子类的方法。 这种多态通过函数的重写以及向上转型来实现,因为它才是面向对象编程中真正的多态。
    1. 优点

    1. 消除类型之间的耦合关系

    2. 可替换性

    3. 可扩充性

    4. 接口性

    5. 灵活性

    6. 简化性

    1. 多态存在的三个必要条件
    • 继承
    • 重写
    • 父类引用指向子类对象

    比如:

    Parent p = new Child();

    1. 父类子类对象转换实例:

    Animal a = new Cat(); // 向上转型, 父类引用指向子类对象

    a.eat(); // 调用的是 Cat eat

    Cat c = (Cat)a; // 向下转型

    c.work(); // 调用的是 Cat work

    可以看出既可以把子类赋给父类(Animal a = new Cat();),也可以把父类强制转换成子类(Cat c = (Cat)a;

    1. 虚方法

    我们已经讨论了方法的重写,也就是子类能够重写父类的方法。当子类对象调用重写的方法时,调用的是子类的方法,而不是父类中被重写的方法。要想调用父类中被重写的方法,则必须使用关键字super

    两种方式 Son son = new Son()

    Parent parent = new Son()

    当调用 son.mailCheck() 时,编译器在编译时会在 Son 类中找到 mailCheck(),执行过程 JVM 就调用 Son 类的 mailCheck()

    当调用parent.mailCheck() 方法时,编译器会去 Parent类查找 mailCheck() 方法 ,在编译的时候,编译器使用 Parent类中的 mailCheck() 方法验证该语句, 但是在运行的时候,Java虚拟机(JVM)调用的是 Son 类中的 mailCheck() 方法。

    1. 多态的实现方法
        1. 重写
        2. 接口
        3. 抽象类和抽象方法

     

     

    展开全文
  • C#封装继承多态

    2014-11-05 10:29:54
    这是关于C#封装继承多态的一个简单的例子,对于深入学习C#中封装继承多态将很有帮助!
  • 封装 继承 多态 对象有三大特性:封装,继承多态。 对象 Java是一门面向对象的语言,对象,在java中表达的形式就是类(class),包含了数据,行为的一个独立的编程单元。 也就是说,Java编程语言是建基于Class...

    封装 继承 多态

    对象有三大特性:封装,继承,多态。

    • 对象

    Java是一门面向对象的语言,对象,在java中表达的形式就是类(class),包含了数据,行为的一个独立的编程单元。
    也就是说,Java编程语言是建基于Class的。通过建立Class来模拟现实世界的对象。

    实际上,通过属性和方法可以模拟世界上任何的对象。

    • 概念:

    封装:将内部细节隐藏类中用private隐藏属性,其实就是有选择性地公开或隐藏某些信息,它解决了数据的安全性问题。

    继承:子类从父类得到属性和行为

    多态:父类或接口可以指向子类实例父类定义的方法会在不同子类中出现不同实现

    • 实现:

    -① 封装的实现:

    定义属性,构造方法,get set方法,tostring,hashcode,equals

    public class Person {
    private  String name;
    private  int age;
    
    public Person() {
    	super();
    	// TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
    	super();
    	this.name = name;
    	this.age = age;
    }	
    
    @Override
    public String toString() {
    	return "Person [name=" + name + ", age=" + age + "]";
    }
    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;
    }}
    

    ② 继承的实现:

    father

    public class Father {
    private String name;
    public Father() {
    	System.out.println("father wu can");
    }
    public Father(String name) {
    	System.out.println("father yi ge can ");
    	this.name = name;
    }}
    

    son

    public class Son extends Father {
    public String name;
    public Son(String name) {
    	System.out.println("son you yi ge can ");
    	this.name = name;
    }
    
    public Son() {
    	System.out.println("son wu can ");
    }}
    

    Test

    public class Fatherson_Test {
    public static void main(String[] args) {
    	new Son();
    }}
    

    打印结果:

    father wu can
    son wu can

    总结:

    使用extends关键字,只有一个继承关系,父类的所有的不是private 的东西都可以使用。

    可以继承的有:属性,静态属性,get,set,构造方法;

    在父类实例化了,子类可以不用实例化。

    排序:

    【第一次new 类(静态块,实例块):先父类静态块,子类静态块,父类实例块,子类实例块

    还是new类加上构造器:(静态块,实例块,构造器)

    先静态,再实例,后构造

    加上属性初始化后new:

    先执行类相关初始化,在执行实例相关的操作,先父,再子,】

    单个类:构造器调另一个构造器:

    this调子类在新的构造器中写this(已有的参数列表),必须第一行先输出无参构造,再输出一个,最后输出全部的参数的构造器

    super(参数)调用父类构造器,必须第一行,若不写,则为super(默认无参构造器)没有无参构造器,调super()出错:

    重载,重写(覆盖)的概念:

    ①重载(重新加载)是指不同的函数使用相同的函数名,但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。
    
    ②覆盖(也叫重写)(重来再写)是指在派生类中重新对基类中的虚函数(注意是虚函数)重新实现。即函数名和参数都一样,只是函数的实现体不一样。
    
    

    ③多态的实现:

    接口interface ————USB

    public interface USB {
    	public void Realized();	
    }
    
    

    实现接口implements———— USB_drive(U盘)

    public class USB_drive implements USB {
    public void Realized() {
    System.out.println("u盘链接");
    	
    }}
    

    实现接口implements———— Phone(手机)

    public class Phone implements USB {
    	public void Realized() {
    	System.out.println("手机链接");		
    	}
    }
    

    实现接口implements———— Hard_Disk(硬盘)

    public class Hard_Disk implements USB {
    	public void Realized() {
    	System.out.println("硬盘链接");		
    	}
    }
    

    ​ 实现——————computer

    public class Computer {
    public void beused(USB usb,String name) {
    	System.out.println("USB被"+name+"使用");
    	usb.Realized();
    }}
    

    测试:

    public class Test {
    public static void main(String[] args) {
    	Computer computer =new Computer();
    	computer.beused(new Phone(),"手机");
    	computer.beused(new USB_drive(),"U盘");
    	computer.beused(new Hard_Disk(),"硬盘");
    	 
    }}
    

    结果:

    USB被手机使用
    手机链接
    USB被U盘使用
    u盘链接
    USB被硬盘使用
    硬盘链接

    笔记整理:

    可以把一个父类(接口)的引用指向一个子类的实例,称为向上造型,是多态的典型表现
    向上造型,只能访问父类(或接口)的方法,不能使用其他方法,
    调用时,真正执行的是子类(或实现类)的方法.
    我的理解:
    【将一个接口指向实现类或将一个父类引用指向子类实例,称向上造型(左,大)(,俯视图最先看见的是较大的那个接口,)只能使用上面的那个类([左边,大的那个接口]或[extends,implements 右边的那个接口或抽象类]),
    person zs=new  zhangsan();
    】
    简单来说:向上转型,访问父类接口(person),执行子类方法(zs.dosomething())
    【zs.dosomething();】
    隐式转换// 小转大 隐式
    
    
    向下转型:显示转换(强转)// 大转小 显式 / 强制
    
    
    
    多态参数:
    对于向上造型,当方法的参数为上层类型,可以传入下层类型
    
    
    
    
    • 好处

    ①封装的好处:

    1、提高了代码的复用性。
    2、隐藏了实现细节,还要对外提供可以访问的方式。便于调用者的使用。这是核心之一,也可以理解为就是封装的概念。

    3、提高了安全性。

    ②继承的好处:

    a:提高了代码的复用性

    b:提高了代码的维护性

    c:让类与类之间产生了关系,是多态的前提

    ③多态的好处:

    可替换:多态可以对已存在的代码,来替换(只要子类实现了接口的方法,可以替换父类的类)
    可扩充性:新加的子类不影响已存在多态性、继承性、以及其他特性的运行和操作
    接口性:多态是超类通过方法签名,像子类提供了一结构性
    灵活性:灵活多样的操作,提高了使用效率
    简化性:多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时

    展开全文
  • 继承多态和接口多态

    2018-09-08 16:22:27
    继承多态和接口多态 继承多态和接口多态基本一致,不同的是类的继承是使用继承关系实现多态,而接口多态是使用实现的方式实现的     接口多态 package 接口; interface Preson{ public void ...

     

    继承多态和接口多态

    继承多态和接口多态基本一致,不同的是类的继承是使用继承关系实现多态,而接口多态是使用实现的方式实现的

     

     

    接口多态

    package 接口;

    interface Preson{

    public  void teachLession();

    public void sleep();

     

    }

    class JavaTeacher implements Preson{

    //实现第一种多态

    String name;

    int age;

    public JavaTeacher(String name) {

    注意构造函数是不用返回值void int String 的

    Public void JavaTeacher (String name){

    This.name=name;
    }这是错的

    this.name=name;

    }

    public void teachLession() {

    System.out.println(name+"老师正在讲多态");

    }

    public void smoking() {

    System.out. println("正在抽烟");

    }

    public void sleep() {

    System.out.println(name+"正在睡觉");

    }

    }

     

     

     

     class PHPTeacher implements Preson{

    //实现 第二种多态

     String name;

    int age;

    public  PHPTeacher(String name) {

    this.name=name;

    }

    public void teachLession() {

     

    System.out.println(name+"老师在讲PHP");

    }

    public void sleep() {

    System.out.println(name+"老师正在睡觉");

    }

    }

     

     

     class Leader{

     public void checkTeacher(Preson t) {

    String preson="";

    //instanceof可以判断我们的多态的引用变量到底是什么类型

    if(t instanceof JavaTeacher ) {

    preson="Java老师";

    }

    else if(t instanceof PHPTeacher ) {

    preson ="PHP老师";

    }

    System.out.println("开始考察"+preson);

    t.teachLession();

    System.out.println("考察结束");

     }

     }

    public class 接口 {

    public static void main(String [] args) {

    Preson j=new JavaTeacher("张三");

     

    j.sleep();

    j.teachLession();

    //注意

    //j.smoking();子类中特有的方法不能用父类来调用

    //但是可以用子类来的调用

    JavaTeacher d=new JavaTeacher("张三");

    d.smoking();

    PHPTeacher p=new PHPTeacher("李希");

     

    p.sleep();

    p.teachLession();

    Leader leader=new Leader();

    leader.checkTeacher(j);

    }

    }

     

     

     

     

    继承多态

    package 接口;

    abstract class Preson{

    String name;

    int age;

    public abstract void teachLession();

    public void sleep() {

    System.out.println("正在睡觉");

    }

    }

    class JavaTeacher extends Preson{

    //实现第一种多态

    public void teachLession() {

    System.out.println(name+"老师正在讲多态");

    }

    public void smoking() {

    System.out. println("正在抽烟");

    }

    }

     class PHPTeacher extends Preson{

    //实现 第二种多态

    public void teachLession() {

     

    System.out.println(name+"老师在讲PHP");

    }

    public void sleep() {

    System.out.println("老师正在睡觉");

    }

    }

     

     

    public class 接口 {

    public static void main(String [] args) {

    Preson j=new JavaTeacher();

    j.name="张三";

    j.age=21;

    j.sleep();

    j.teachLession();

    注意

    //j.smoking();子类中特有的方法不能用父类来调用

    //但是可以用子类来的调用

    JavaTeacher d=new JavaTeacher();

    d.smoking();

    PHPTeacher p=new PHPTeacher();

    p.name="李希";

    p.age=21;

    p.sleep();

    p.teachLession();

     

    }

    }

     

    正在睡觉

    张三老师正在讲多态

    正在抽烟

    老师正在睡觉

    李希老师在讲PHP

     

     

     

     

    展开全文
  • 封装继承多态

    千次阅读 2019-04-29 22:17:46
    封装的目的 增强安全性和简化编程,使用者不必了解具体的实现细节,而只要通过对外公开的访问方法,来使用类的成员。...继承 可以理解为,在一个现有类的基础之上,增加新的方法或重写已有方法,从而产生...

    封装的目的
    增强安全性和简化编程,使用者不必了解具体的实现细节,而只要通过对外公开的访问方法,来使用类的成员。
    封装的基本要求

    把所有的属性私有化。
    对每个属性提供 getter 和 setter 方法。
    如果有一个带参的构造函数的话,那一定要写一个不带参的构造函数。
    建议重写 toString 方法,但这不是必须的。

    继承
    可以理解为,在一个现有类的基础之上,增加新的方法或重写已有方法,从而产生一个新类。
    我们在编写 Java 代码时,每一个类都是在继承。因为在 Java 中存在一个所有类的父类(基类、超类)Object
    继承的优点
    继承给我们的编程带来的好处就是对原有类的复用(重用)。除了继承之外,我们还可以使用组合的方式来复用类。
    所谓组合就是把原有类定义为新类的一个属性,通过在新类中调用原有类的方法来实现复用。从抽象概念上来讲,新定义类所代表的事物是原有类所代表的事物的一种,那么这时组合就是实现复用更好的选择。

    多态
    相同的事物,调用其相同的方法,参数也相同时,但表现的行为却不同。
    实现多态的三个必要条件

    继承:在多态中必须存在有继承关系的子类和父类。
    重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。
    多态的实现方式
    基于继承实现的多态
    主要表现在父类和继承该父类的一个或多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为。
    基于接口实现的多态
    在接口的多态中,指向接口的引用必须是指定这实现了该接口的一个类的实例,在运行时,根据对象引用的实际类型来执行对应的方法。
    继承都是单继承,只能为一组相关的类提供一致的服务接口。
    接口是多继承多实现,它能够利用一组相关或者不相关的接口进行组合与扩充,能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
    重载(overloading)重写(overriding)

    展开全文
  • 使用基类变量引用子类对象,或使用接口变量引用实现了此接口的对象。这其实就是多态编程。 多态编程的基本原理是:使用基类或接口变量编程。...因此,多态的实现分为两大基本类别:继承多态和接口多态。
  • 易语言的继承多态演示源码,的继承多态演示,说明,继承的方法,生产
  • 封装 继承 多态

    热门讨论 2018-01-07 09:25:01
    面向对象的三大特征:封装、继承多态。1、封装概念:每个对象都包含它能进行操作所需要的所有信息,这个特性称为封装。 对象不必依赖其他对象来完成自己的操作。优点: 良好的封装能够减少耦合 类内部的实现可以...
  • 当这个作为参数的父类是普通类或者抽象类时,构成继承多态 当这个父作为参数的父类是一个接口时,构成接口多态 多态作为形参 形式参数 基本类型 引用类型 普通类 当一个形参希望我们传入的是一个普通类时,我们实际上...
  • java继承 多态

    千次阅读 2017-02-23 17:02:35
    1. 继承:  (1)子类的构造方法一定会调用父类的构造方法。  (2)任何子类构造方法第一行肯定是this();或者super();两个择一。  this();调用本类的其它构造方法。(传递相应参数调用相应的方法)  super();调用...
  • 继承多态

    2017-08-13 10:29:16
    #include "iostream" using namespace std; /* C++中没有接口的概念 C++中可以使用纯虚函数实现接口 接口类中只有函数原型定义,没有任何数据的定义。 */ class Interface1 { public: virtual void print() =...clas
  • java封装继承多态

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

    千次阅读 2019-03-16 21:15:08
    面向对象编程(Object Oriented Programming)有三大特性:封装、继承多态。在这里,和大家一起加深对三者的理解。 封装 封装可以拆开理解,装,是把数据和方法放进了类里;封,把装进去的数据和成员方法加上访问...
  • 实现重载(overload)和重写(override) 调用中用到多态,向上转换,强制转换 所有被创建的类,都各自创建两个实现接口 最底层的类中创建内部类,并在外部类中调用内部类的方法
  • C++封装继承多态

    2018-08-31 10:00:28
    封装 也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作...继承对于软件复用有着重要意义,是面向对象技术能够提高软件开发效率的重要原因之一。 定义:特殊类的对象拥有...
  • 八、继承多态

    2018-02-07 13:28:32
    八、继承多态继承多态八、继承多态八、继承多八、继承多态 继承的格式:  public class 子类名extends 父类名 {} 继承的好处:  A:提高了代码的复用性  B:提高了代码的维护性  C:让类与类之间产生了关系...
  • c++多继承多态

    2017-06-18 14:59:24
    C++多继承多态的实现如果一个类中存在虚函数,在声明类的对象时,编译器就会给该对象生成一个虚函数指针,该虚函数指针指向该类对应的虚函数表。 多态的实现是因为使用了一种动态绑定的机制,在编译期间不确定调用...
  • 封装继承多态举例

    千次阅读 2017-03-16 21:50:19
    大家都知道php是面向对象的,面向对象就少不了封装继承多态。 1.什么时候封装函数?1.内容重复利用2.单独功能,不同的功能可以封装成不同的函数其实每个功能都可以封装成一个函数,封装好了这样方便在主函数中调用,...
  • 继承多态知识总结

    2018-09-05 22:21:37
    继承多态知识总结
  • Java继承多态部分习题

    万次阅读 2018-07-06 18:22:44
    1 下列程序的输出结果为:class Base { Base() { int i = 100; System.out.println(i); } } public class Pri extends Base { static int i = 200;... public static void main(String argv[]) ...
  • 面向对象三大基本特征——封装、继承多态 封装 首先封装的意思就是将客观事物封装成抽象的类,封装可以看做是一个保护屏障,将实现细节全都隐藏起来,防止该类的代码和数据被外部类定义的代码随机访问。要访问...
  • 对封装 继承 多态 抽象的理解
  • [c++]继承 多态

    千次阅读 2016-04-09 16:10:23
    继承: 是除了基类的构造函数 ,析构函数 全部继承(私有 也可继承 但不可直接访问)继承方法:public: is-a关系 base private 不可访问 public protected 不变protected: base private protected 都不可访问 ...

空空如也

1 2 3 4 5 ... 20
收藏数 528,323
精华内容 211,329
关键字:

继承