精华内容
下载资源
问答
  • 由于接口根本没有具体的实施细节——也就是说,没有与存储空间与“接口”关联在一起——所以没有任何办法可以防止多个接口合并到一起。这一点是至关重要的,因为我们经常都需要表达这样一个意思:“x 从属于a,也从...

    接口只是比抽象类“更纯”的一种形式。它的用途并不止那些。由于接口根本没有具体的实施细节——也就

    是说,没有与存储空间与“接口”关联在一起——所以没有任何办法可以防止多个接口合并到一起。这一点

    是至关重要的,因为我们经常都需要表达这样一个意思:“x 从属于a,也从属于b,也从属于c”。在C++

    中,将多个类合并到一起的行动称作“多重继承”,而且操作较为不便,因为每个类都可能有一套自己的实

    施细节。在Java 中,我们可采取同样的行动,但只有其中一个类拥有具体的实施细节。所以在合并多个接口

    的时候,C++的问题不会在Java 中重演。如下所示:

    4dfd4131d4a01239.png

    在一个衍生类中,我们并不一定要拥有一个抽象或具体(没有抽象方法)的基础类。如果确实想从一个非接

    口继承,那么只能从一个继承。剩余的所有基本元素都必须是“接口”。我们将所有接口名置于implements

    关键字的后面,并用逗号分隔它们。可根据需要使用多个接口,而且每个接口都会成为一个独立的类型,可

    对其进行上溯造型。下面这个例子展示了一个“具体”类同几个接口合并的情况,它最终生成了一个新类:

    //: Adventure.java//Multiple interfaces

    import java.util.*;interfaceCanFight {voidfight();

    }interfaceCanSwim {voidswim();

    }interfaceCanFly {voidfly();

    }classActionCharacter {public voidfight() {}

    }class Hero extendsActionCharacterimplementsCanFight, CanSwim, CanFly {public voidswim() {}public voidfly() {}

    }public classAdventure {static voidt(CanFight x) { x.fight(); }static voidu(CanSwim x) { x.swim(); }static voidv(CanFly x) { x.fly(); }static voidw(ActionCharacter x) { x.fight(); }public static voidmain(String[] args) {

    Hero i= newHero();

    t(i);//Treat it as a CanFight

    u(i); //Treat it as a CanSwim

    v(i); //Treat it as a CanFly

    w(i); //Treat it as an ActionCharacter

    }

    }///:~

    从中可以看到,Hero 将具体类ActionCharacter 同接口CanFight,CanSwim 以及CanFly 合并起来。按这种

    形式合并一个具体类与接口的时候,具体类必须首先出现,然后才是接口(否则编译器会报错)。

    请注意fight()的签名在CanFight 接口与ActionCharacter 类中是相同的,而且没有在Hero 中为fight()提

    供一个具体的定义。接口的规则是:我们可以从它继承(稍后就会看到),但这样得到的将是另一个接口。

    如果想创建新类型的一个对象,它就必须是已提供所有定义的一个类。尽管Hero 没有为fight()明确地提供

    一个定义,但定义是随同ActionCharacter 来的,所以这个定义会自动提供,我们可以创建Hero 的对象。

    在类Adventure 中,我们可看到共有四个方法,它们将不同的接口和具体类作为自己的自变量使用。创建一

    个Hero 对象后,它可以传递给这些方法中的任何一个。这意味着它们会依次上溯造型到每一个接口。由于接

    口是用Java 设计的,所以这样做不会有任何问题,而且程序员不必对此加以任何特别的关注。

    注意上述例子已向我们揭示了接口最关键的作用,也是使用接口最重要的一个原因:能上溯造型至多个基础

    类。使用接口的第二个原因与使用抽象基础类的原因是一样的:防止客户程序员制作这个类的一个对象,以

    176

    及规定它仅仅是一个接口。这样便带来了一个问题:到底应该使用一个接口还是一个抽象类呢?若使用接

    口,我们可以同时获得抽象类以及接口的好处。所以假如想创建的基础类没有任何方法定义或者成员变量,

    那么无论如何都愿意使用接口,而不要选择抽象类。事实上,如果事先知道某种东西会成为基础类,那么第

    一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候,才应考虑采用抽象类。

    展开全文
  • java继承

    2017-10-30 15:45:00
    为了防止继承被滥用,有如下使用条件: 当某个类会比其父类更具有特定意义时使用继承。例:短尾猫 IS-A 猫 在行为程序应该被多个相同基本类型类所共享时,应该要考虑使用继承。例:方形、圆形、三角形 I...

    措辞

    1. Y是继承类X == 类X是类Y的父类 == Y IS-A X
    2. IS-A测试具有传递性,即:若Y IS-A X,且Z IS-A Y,则Z IS-A X
    3. IS-A关系是单向的

    条件

    为了防止继承被滥用,有如下使用条件:

    1. 当某个类会比其父类更具有特定意义时使用继承例:短尾猫 IS-A 猫
    2. 在行为程序应该被多个相同基本类型类所共享时,应该要考虑使用继承例:方形、圆形、三角形 IS-A 具有旋转、发声的类
    3. 若两者间的关系对于继承结构来说并不合理,则不要只是因为打算要重用其他类的程序代码而运用继承
    4. 如果两者间不能通过IS-A测试,就不要应用继承

    转载于:https://www.cnblogs.com/pualus/p/7754808.html

    展开全文
  • Java继承

    2016-06-27 16:03:15
    Java继承是面向对象的第二个特性,Java只支持单继承防止产生二义性,以免出现同时继承多个类,而类又有相同的方法,JVM一下子不知道要找哪个类的方法了,瞬间蒙蔽,over。继承,首先要有继承,就必须存在关系。...

    Java继承是面向对象的第二个特性,Java只支持单继承,防止产生二义性,以免出现同时继承多个类,而类又有相同的方法,JVM一下子不知道要找哪个类的方法了,瞬间蒙蔽,over。

    继承,首先要有继承,就必须存在关系。比如,父与子的关系。

    继承关系中,父类又称为基类,子类又称为派生类。

    继承,使得子类可以从父类继承父类所拥有的属性和行为,并添加一些属于自己的属性和行为。

    继承的特征:传递性、可重用性、易维护性。

    为什么说具有传递性?

    比如有3个类ABC,A是B的父类,B是C的父类,那么A也算是C的父类(其实是爷爷类),总之就是A中有的属性和行为,C可以继承到。这就是所谓的传递性。

    为什么说具有可重用性?

    一个类中的属性和行为可以被多个子类所使用,不用子类再单独去写啊写啊,一个父类就解决,简单粗暴无冗余,就是所说的可重用性。

    为什么说具有易维护性?

    子类今天想用这个父类,明天想用那个父类,一个extends分分钟解决,不必再删啊删啊,添加啊添加啊。传说中的,Java通过增强程序的一致性来减少模块接口之间的耦合程度来提高维护性。

    展开全文
  • java中final关键字 While one of Java's strengths is the concept of inheritance, in which one class can derive from another, sometimes it's desirable to prevent inheritance by another class. To prevent ...

    While one of Java's strengths is the concept of inheritance, in which one class can derive from another, sometimes it's desirable to prevent inheritance by another class. To prevent inheritance, use the keyword "final" when creating the class.

    虽然Java的优势之一是继承的概念,其中一个可以从另一个派生,但有时还是希望防止另一个类进行继承。 为防止继承,在创建类时使用关键字“ final”。

    For example, if a class is likely to be used by other programmers, you may wish to prevent inheritance if any subclasses created could cause problems. A typical example is the String class. If we wanted to create a String subclass:

    例如,如果一个类可能被其他程序员使用,则如果创建的任何子类可能引起问题,则您可能希望防止继承。 一个典型的例子是String类 。 如果我们想创建一个String子类:

    public class MyString extends String{
    }

    We would be faced with this error:

    我们将面临以下错误:

     cannot inherit from final java.lang.String 
    

    The designers of the String class realized that it was not a candidate for inheritance and have prevented it from being extended.

    String类的设计者意识到它不是继承的候选者,因此阻止了对其进行扩展。

    为什么要防止继承? ( Why Prevent Inheritance? )

    The main reason to prevent inheritance is to make sure the way a class behaves is not corrupted by a subclass.

    防止继承的主要原因是确保类的行为方式不会被子类破坏。

    Suppose we have a class Account and a subclass that extends it, OverdraftAccount. Class Account has a method getBalance():

    假设我们有一个Account类和一个扩展它的子类OverdraftAccount。 类帐户具有方法getBalance():

     public double getBalance()
    {
     return this.balance;
     } 
    

    At this point in our discussion, subclass OverdraftAccount has not overridden this method.

    至此,在我们的讨论中,子类OverdraftAccount尚未覆盖此方法。

    (Note: For another discussion using this Account and OverdraftAccount classes, see how a subclass can be treated as a superclass).

    ( :有关使用此Account和OverdraftAccount类的另一讨论,请参见如何将子类视为超类 )。

    Let's create an instance each of the Account and OverdraftAccount classes:

    让我们为每个Account和OverdraftAccount类创建一个实例:

     Account bobsAccount = new Account(10);
     bobsAccount.depositMoney(50);
     OverdraftAccount jimsAccount = new OverdraftAccount(15.05,500,0.05);
     jimsAccount.depositMoney(50);
     //create an array of Account objects
     //we can include jimsAccount because we 
     //only want to treat it as an Account object
     Account[] accounts = {bobsAccount, jimsAccount};
     //for each account in the array, display the balance
     for (Account a:accounts)
     {
     System.out.printf("The balance is %.2f%n", a.getBalance());
     }
     The output is:
     The balance is 60.00
     The balance is 65.05 
    

    Everything appears to work as expected, here. But what if OverdraftAccount overrides the method getBalance()? There is nothing to prevent it from doing something like this:

    一切似乎都按预期工作,在这里。 但是,如果OverdraftAccount覆盖方法getBalance()怎么办? 没有什么可以阻止它执行以下操作:

     public class OverdraftAccount extends Account {
     private double overdraftLimit;
     private double overdraftFee;
     //the rest of the class definition is not included
     public double getBalance()
     {
     return 25.00;
     }
     } 
    

    If the example code above is executed again, the output will be different because the getBalance() behavior in the OverdraftAccount class is called for jimsAccount:

    如果再次执行上述示例代码,则输出将不同,因为 为jimsAccount调用OverdraftAccount类中的getBalance()行为:

     The output is:
     The balance is 60.00
     The balance is 25.00 
    

    Unfortunately, the subclass OverdraftAccount will never provide the correct balance because we have corrupted the behavior of the Account class through inheritance.

    不幸的是,子类OverdraftAccount将永远无法提供正确的余额,因为我们已经通过继承破坏了Account类的行为。

    If you design a class to be used by other programmers, always consider the implications of any potential subclasses. This is the reason the String class cannot be extended. It's extremely important that programmers know that when they create a String object, it's always going to behave like a String.

    如果您设计一个供其他程序员使用的类,请始终考虑任何潜在子类的含义。 这就是无法扩展String类的原因。 程序员必须知道,当他们创建一个String对象时,它总是表现得像String一样,这一点非常重要。

    如何防止继承 ( How to Prevent Inheritance )

    To stop a class from being extended, the class declaration must explicitly say it cannot be inherited. This is achieved by using the "final" keyword:

    为了阻止扩展类,类声明必须明确声明它不能被继承。 这可以通过使用“ final”关键字来实现:

     public final class Account {
     } 
    

    This means that the Account class cannot be a superclass, and the OverdraftAccount class can no longer be its subclass.

    这意味着Account类不能是超类,而OverdraftAccount类不能再作为其子类。

    Sometimes, you may wish to limit only certain behaviors of a superclass to avoid corruption by a subclass. For example, OverdraftAccount still could be a subclass of Account, but it should be prevented from overriding the getBalance() method.

    有时,您可能希望仅限制超类的某些行为,以避免子类损坏。 例如,OverdraftAccount仍然可以是Account的子类,但应避免覆盖getBalance()方法。

    In this case use, the "final" keyword in the method declaration:

    在这种情况下,使用方法声明中的“ final”关键字:

     public class Account {
     private double balance;
     //the rest of the class definition is not included
     public final double getBalance()
     {
     return this.balance;
     } 
     } 
    

    Notice how the final keyword is not used in the class definition. Subclasses of Account can be created, but they can no longer override the getBalance() method. Any code calling that method can be confident it will work as the original programmer intended.

    注意在类定义中如何不使用final关键字。 可以创建Account的子类,但是它们不能再覆盖getBalance()方法。 任何调用该方法的代码都可以确信它会按原始程序员的意图工作。

    翻译自: https://www.thoughtco.com/how-to-prevent-inheritance-2034337

    展开全文
  • Java继承的特点

    2019-10-26 23:26:54
    Java继承的特点 在java中,继承具有以下特点: 1.只支持单继承,即一个子类只允许有一个父类。 2. 子类可以拥有父类的属性和方法 3. 子类可以拥有自己的属性和方法 4. 子类可以重写覆盖父类的方法 提示:为防止...
  • JAVA 继承

    2013-05-14 18:48:06
    继承可以防止代码的重复。 子类的可以覆盖父类的方法,子类可以有自己新的方法,子类可以继承父类非private的方法,protected方法只能继承一次 方法的重载见:...
  • JAVA是不支持多继承的,目的是防止出现环形继承出现,Python是支持多继承的,java一定要支持多继承的话,可以在内部类里实现,Java里接口是支持多实现的。 但是Java是支持多层继承的。 ...
  • 但继承和多态概念还有一些相关的细节,本节就来探讨这些细节,具体包括:构造方法重名与静态绑定重载和重写父子类型转换继承访问权限 (protected)可见性重写防止继承 (final)下面我们逐个来解释。构造方法super上节...
  • Java继承与接口

    2015-06-30 09:18:00
    为什么Java里面只允许单一继承,但允许实现多个接口? 1,为什么不能实现类的多继承?主要是防止多个类有相同的方法名,然而方法体不一样,子类就比较难选择了。所以java和C#不支持类的多继承2,允许具有多个接口的...
  • 没有本质的关系,主要是语言设计者进行定义规范,防止二义性。 Java定义的规范: 子类可以继承父类的protected、public修饰的方法和字段。 代码 package com.github.noodzhan.test; /** * @author noodzhan <...
  • Java 封装和继承

    2019-12-01 10:40:45
    文章目录第三章-封装和继承1、什么是封装2、访问权限控制3、static关键字4、继承的用法5、子类可以继承父类的内容6、何时使用继承: ...改为private(防止错误修改属性值) 2)创建公有的(public)getter和...
  • Java中,只要是被...为了防止用户对基本类进行相应的扩展,也体现了java设计过程中的开闭原则,最终将这些类设计成为final的。这是final的规定:当你将final用于类身上时,一个final类是无法被任何人继承的,那...
  • JAVA类的继承

    2018-08-26 20:44:12
    类的继承 - extends 继承的定义 继承是面向对象的三大特性之一,也是实现软件复用的重要手段 继承的意思就是把父类的属性和方法复制到子类,拥有...所有类里面都应该些一个无参的构造器,防止没有显示的调用父类构...
  • Java学习之:继承

    2019-07-14 18:31:40
    之前学了java,很多东西很基础的都有点忘记了,但是只知道怎么用,现在放在博客里,防止记忆丢失 继承的特性: 子类拥有父类非 private 的属性、方法。 子类可以拥有自己的属性和方法,即子类可以对父类...
  • 继承主要是为了防止基类里的方法和变量混淆。  在接口中不能有实例变量,只能有静态的常量,不能有具体的方法(包含方法体),只能有抽象方法。  Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以...
  • 走进Java继承的世界

    2020-11-08 23:09:52
    找出具有共同属性和行为的对象,用继承防止子类中出现重复的程序代码。 设计代表共同状态与行为的类 #mermaid-svg-B29MnQGq4ms9HgjS .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--...
  • java封装与继承

    2020-07-21 18:22:56
    好处:便于使用者正确使用系统,防止错误修改属性 有助于系统之间的松耦合,提高系统独立性 提高软件的可重用性 降低了构建大型系统的风险 包:包名由小写字母组成,不能以圆点开头或结尾 包名之前最好加上唯一...
  • 防止命名冲突,不用为重名烦恼;2.可以使类组成一个单元或模块,便于管理和维护;3.更好的保护类,属性和方法。package 用于定义包,必须写在有效源代码的第一句。写法如下package cn.sxt; public class Test01{ ...
  • 向上/向下转型 向上转型:Person p = new Student; 将子类型用父类型进行...操作符instanceof:在向下转型之前判断,防止报错 可以判断对象是否时某一类型或其子类(是的话都为true);但对象为 null 时总是fals...
  • Java继承和接口

    2016-11-03 14:40:00
    使用接口的第二个原因与使用抽象基础类的原因是一样的:防止客户程序员制作这个类的一个对象,以及规定它仅仅是一个接口。这样便带来了一个问题:到底应该使用一个接口还是一个抽象类呢?若使用接口,我们可以同时...
  • Java封装、继承、多态

    2021-01-12 10:29:54
    Java封装、继承、多态一、封装2.1 封装概述 一、封装 2.1 封装概述 概述:面向对象编程语言是对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。 封装可以被认为是一个保护屏障...
  • java封装和继承

    2016-12-21 20:32:27
     好处:便于使用者正确的使用系统,防止错误修改方式  有助于系统之间的耦合,提高系统独立性  a.使用private修饰属性  b.提供setter和getter  c.写过滤代码 3.权限修饰符      priv
  • 如何防止类被继承

    2016-03-12 10:56:05
    java中如何防止类被继承
  • Java_封装和继承

    2019-04-17 21:38:25
    Java_封装和继承 封装: 封装在面向对象设计方法中是指将抽象性接口的实现方法包装和隐藏起来的方法。封装方法是为了防止代码数据被外部的代码方法随机访问,需要访问的话就必须通过封装方法暴露在外的方法或者...
  • Java之封装与继承

    2020-07-22 09:08:24
    Java之封装与继承 一、封装 封装的概念: 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问,把尽可能多的东西藏起来,对外提供便捷的接口 封装的方法: ...
  • JAVA基础之封装继承多态 文章目录系列文章目录前言一、封装二、继承三、多态总结 前言 封装,继承,多态是JAVA面向对象的三大特性,也是最基本的知识 提示:以下是本篇文章正文内容,下面案例可供参考 一、封装 ...
  • java中的继承关系 我们知道有时候在写程序的时候,会遇到多个代码块儿,或者说是方法块儿是重复的,这对我们的程序是非常不好的,会导致文件内存大,并且看起来比较乱,这时,我们就可以想到继承,我们可以首先写好...
  • java继承和封装总结

    2018-04-20 21:04:11
    1、一个方法或一个块内定义的变量是否可以在方法外或块外使用?这种变量称为什么?方法的形式参数是否...说白点,我们之所以要用到封装,就是为了防止有人恶意修改你的数据。我们来看下面一个列子你就明白了Cat.h...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 874
精华内容 349
关键字:

java防止继承

java 订阅