精华内容
下载资源
问答
  • //java只支持单继承,不允许多重继承//可以有多层继承,即一个类可以继承某一个类的子类,如类B继承了few,类C又可以继承B,那么类C也渐渐继承了类A.//这种类型的继承还是第一次见,//类C不能同时继承few ,B;...

    package com.addd;

    //java只支持单继承,不允许多重继承

    //可以有多层继承,即一个类可以继承某一个类的子类,如类B继承了few,类C又可以继承B,那么类C也渐渐继承了类A.

    //这种类型的继承还是第一次见,

    //类C不能同时继承few ,B;

    //在子类的构造方法中可以使用语句super(参数列表)调用父类的构造方法

    public class few {

    public void displayfew() {

    System.out.println("class A is calling");

    }

    }

    class B extends few {

    public void displayB() {

    displayfew();

    System.out.println("class B is calling");

    }

    }

    class C extends B {

    public void displayC() {

    displayB();

    System.out.println("class C is calling");

    }

    }

    测试类

    package com.addd;

    public class Tsf {

    public static void main(String[] args) {

    // new C().displayfew();

    // new C().displayB();

    // new C().displayC();

    // few f=new B();

    // f.displayfew();

    // B f2=new B();

    // f2.displayB();//或者是 new C().displayC(); 全部方法都调用了。

    new C().displayB();

    }

    }

    class A is calling

    class B is calling

    class C is calling

    展开全文
  • 由于业务需要,需要在 feign 的接口上实现多层继承,开开心心撸完代码,却踩了个坑,原来 open-feign 是不支持接口的多层继承与多继承。查看几个解决方案无果,最终在源码的 issues 下找到解决方法。Issues 传送门 ...

     

     


    背景

    由于业务需要,需要在 feign 的接口上实现多层继承,开开心心撸完代码,却踩了个坑,原来 open-feign 是不支持接口的多层继承与多继承。查看几个解决方案无果,最终在源码的 issues 下找到解决方法。Issues 传送门

    一、以下的接口将会导致 feign 报错

    1. 多继承

    2. 多层继承

    二、解决方法

    1.继承 SpringMvcContract,去掉多个接口校验

    public class CustomContract extends SpringMvcContract {
    
        private ResourceLoader resourceLoader;
    
        @Override
        public List<MethodMetadata> parseAndValidatateMetadata(final Class<?> targetType) {
            checkState(targetType.getTypeParameters().length == 0,
                    "Parameterized types unsupported: %s",
                    targetType.getSimpleName());
            final Map<String, MethodMetadata> result = new LinkedHashMap<>();
            for (final Method method : targetType.getMethods()) {
                if (method.getDeclaringClass() == Object.class || (method.getModifiers() & Modifier.STATIC) != 0
                        || Util.isDefault(method)) {
                    continue;
                }
                final MethodMetadata metadata = this.parseAndValidateMetadata(targetType, method);
                checkState(!result.containsKey(metadata.configKey()), "Overrides unsupported: %s", metadata.configKey());
                result.put(metadata.configKey(), metadata);
            }
            return new ArrayList<>(result.values());
        }
    
        @Override
        public MethodMetadata parseAndValidateMetadata(final Class<?> targetType, final Method method) {
            final MethodMetadata methodMetadata = super.parseAndValidateMetadata(targetType, method);
    
            final LinkedList<Class<?>> classHierarchy = new LinkedList<>();
            classHierarchy.add(targetType);
            this.findClass(targetType, method.getDeclaringClass(), classHierarchy);
            classHierarchy.stream()
                    .map(this::processPathValue)
                    .filter(Optional::isPresent)
                    .map(Optional::get)
                    .findFirst()
                    .ifPresent((path) -> methodMetadata.template().insert(0, path));
            return methodMetadata;
        }
    
        private Optional<String> processPathValue(final Class<?> clz) {
            Optional<String> result = Optional.empty();
            final RequestMapping classAnnotation = clz.getAnnotation(RequestMapping.class);
            if (classAnnotation != null) {
                final RequestMapping synthesizeAnnotation = synthesizeAnnotation(classAnnotation, clz);
                // Prepend path from class annotation if specified
                if (synthesizeAnnotation.value().length > 0) {
                    String pathValue = emptyToNull(synthesizeAnnotation.value()[0]);
                    pathValue = this.resolveValue(pathValue);
                    if (!pathValue.startsWith("/")) {
                        pathValue = "/" + pathValue;
                    }
                    result = Optional.of(pathValue);
                }
            }
            return result;
        }
    
        private String resolveValue(final String value) {
            if (StringUtils.hasText(value) && this.resourceLoader instanceof ConfigurableApplicationContext) {
                return ((ConfigurableApplicationContext) this.resourceLoader).getEnvironment().resolvePlaceholders(value);
            }
            return value;
        }
    
        @Override
        protected void processAnnotationOnClass(final MethodMetadata data, final Class<?> clz) {
            // skip this step
        }
    
        private boolean findClass(final Class<?> currentClass, final Class<?> searchClass,
                                  final LinkedList<Class<?>> classHierarchy) {
            if (currentClass == searchClass) {
                return true;
            }
            final Class<?>[] interfaces = currentClass.getInterfaces();
            for (final Class<?> currentInterface : interfaces) {
                classHierarchy.add(currentInterface);
                final boolean findClass = this.findClass(currentInterface, searchClass, classHierarchy);
                if (findClass) {
                    return true;
                }
                classHierarchy.removeLast();
            }
            return false;
        }
    
        @Override
        public void setResourceLoader(final ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
            super.setResourceLoader(resourceLoader);
        }
    }

     

    2.配置 bean

    添加 @ConditionalOnProperty 注解,控制项目是否开启多继承 feign

    @ConditionalOnProperty(name = "com.test.feign.multipleInheritance.enable")
    @Configuration
    public class FeignConfig {
        @Bean
        public Contract feignContract() {
            return new MContract();
        }
    }
    

    此种方法简单粗暴,其他解决方法可参考 https://github.com/OpenFeign/feign/issues/1284

    展开全文
  • 继承 继承 继承作用: 子类默认继承父类的所有属性和方法 在python中,所有类默认继承object类,object类是顶级类或基类,其他子类叫做派生类 # 父类 class A(object): def __init__(self): self.num = 1 ...

    继承

    继承

    继承作用:
    子类默认继承父类的所有属性和方法
    在python中,所有类默认继承object类,object类是顶级类或基类,其他子类叫做派生类
    
    # 父类
    class A(object):
        def __init__(self):
            self.num = 1
    
        def pr(self):
            print(self.num)
    
    # 子类
    class B(A):
        pass
    
    co = B()
    co.pr()
    
    1

    单继承

    单继承:
    徒弟类会继承师父类所有的属性和方法
    
    # 师父类
    class Sf(object):
        def __init__(self):
            self.kongfu = '【超级无敌霹雳上古手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    # 徒弟类
    class Td(Sf):
        pass
    
    he = Td()
    he.make()
    
    运用【超级无敌霹雳上古手法】制作煎饼果子

    多继承

    多继承:
    一个子类继承多个父类的属性和方法
    当一个类有多个父类的时候,默认使用第一个父类的同名属性和方法
    class Sf(object):
        def __init__(self):
            self.kongfu = '【超级无敌霹雳上古手法】'
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class School(object):
        def __init__(self):
            self.kongfu = '【弱鸡手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class Td(School, Sf):
        pass
    
    he = Td()
    he.make()
    
    运用【弱鸡手法】制作煎饼果子

    子类重写父类同名方法和属性

    如果子类和父类有同名的属性和方法,子类创建对象调用属性和方法的时候
    调用的是子类里的同名属性和方法
    
    class Sf(object):
        def __init__(self):
            self.kongfu = '【超级无敌霹雳上古手法】'
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class Td(Sf):
        def __init__(self):
            self.kongfu = '【超级无敌霹雳升级版上古手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作巨大煎饼果子')
    
    he = Td()
    he.make()
    
    运用【超级无敌霹雳升级版上古手法】制作巨大煎饼果子

    __mro__查询继承关系

    语法:
    类名.__mro__
    作用:
    展示类的继承关系
    
    class Sf(object):
        def __init__(self):
            self.kongfu = '【超级无敌霹雳上古手法】'
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class Td(Sf):
        def __init__(self):
            self.kongfu = '【超级无敌霹雳升级版上古手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作巨大煎饼果子')
    
    print(Td.__mro__)
    
    (<class '__main__.Td'>, <class '__main__.Sf'>, <class 'object'>)

    子类调用父类的同名方法和属性

    class Sf(object):
        def __init__(self):
            self.kongfu = '【师父手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class School(object):
        def __init__(self):
            self.kongfu = '【弱鸡手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class Td(School, Sf):
        def __init__(self):
            self.kongfu = '【徒弟手法】'
    
        def make(self):
            self.__init__()
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def Sf_make(self):
            Sf.__init__(self)
            Sf.make(self)
    
        def School_make(self):
            School.__init__(self)
            School.make(self)
    
    one = Td()
    one.make()
    one.Sf_make()
    one.School_make()
    one.make()
    
    运用【徒弟手法】制作煎饼果子
    运用【师父手法】制作煎饼果子
    运用【弱鸡手法】制作煎饼果子
    运用【徒弟手法】制作煎饼果子

    多层继承

    子类会继承父类的所有属性和方法
    
    class Sf(object):
        def __init__(self):
            self.kongfu = '【师父手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class School(object):
        def __init__(self):
            self.kongfu = '【弱鸡手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
    class Td(School, Sf):
        def __init__(self):
            self.kongfu = '【徒弟手法】'
    
        def make(self):
            self.__init__()
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def Sf_make(self):
            Sf.__init__(self)
            Sf.make(self)
    
        def School_make(self):
            School.__init__(self)
            School.make(self)
    
    class Tusun(Td):
        pass
    
    one = Tusun()
    one.make()
    one.Sf_make()
    one.School_make()
    
    运用【徒弟手法】制作煎饼果子
    运用【师父手法】制作煎饼果子
    运用【弱鸡手法】制作煎饼果子

    super调用父类方法

    super()方法自动查找父类,调用顺序遵循__mro__类属性的顺序,比较适合单继承使用
    
    super()带参数写法:
    super(当前类名, self).函数()
    
    class Sf(object):
        def __init__(self):
            self.kongfu = '【师父手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def old_make(self):
            super(Sf, self).__init__()
            super(Sf, self).make()
    
    class School(Sf):
        def __init__(self):
            self.kongfu = '【弱鸡手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def old_make(self):
            super(School, self).__init__()
            super(School, self).make()
    
    class Td(School):
        def __init__(self):
            self.kongfu = '【徒弟手法】'
    
        def make(self):
            self.__init__()
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def old_make(self):
            super(Td, self).__init__()
            super(Td, self).make()
    
    one = Td()
    one.old_make()
    
    two = School()
    two.old_make()
    
    运用【弱鸡手法】制作煎饼果子
    运用【师父手法】制作煎饼果子
    
    super()不带参数写法
    super().函数()
    
    class Sf(object):
        def __init__(self):
            self.kongfu = '【师父手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def old_make(self):
            super().__init__()
            super().make()
    
    class School(Sf):
        def __init__(self):
            self.kongfu = '【弱鸡手法】'
    
        def make(self):
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def old_make(self):
            super().__init__()
            super().make()
    
    class Td(School):
        def __init__(self):
            self.kongfu = '【徒弟手法】'
    
        def make(self):
            self.__init__()
            print(f'运用{self.kongfu}制作煎饼果子')
    
        def old_make(self):
            super().__init__()
            super().make()
    
    one = Td()
    one.old_make()
    
    two = School()
    two.old_make()
    
    运用【弱鸡手法】制作煎饼果子
    运用【师父手法】制作煎饼果子

    私有权限

    定义私有属性和方法

    设置私有权限的方法:
    再属性名和方法名前面加上两个下划线__
    
    class Sf(object):
        def __init__(self):
            self.__money = 100
    
        def __pr(self):
            print('hello')
    
    class Td(Sf):
        pass
    
    one = Td()
    print(one.__money)
    one.__pr()
    
    报错

    获取和修改私有属性值

    一般定义函数get_xx用来获取私有属性,定义set_xx用来修改私有属性值
    
    class Sf(object):
        def __init__(self):
            self.__money = 100
    
        def __pr(self):
            print('hello')
    
        def get_money(self):
            return self.__money
    
        def set_money(self):
            self.__money = 1
    
        def get___Pr(self):
            return self.__pr()
    
    class Td(Sf):
        pass
    
    one = Td()
    print(one.get_money())
    one.set_money()
    print(one.get_money())
    one.get___Pr()
    
    100
    1
    hello

    展开全文
  • 2.类的多层继承 3.类的多重继承 4.类的定制 1.类的继承 继承这个词很好理解,比如你继承了亿万家产,什么都没干一夜暴富。类的继承也是如此,子类继承父类,什么都没干就有了父类所有的属性和方法。 class ...

    目录

    1.类的继承

    2.类的多层继承

    3.类的多重继承

    4.类的定制


    1.类的继承

            继承这个词很好理解,比如你继承了亿万家产,什么都没干一夜暴富。类的继承也是如此,子类继承父类,什么都没干就有了父类所有的属性和方法。

    class Human:
        arms = 2
        legs = 2
        hair = '各种颜色的头发'
        def walk(self):
            print('直立行走')
        def speak(self):
            print('说着各种各样的语言')
    class Chinese(Human):
        pass #pass是空语句,表示跳过,什么都没有。
    Xiaolang = Chinese()
    Xiaolang.walk()
    print(Xiaolang.arms)

    输出:

    直立行走
    2

    2.类的多层继承

            继承不只是子类继承父类的属性的方法,子类也能继承父类的父类的属性和方法。

    多层继承格式
    class A:
    class B(A):
    class Human:
        arms = 2
        legs = 2
        hair = '各种颜色的头发'
        def walk(self):
            print('直立行走')
        def speak(self):
            print('说着各种各样的语言')
    class Chinese(Human):
        pass #pass是空语句,表示跳过,什么都没有。
    class ShanDong(Chinese):
        pass
    Xiaolang = ShanDong()
    Xiaolang.walk()
    print(Xiaolang.arms)

    输出:

    直立行走
    2

    3.类的多重继承

            除了继承一个类,还可以同时继承多个类。语法如下:

    class 类A(类B, 类C, 类D):

             以出生在中国山东的小浪宝宝为例:

    class Chinese:
        hair = '黑头发'
        skin = '黄皮肤'
        def speak(self):
            print('说汉语')
    class Shandong:
        arms = 2
        legs = 2
        def speak(self):
            print('讲山东方言')
    class Human(Chinese, Shandong):
        pass
    
    Xiaolang = Human()
    Xiaolang.speak()
    
    print(Xiaolang.hair)
    print(Xiaolang.arms)

    输出:

    说汉语
    黑头发
    2

             Human 类继承了 Chinese 类和 ShanDong 类的所有属性和方法,但是两个类都有 speak 的方法,Human 类只继承了 Chinese 的。这是因为class Human(Chinese, ShanDong):中的 Chinese 靠前,调用实例的属性和方法时会优先在子类中查找,找不到再从左到右依次查找继承的父类,直到找到,如果找不到会报错

    4.类的定制

            你可能会有疑问,既然子类可以继承父类的所有属性和方法,它俩是一样的,为什么不直接使用父类呢?因为:类除了可以继承以外,还可以定制。在父类的基础上做以下两点定制:

            1.创建新的属性和方法。(新增)

            2.修改继承自父类的属性和方法。(重写)

    class Human:
        arms = 2
        legs = 2
        hair = '各种颜色的头发'
        def walk(self):
            print('直立行走')
        def speak(self):
            print('说着各式各样的语言')
    class Chinese(Human):
        hair = '黑头发'
        skin = '黄皮肤'
        def speak(self):
            print('说汉语')
        def eat(self):
            print('吃馒头')
    
    Xiaolang = Chinese()
    print(Xiaolang.arms)
    Xiaolang.walk()
    Xiaolang.speak()
    Xiaolang.eat()

    输出:

    2
    直立行走
    说汉语
    吃馒头

             Chinese 类在 Human 类的基础上新增了 skin 属性和 eat() 方法,并且 Chinese 类自己的 hair 属性和 speak() 方法覆盖了 Human 类中对应的属性和方法,这就是类的定制的两个特点:新增重写

    新增和重写的概念
    新增继承父类的属性和方法的基础上添加自己独有的属性或方法
    重写在继承父类的属性和方法的基础上重写父类的属性或方法

    《Python——类(__init__初始化 、__str__ 方法的使用及面向对象和向过程的区别)》

    《Python——类(与实例区别、创建、调用、self的作用)》

    加上本文《Pthon——类(类的继承、多层继承、多重继承、定制)》

     在使用类时应特别注意:

            1)定义类的方法时,第一个参数 self 不能丢,调用方法时忽略;

            2)self 作用是代替实例本身,在类种访问类的属性和方法;

            3)初始化方法 __init__() 在类实例化时会自动执行,一般用于类属性的初始化;

            4)子类可以继承父类的所有属性和方法,并且可以定制自己的属性和方法。

    展开全文
  • 展开全部Java代码:classPoint{protectedintx;protectedinty;publicPoint(intx,inty){e5a48de588b63231313335323631343130323136353331333363373166this.x=x;this.y=y;}}classCircleextendsPoint{protec...
  • 1. 多层继承 如果一个类有两个及以上的父类,就把这种继承关系称为多继承. class Master(object): def __init__(self): self.kongfu = "古法煎饼果子配方" def make_cake(self): print("[古法] 按照 <%s>...
  • 多层继承我们知道,如果要直接继承类,子类不可直接多继承,但可通过多层继承实现多继承。但多层继承一般建议不超过三次,且代码较冗余。//多层继承实现多继承class A{//父类A类private int num=10;public int ...
  • 1.在程序中,继承描述的是多个类之间的所属关系。 如果一个类A里面的属性和方法可以复用,则可以通过继承的方式,传递到类B里。 那么类A就是基类,也叫做父类;类B就是派生类,也叫做子类。 单继承:子类只继承一个...
  • 多层继承 super() 私有属性和私有方法 一. 继承的概念 生活中的继承,一般指的是子女继承父辈的财产。 拓展1:经典类或旧式类 不由任意内置类型派生出的类,称之为经典类。 class 类名: 代码 ...... 拓展2:...
  • 首先,声明一组多层继承关系的形状类族。从最抽象、最顶层的基类SHAPE(形状)开始,逐级向下派生出的各级子类依次为:POINT、LINE//CURVE、…..、CUBE//CUBOID//DAM。详细的派生关系如下图所示。
  • 【简答题】实现猜奖游戏:请您输入...【简答题】使用继承思想实现动物类(Animals)、哺乳动物类(Suckler)、猫科动物(Cat)类的多层继承关系。 分析: 动物类(Animals):属性(名称)、行为(吃、休息) 哺乳动物类(Suckler...
  • PHP5多层继承顺序的bug

    2021-04-16 13:29:20
    zend_do_fetch_class 会设置opcode = ZEND_FETCH_CLASS 从这个过程我们可以发现,这个应该是PHP5的bug, 对于fully_qualified_class_name,如果fully_qualified_class_name也是继承来自一个类,那么就会出错, 因为...
  • 一、继承 Python⾯向对象的继承指的是多个类之间的所属关系,即⼦类默认继承⽗类的所有属性和⽅法。 继承作用:继承可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。 在Python中,...
  • 多接口继承多层抽象类设计理解 以JDK集合List框架为例有感(以后可能又会有新的理解,先记录一下) 设计得好的接口一般也要遵循单一职责原则,最上层的接口一般属于独立的,不再有依赖的, 如Iterable接口...
  • Java继承

    2021-02-20 15:27:34
    继承 在现实生活中,继承一般指的是子女继承父辈的财产。在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。例如公司中的研发部员工和维护部员工都属于员工,程序中便可以...
  • 接口只是比抽象类“更纯”的一种形式。它的用途并不止那些。由于接口根本没有具体的实施...在C++中,将多个类合并到一起的行动称作“多重继承”,而且操作较为不便,因为每个类都可能有一套自己的实施细节。在Java...
  • 多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需要...
  • 继承涉及一个对象,该对象获取另一个对象的属性和行为。因此,基本上,使用继承可以通过创建一个新类来扩展该类的功能,该新类可以通过继承前一个类来构建。多级继承是指一个类继承一个类,而该类又继承了另一个类。...
  • Java 实现“多继承

    2021-03-16 13:36:59
    一、Java语言特点Java是一种简单、面向对象、分布式、易读、鲁棒、安全、结构明晰、可移植、高...多继承:指一个子类同时继承多个父类,从而具备多个父类的特征多继承会造成1、若子类继承的父类中拥有相同的成员变量...
  • Java SE基础(十一)面向对象2概述类的继承好处与弊端Java中继承的特点Java继承中成员变量与成员方法的特点方法重写类的多态好处与弊端向上转型与向下转型判断是否为同一类对象中的成员访问特点尾言 概述 之前有写过...
  • Java中的多级继承

    2021-04-17 09:45:25
    多级继承-类从再次继承属性的类继承属性。示例classShape{publicvoiddisplay(){System.out.println("Insidedisplay");}}classRectangleextendsShape{publicvoidarea(){System.out.println("Insidearea");}}...
  • "middle3") class Top(Middle1, Middle2, Middle3): def __init__(self): super(Top, self).__init__("top") # Here is where it produces the error if __name__ == '__main__': Top() 我不理解这个多重继承问题是...
  • java多个类继承的方法问题实例。假设有三个类,ClassA-ClassB-ClassC,ClassC在最底端。先看例子:public class ClassA {public void fun1(){System.out.println(“A-fun1″);}public void fun2(){System.out....
  • 其中的原因有以下几点: 第一、子类对父类的继承是全部的公有和受保护的继承,这使得子类可能继承了对子类无用甚至有害的父类的方法。换句话说,子类只希望继承父类的一部分方法,怎么办? 第二、实际的对象千变万化...
  • 本文实例讲述了php 多继承的几种常见实现方法。分享给大家供大家参考,具体如下:class Parent1 {function method1() {}function method2() {}}class Parent2 {function method3() {}function method4() {}}class ...
  • //: c07:Sandwich.java// Order of constructor calls.// package c07;// import ...import java.util.*;class Meal {Meal() { System.out.println("Meal()"); }}class Bread {Bread() { S...
  • 众所周知,java是一门不支持多重继承的语言,每当在java中谈及多重继承,人们都会说起接口。然而一般理解之下,既然是接口,里面的方法是不能有具体实现的,顶多也就起到一个规范的作用嘛,这样岂不是还会造成代码的...
  • 最近研究java的方法覆盖时发现了一篇蛮好的文章,记录下来分享下:首先申明:static的方法和变量只能隐藏,不能覆盖大多数好的设计者象躲避瘟疫一样来避免使用实现继承(extends 关系)。实际上80%的代码应该完全用...
  • 一、继承使用package java面向对象;/*** 测试对象继承*/public class TestExtends {public static void main(String[] args) {Student stu=new Student("小明","挖掘机",18);}}class Person{String name;int height;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,748
精华内容 19,499
关键字:

多层继承

友情链接: ABC_1.zip