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

    千次阅读 2019-05-06 22:06:57
    继承:从已有类中,派生出新的类,新的类中吸收已有类当中的状态和行为,并能扩展出新的能力。 Java继承是使用已有类作为基础,建立新的类。 继承的格式: class 父类{} class 子类 extends 父类 1、继承只允许多层...

    继承:从已有类中,派生出新的类,新的类中吸收已有类当中的状态和行为,并能扩展出新的能力。
    Java继承是使用已有类作为基础,建立新的类。

    继承的格式:
    class 父类{}
    class 子类 extends 父类

    1、继承只允许多层继承不运行多重继承。

    
    //错误的继承——多层继承
    class A{}
    class B{}
    class C extends A,B{}		//错误的
    //多重继承
    class A{}
    class B extends A{}
    class C extends B{}
    

    2、子类访问父类的私有成员——通过setter或getter方法调用可以访问父类私有成员。

    public class ExtDemo01 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Student s=new Student();
    		s.print();
    	}
    }
    class Person{
    	private String father="Father";
    
    	public String getFather() {
    		return father;
    	}
    
    	public void setFather(String father) {
    		this.father = father;
    	}
    }
    class Student extends Person{
    	public void print() {
    		System.out.println("父类属性的名字叫:"+getFather());
    	}
    }
    //结果:
    //父类属性的名字叫:Father
    

    3、子类对象的实例化

    子类对象在实例化时必须先默认调用父类的构造方法,在调用自己的构造方法。

    public class ExtDemo02 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Student s=new Student();
    		s.setName("张三");		//这个方法是父类定义的
    		s.setSchool("清华");	//子类自己的方法
    		System.out.println("姓名是:"+s.getName()+",学校是:"+s.getSchool());
    	}
    }
    class Person{
    	private String name;
    	public Person() {
    		System.out.println("父类的无参构造方法");
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    class Student extends Person{
    	private String school;
    	public Student() {
    		super();	//表示直接使用super()调用父类方法
    		System.out.println("这是子类的无参构造方法");
    	}
    	public String getSchool() {
    		return school;
    	}
    	public void setSchool(String school) {
    		this.school = school;
    	}
    }
    //结果:
    /*父类的无参构造方法
    这是子类的无参构造方法
    姓名是:张三,学校是:清华*/
    

    4、方法的覆写
    定义:指子类定义了父类中同名的方法。
    在方法覆写时子类的访问权限要>=父类的访问权限。——父类权限为private,子类的权限为default,此时不算方法的覆写,算子类重新定义了一个方法。
    public>default>private
    父类的方法被覆写后,子类调用的将是被覆写的方法。

    public class OverrideDemo01 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		new Student().print();
    	}
    }
    class Person{
    	private void print() {
    		System.out.println("父类的方法");
    	}
    }
    class Student extends Person{
    	void print() {
    		System.out.println("子类的方法");
    	}
    }
    //结果
    //子类的方法
    

    5、属性的覆写

    public class OverrideDemo02 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		new Student().print();
    	}
    
    }
    class Person{
    	private int age=10;
    	
    	public int getAge() {
    		return age;
    	}
    	
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    }
    class Student extends Person{
    	
    	int age=20;
    	
    	public void print() {
    		System.out.println("父类的属性:"+super.getAge());
    		System.out.println("子类的属性:"+this.age);
    	}
    	
    }
    //结果
    //父类的属性:10
    //子类的属性:20
    

    判断方法是否为覆写:
    判断是否是覆写方法的必杀技:@Override标签:若方法是覆写方法,在方法前或上贴上该标签, 编译通过,否则,编译出错。

    重载与覆写
    方法重载: Overload
    作用:
    解决了同一个类中,相同功能的方法名不同的问题。
    既然是相同的功能,那么方法的名字就应该相同。
    规则:
    同类中,方法名相同,方法参数列表(参数个数,参数类型,参数顺序)不同。

    方法覆写: Override
    作用:
    解决子类继承父类之后,可能父类的某一个方法不满足子类的具体特征,此时需要重新在子类中定义该方法,并重写方法体。
    规则:
    父类和子类的方法签名(方法名称,方法返回值类型,方法参数列表)是相同的。

    展开全文
  • 这个继承,不仅仅是一级的继承关系,包括好几层的继承。父类的父类的父类。直到最后。 可以很清楚明了的了解一个类的实现关系。diagram 英[ˈdaɪəgræm] 美[ˈdaɪəˌɡræm] n. 图表; 示意图; 图解; [数] 线图;....

    IntelliJ IDEA使用教程 (总目录篇)

    在 IntelliJ IDEA 中这个查看一个类也就是当前类的所有继承关系,包括实现的所有的接口和继承的类,

    这个继承,不仅仅是一级的继承关系,包括好几层的继承。父类的父类的父类。直到最后。
    可以很清楚明了的了解一个类的实现关系。
    diagram 英[ˈdaɪəgræm] 美[ˈdaɪəˌɡræm]
    n. 图表; 示意图; 图解; [数] 线图;
    vt. 图解; 用图表示;

    下面看这个编辑器怎么以图解的形式,查看这种继承关系。

    (上面的是查看的Java源码的类的所有继承关系,最下面的这个是在查看spring项目里面的一个类的继承关系的时候,可能会有spring关系图,这个spring关系太复杂了,简直跟蜘蛛网一样,还是就看看各个类的继承图就可以啦。)

     

    更新:这个地方是有放大镜功能哦。我也是意外发现的,具体看图。

    20170508,追加;

    看了楼下的评论,还真的有个uml插件,然后,就看下面的截图,要是你们是社区版的,看看下载了这个插件之后,能不能用?

    2017/08/01追加

    上面示范的是如何向上看----看一个类的继承关系;

    下面再看看,怎么向下看,-----看一个类的子类实现关系。

    先看下map接口的实现类,哇赛赛,600多个。

    这个so far。我上面截图理解的有点问题,不是没找到,是暂时没有继续扩展,因为jdk也是一直在发展的,所以,这个map接口的实现类,以后只会多,不会少的。所以,他这个地方的so far ,就目前为止,也许再过些年,六千个也是可能的。

    再看个少点的。

    这个是我们自己写的一个类,他有四个类继承了这个类。这个少。

    那么快捷键是啥呢?

    我这个就是告诉你,怎么在你的电脑上,找到你自己对应的快捷键。我这是Ctrl + T。不知道你那是啥。

     

    我写完文章,给自己点个赞,不过分吧,
    不过分,那我可就点啦啊。
    我先点为敬,你们随意。大家随意。不要客气。。。

    展开全文
  • 7.1.4继承

    万次阅读 2020-02-03 20:52:03
    继承 生活中的继承 类的继承格式 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下: class 父类 { } class 子类 extends 父类 { } 为什么需要继承 接下来我们通过...

    继承

    生活中的继承

    类的继承格式

    在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

    class 父类 {
    }
     
    class 子类 extends 父类 {
    }

    为什么需要继承

    接下来我们通过实例来说明这个需求。

    开发动物类,其中动物分别为企鹅以及老鼠,要求如下:

    • 企鹅:属性(姓名,id),方法(吃,睡,自我介绍)
    • 老鼠:属性(姓名,id),方法(吃,睡,自我介绍)
    public class AA
    {
    	public static void main(String[] args)
    	{
    		dog TOM = new dog("TOM");//新建dog对象
    	}
    }
    class dog extends Animal//继承Animal类  相当于把Animal类的东西送给dog
    {
    	public  dog(String name) //构造函数
    	{
    		this.name=name;//继承Animal的name
    		System.out.print(this.name);
    		eat("食物");//调用继承函数eat
    		sleep();//调用继承函数sleep
    	}	
    }
    class Animal 	//动物   包含  吃 和 睡 
    {
    	public String name;
    
    	/睡睡睡
    	public void sleep()
    	{
    		System.out.print("sleep now");
    	}
    	/吃吃吃
    	public void eat(String something)
    	{
    		System.out.print(something);
    	}
    	
    	
    }
    

    继承类型

    需要注意的是 Java 不支持多继承,但支持多重继承。

    继承关键字

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

    extends关键字

    在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。

    public class Animal { 
        private String name;   
        private int id; 
        public Animal(String myName, String myid) { 
            //初始化属性值
        } 
        public void eat() {  //吃东西方法的具体实现  } 
        public void sleep() { //睡觉方法的具体实现  } 
    } 
     
    public class Penguin  extends  Animal{ 
    }

    implements关键字

    使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

    public interface A {
        public void eat();
        public void sleep();
    }
     
    public interface B {
        public void show();
    }
     
    public class C implements A,B {
    }

    super 与 this 关键字

    super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。

    this关键字:指向自己的引用。

    class Animal {
      void eat() {
        System.out.println("animal : eat");
      }
    }
     
    class Dog extends Animal {
      void eat() {
        System.out.println("dog : eat");
      }
      void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
      }
    }
     
    public class Test {
      public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
      }
    }

    final关键字

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

    • 声明类:

      final class 类名 {//类体}
    • 声明方法:

      修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

    :实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final,但是实例变量并不是 final

     

    构造器

    子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

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

    
    
    public class AA extends Animal
    {
    	public static void main(String[] args)
    	{
    		new AA("继承构造函数");
    	}
    	
    	public AA(String A)
    	{
    		super(A);
    	}
    }
    
    class Animal 	//动物   包含  吃 和 睡 
    {
    	
    	public Animal(String A)
    	{
    		System.out.print(A);
    	}
    	
    	
    	
    }
    

     

    展开全文
  • 考虑用Mix-in组件代替多继承

    万次阅读 2020-10-28 11:24:25
    Python是面向对象的编程语言,它提供了一些内置的编程机制,使得开发者可以适当地实现多继承。但是,我们仍然应该尽量避开多继承。 若一定要利用多继承所带来的便利及封装性,那就考虑编写min-in类。min-in是一种...

    Python是面向对象的编程语言,它提供了一些内置的编程机制,使得开发者可以适当地实现多继承。但是,我们仍然应该尽量避开多继承。

    若一定要利用多继承所带来的便利及封装性,那就考虑编写min-in类。min-in是一种小型的类,它只定义了其他类可能需要提供的一套附加方法,而不定义自己的属性,此外,它也不要求使用者调用自己的__init__构造器。

    min-in的最大优势在于,使用者可以随时安插这些通用的功能,并且在必要时覆写它们,多个min-in直接也可以相互组合。有了这样的min-in之后,我们只需要编写极其少量的代码,就可以通过继承体系,轻松地创建出相关工具类。

    要点:

    1.能用min-in组件实现的效果,就不要用多继承来做。

    2.将各功能实现为可插拔的min-in组件,然后继承之。

    3.将简单的行为封装到min-in组件里,然后就可以用多个min-in组合出复杂的行为。

     

    例如,我们需要把Python实例对象以字典形式输出,以便将其序列化,我们不妨把这个功能写成通用代码,以供其他类使用。

    class ToDictMixin(object):
        def to_dict(self):
            return self._traverse_dict(self.__dict__)
    
        def _traverse_dict(self, instance_dict):
            output = {}
            for key, value in instance_dict.items():
                output[key] = self._traverse(key, value)
            return output
    
        def _traverse(self, key, value):
            if isinstance(value, ToDictMixin):
                return value.to_dict()
            elif isinstance(value, dict):
                return self._traverse_dict(value)
            elif isinstance(value, list):
                return [self._traverse(key, i) for i in value]
            elif hasattr(value, '__dict__'):
                return self._traverse_dict(value.__dict__)
            else:
                return value

    再如,我们可以编写一个min-in,它能为任意类提供通用的JSON序列化功能,我们可以假设:继承了min-in的那个类,会提供名为to_dict的方法。

    class JsonMixin(object):
        @classmethod
        def from_json(cls, data):
            kwargs = json.loads(data)
            return cls(**kwargs)
    
        def to_json(self):
            return json.dumps(self.to_dict())

     然后,我们定义一个测试类,同时继承上述两个min-in,以达到扩展功能的作用。

    class Person(ToDictMixin, JsonMixin):
        def __init__(self, name, age, address, list1, dict1):
            self.name = name
            self.age = age
            self.address = address
            self.list1 = list1
            self.dict1 = dict1
    
        def introduce(self):
            print(f'{self.name} {self.age} {self.address}')

    测试运行结果:

    if __name__ == '__main__':
        # 1.测试ToDictMixin
        person = Person('zhangsan', 18, 'Shenzhen', [1, 2, 3], {'username': 'admin', 'password': '123456'})
        print(person.to_dict())
    
        # 2.测试JsonMixin
        json_str = '{"name": "zhangsan", "age": 18, "address": "Shenzhen", "list1": [1, 2, 3], "dict1": {"username": "admin", "password": "123456"}}'
        person = Person.from_json(data=json_str)
        json_str = person.to_json()
        print(json_str)

    运行结果:

    运行结果显示,已成功为Person类通过min-in扩展的形式,为其添加了新功能 :将Python实例对象以字典形式输出、将Python实例对象以JSON字符串形式输出。

    展开全文
  • C++ 继承(2): 多重继承, 多继承, 虚继承(virtual)

    千次阅读 多人点赞 2019-03-20 22:59:49
    C++远征之继承篇 视频教程 笔记 方便自己查阅和复习,温故而知新。 接着C++ 继承(1): 继承方式(public, protected, private), 继承中的特殊关系(隐藏 , is-a) 继续做笔记 目录 4 多继承与多重继承 4.1 多重...
  • Java 继承

    千次阅读 多人点赞 2019-05-07 11:12:43
    java继承的概念 Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为, 并能扩展新的能力, 继承使用的是extends 类的继承格式 class 父类 { } class ...
  • 首先给出以下继承关系,以便描述虚继承原理: class AAA { public: int age; }; class BBB:virtual public AAA//变为虚继承,A变为虚基类 { }; class CCC:virtual public AAA { }; class DDD:public BBB, ...
  • Kotlin 继承

    千次阅读 2020-08-17 11:32:24
    文章目录Kotlin 继承构造函数子类有主构造函数子类没有主构造函数实例重写属性重写END Kotlin 继承 Kotlin 中所有类都继承该 Any 类,它是所有类的超类,对于没有超类型声明的类是默认超类: class Example // 从 ...
  • 密封类从刚开始学就从各种途径了解到不能被继承,新版本的密封类如果想要被继承需要用permits指定被继承的类 同时,被继承的类需要用final,sealed或者non-sealed修饰 正常的一个代码思路 public class Person { }...
  • 1 三种继承方式    (1) 公有继承(public) 公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的,不能被这个派生类的子类所访问。  (2) 私有...
  • C++公有继承,保护继承,私有继承的区别

    万次阅读 多人点赞 2018-08-21 15:34:32
    1.公有继承–public 公有继承时,对基类的公有成员和保护成员的访问属性不变,派生类的新增成员可以访问基类的公有成员和保护成员,但是访问不了基类的私有成员。派生类的对象只能访问派生类的公有成员(包括继承的...
  • Python中类的继承、多层继承和多继承 Python中,一个类可以通过继承的方式来获得父类中的非私有属性和非私有方法。 一、继承、重写、和调用重写的父类方法 继承的语法为在类名后的小括号()中写入要继承的父类名,...
  • 菱形继承与虚继承

    千次阅读 2018-08-07 11:23:07
    菱形继承 先介绍一下单继承和多继承  单继承 多继承   菱形继承 菱形继承是单继承和多继承的集合  ...
  • java继承(implements与extends)总结

    万次阅读 多人点赞 2018-04-23 21:40:20
    使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔) 还有几点需要注意: (1)接口可以被多重实现(implements),抽象类...
  • C++ 深入理解 虚继承、多重继承和直接继承
  • 继承——菱形继承

    千次阅读 2019-01-18 20:34:07
    一、菱形继承是什么? 一个派生类有多个基类,多个基类又由同一个类派生,用下列代码来解释 class A { public: int _a; }; class B : public A { public: int _b; }; class C : public A { public: int _c; ...
  • java单继承和多继承

    千次阅读 2019-10-04 19:55:27
    java单继承和多继承 单线程:一个子类只能继承自一个父类 多线程:一个子类可以继承自多个父类 java继承关键字extend和implement,Java所有子类都继承自 java.lang.Object,即java.lang.Object是Java的祖先类,当一...
  • 一个子类继承父类时,可按照public、private和protected方式继承父类,每种继承方式的区别如下:   1) public继承方式 基类中所有public成员在派生类中为public属性; 基类中所有protected成员在派生类中为...
  • C++多继承多重继承

    千次阅读 2019-03-05 21:58:19
    多重继承:一个基类有一个派生类,这个派生类又有一个派生类 多继承:一个派生类有多个基类 下面我们看一个多重继承的例子 #include <iostream> #include <stdlib.h> #include ...
  • C++多继承与虚继承

    千次阅读 2018-12-06 08:57:08
    目录   多继承与虚继承以及存在的问题 例子 多继承与虚继承以及存在的问题 虚继承 ...有了多继承,虚继承才会有意义 ...如果这样继承B,C虚继承了A,virtual public,然后D继承B,C 通常的理...
  • JS继承之组合继承

    千次阅读 2018-09-05 16:39:17
    前面介绍了原型链继承以及构造函数继承,它们都有各自的优缺点 特点 优点 缺点 原型链继承 子类原型prototype对父类实例化来实现 子类不仅仅可以访问父类原型上的属性和方法,同样也可以访问从父类...
  • Python:类的继承,调用父类的属性和方法基础详解

    万次阅读 多人点赞 2018-12-30 11:35:01
    备注:这里省略了关于继承含义的解释,直接上代码了,更直观点 子类:Son类 父类:Father类 以下案例均表示Son类继承父类的一些属性和初始化参数构造等。 5个模块: (1):直接调用父类属性方法; (2):重写...
  • 多重继承和多继承 这个我们来讲讲这两个的概念问题,一字之差,千差万别。 多重继承,比如有三个类,人类-士兵类-步兵类,三个依次继承,这样的继承称为多重继承。class Person {};class Soldier :public Person {...
  • JS继承之寄生继承

    千次阅读 2018-09-05 16:58:57
    JavaScript继承还有一种继承模式——寄生继承。 举个例子: function object(o) { function F() {}; F.prototype = o; return new F(); } var twoD = { name: '2D shape', dimensions: 2 } function triangle...
  • JS继承

    千次阅读 多人点赞 2018-11-11 11:05:41
    最近在面试中被问到js的继承,当时回答的不太好,所以今天特别总结一下。 我们先来看一个基于原型链的继承 //父类 function Person(){} //子类 function Student(){} //继承 Student.prototype = new Person...
  • 继承比单继承更复杂,引入了歧义的问题,以及虚继承的必要性; 虚继承在大小,速度,初始化,复制的复杂性上有不小的代价,当虚基类中没有数据时还是比较合适的; 多继承有时也是有用的。典型的场景是:public继承...
  • 一个子类可以继承多个父类,就是多继承,并且拥有所有父类的属性和方法。 例如 孩子会继承自己的父亲和母亲的特征。 目录 (一)语法 (二)多继承注意事项 (三)钻石继承 (四)多继承中super本质 (一)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 537,898
精华内容 215,159
关键字:

继承