精华内容
下载资源
问答
  • class Base { private Base() { } public Base(String str) { test(); ...private void test() //①号test方法 ...System.out.println("将被子类重写方法"); } } public class Sub extends Base { /
    class Base
    {
    private Base()
    {
    
    }
    public  Base(String str)
    {
    test();
    }
    private void test()           //①号test方法
    {
    System.out.println("将被子类重写的方法");
    }
    }
    public class Sub extends Base
    {
    /**
    * @param str
    */
    public Sub(String str)
    {
    super(str);
    // TODO Auto-generated constructor stub
    }
    private<span style="color:#ff0000;"> static</span> String name;
    public void test()        //②号test方法
    {
    System.out.println("子类重写父类的方法,"
    + "其name字符串长度" + name.length());
    }
    public static void main(String[] args)
    {
    
    Sub s = new Sub(<span style="color:#ff0000;">name</span>);
    }
    }


    可以看到输出结果将是“将被子类重写的方法”

    解释:因为1号test方法是被private修饰的,所以不能被子类继承,与2号的test方法并不构成重写关系,因此并不会发生空指针异常

    这里要注意红色部分需要定义成static类型的

    展开全文
  • 继承是面向对象语言的一个重要特征,在进行大型项目开发的时候其优点尤其明显,这里对java中应用继承时的几点注意事项(容易出错的地方)进行了总结。笔者本打算将这几种现象从基本原理上解释一下,但是想来想去都感觉...

    继承是面向对象语言的一个重要特征,在进行大型项目开发的时候其优点尤其明显,这里对java中应用继承时的几点注意事项(容易出错的地方)进行了总结。笔者本打算将这几种现象从基本原理上解释一下,但是想来想去都感觉无从下手,因为需要读者比较了解java虚拟机的内部机制,很多东西比较抽象,所以看到这篇文章的读者记住下面这几种现象就行了,如果想深入理解其本质原理,建议大家读一下《深入java虚拟机》这本书。

    一、最常见的一种,对象的上转型对象:即运行时多态(这种情况相信大家都知道,为了文章的完整性也放到了这里)

    示例:

    public class TestExtend{

    public static void main(String args[]){

    Person p=new Person();

    p.disp();

    Student s=new Student();

    p=s;

    p.disp();

    }

    }

    class Person{

    int a;

    public Person(){

    a=1;

    }

    public void disp(){

    System.out.println(a);

    }

    }

    class Student extends Person{

    int a;

    public Student(){

    a=2;

    }

    public void disp(){

    System.out.println(a);

    }

    }

    解析:上面的程序会先输出1,然后输出2。

    输出1时,p指向的就是Person的实例,调用Person类的disp()方法,输出Person实例的属性a=1;输出2时,p指向的是Student的实例,调用Student的disp()方法,输出Student实例的属性a=2。

    二、情况二

    示例:

    public class TestExtend{

    public static void main(String args[]){

    Student s=new Student();

    s.disp();

    }

    }

    class Person{

    int a;

    public Person(){

    a=1;

    }

    public void disp(){

    System.out.println(a);

    }

    }

    class Student extends Person{

    int a;

    public Student(){

    a=2;

    }

    }

    解析:运行上面的程序,输出的是1还是2?你会看到输出的是1!

    上面的程序中Person和Student类中都有a属性,我们定义了一个Student的对象s,调用s的disp()方法输出的不是Student的a而是Person的a。相信很多人在运行程序前都会觉得应该输出2,但结果告诉我们输出的就是1!子类Student虽然覆盖了父类的属性a,但子类没有重写父类的disp()方法,对象s调用disp()方法时调用的依然是父类的方法,而父类方法访问的依然是父类的a,而不是子类的a。这里或者重写父类的disp()方法,或者将Student中的int a;注释掉才能输出2!

    其实上面程序在逻辑上是有问题的,既然继承了父类的属性,就不应该在子类中从新定义一遍,子类中可以增加属性,但是重写属性没有什么意义!这里这样演示,是想说明这样一种情况。

    三、情况三:类属性没有多态

    示例:

    public class TestExtend{

    public static void main(String args[]){

    Person p;

    Student s=new Student();

    p=s;

    System.out.println(p.a);

    }

    }

    class Person{

    int a;

    public Person(){

    a=1;

    }

    public void disp(){

    System.out.println(a);

    }

    }

    class Student extends Person{

    int a;

    public Student(){

    a=2;

    }

    public void disp(){

    System.out.println(a);

    }

    }

    解析:上面的程序输出的是1;

    即使在Student类中从新定义了一遍a,并且p指向了Student的实例,上面输出的是依然是Person的a而不是Student的a,属性是没有多态现象的。和上面一样,在子类中定义父类中已经定义了的属性,是没有意义的,既然父类已经有了某个属性,子类直接继承就是了,重写一遍从道理上根本说不清。很多初学者,对继承理解不是很透彻,很多论坛上都在问很多关于在子类中复写了父类的属性,访问中遇到的问题,其实这是自找麻烦。

    展开全文
  • java 继承重写注意

    2018-11-24 19:07:59
    LSP: 子类能够出现的地方, 父类一定可以替换出现, 并且不影响程序的运行, 外界无法判断是使用了父类还是子类 但是! 子类出现的地方, 父类不一定可以替换 如何遵守LSP 子类可以有自己的特性 子类可以相对于父类有...

    继承要记住满足里式替换原则(LSP)

    LSP: 子类能够出现的地方, 父类一定可以替换出现, 并且不影响程序的运行, 外界无法判断是使用了父类还是子类
    但是! 子类出现的地方, 父类不一定可以替换

    如何遵守LSP

    子类可以有自己的特性

    子类可以相对于父类有自己的特殊性, 但不应该讲父类的方法修改得面目全非
    比如说:(具体代码参考https://blog.csdn.net/BeyondHaven/article/details/6826013)
    父类是矩形 , 拥有设置长宽的方法, 子类是正方形, 只能设置边长 , 所以这违背了LSP

    子类必须完全实现父类的方法

    覆盖或实现父类的方法时输入参数的约束可以被放大, 不可以被缩小

    如果约束缩小 , 父类替换出现时会出现取值在子类约束之外 但在父类约束之内的情况

    覆盖或实现父类的方法时输出结果可以被缩小, 不可以放大

    继承的风险

    • 继承是入侵性的(只要继承,就必须拥有父类的所有属性与方法);
    • 降低了代码的灵活性(子类拥有了父类的属性方法,会增多约束);
    • 增强了耦合性(当父类的常量、变量、方法被修改时,必需要考虑子类的修改)。

    参考链接

    https://blog.csdn.net/yuanlong_zheng/article/details/7425919

    展开全文
  • 继承是面向对象语言的一个重要特征,在进行大型项目开发的时候其优点尤其明显,这里对java中应用继承时的几点注意事项(容易出错的地方)进行了总结。笔者本打算将这几种现象从基本原理上解释一下,但是想来想去都感觉...

    继承是面向对象语言的一个重要特征,在进行大型项目开发的时候其优点尤其明显,这里对java中应用继承时的几点注意事项(容易出错的地方)进行了总结。笔者本打算将这几种现象从基本原理上解释一下,但是想来想去都感觉无从下手,因为需要读者比较了解java虚拟机的内部机制,很多东西比较抽象,所以看到这篇文章的读者记住下面这几种现象就行了,如果想深入理解其本质原理,建议大家读一下《深入java虚拟机》这本书。

    一、最常见的一种,对象的上转型对象:即运行时多态(这种情况相信大家都知道,为了文章的完整性也放到了这里)

    示例:

    [java] view plaincopy
    1. public class TestExtend{  
    2.     public static void main(String args[]){  
    3.         Person p=new Person();  
    4.         p.disp();  
    5.         Student s=new Student();  
    6.         p=s;      
    7.         p.disp();  
    8.     }  
    9. }  
    10.   
    11. class Person{  
    12.     int a;  
    13.     public Person(){  
    14.         a=1;  
    15.     }  
    16.     public void disp(){  
    17.         System.out.println(a);  
    18.     }  
    19. }  
    20.   
    21. class Student extends Person{  
    22.     int a;  
    23.     public Student(){  
    24.         a=2;  
    25.     }  
    26.     public void disp(){  
    27.         System.out.println(a);  
    28.     }  
    29. }  

    解析:上面的程序会先输出1,然后输出2。

    输出1时,p指向的就是Person的实例,调用Person类的disp()方法,输出Person实例的属性a=1;输出2时,p指向的是Student的实例,调用Student的disp()方法,输出Student实例的属性a=2。

     

    二、情况二

    示例:

    [java] view plaincopy
    1. public class TestExtend{  
    2.     public static void main(String args[]){  
    3.         Student s=new Student();  
    4.         s.disp();  
    5.     }  
    6. }  
    7.   
    8. class Person{  
    9.     int a;  
    10.     public Person(){  
    11.         a=1;  
    12.     }  
    13.     public void disp(){  
    14.         System.out.println(a);  
    15.     }  
    16. }  
    17.   
    18. class Student extends Person{  
    19.     int a;  
    20.     public Student(){  
    21.         a=2;  
    22.     }  
    23. }  

    解析:运行上面的程序,输出的是1还是2?你会看到输出的是1!

    上面的程序中Person和Student类中都有a属性,我们定义了一个Student的对象s,调用s的disp()方法输出的不是Student的a而是Person的a。相信很多人在运行程序前都会觉得应该输出2,但结果告诉我们输出的就是1!子类Student虽然覆盖了父类的属性a,但子类没有重写父类的disp()方法,对象s调用disp()方法时调用的依然是父类的方法,而父类方法访问的依然是父类的a,而不是子类的a。这里或者重写父类的disp()方法,或者将Student中的int a;注释掉才能输出2!

    其实上面程序在逻辑上是有问题的,既然继承了父类的属性,就不应该在子类中从新定义一遍,子类中可以增加属性,但是重写属性没有什么意义!这里这样演示,是想说明这样一种情况。

     

    三、情况三:类属性没有多态

    示例:

    [java] view plaincopy
    1. public class TestExtend{  
    2.     public static void main(String args[]){  
    3.         Person p;  
    4.         Student s=new Student();  
    5.         p=s;  
    6.         System.out.println(p.a);      
    7.     }  
    8. }  
    9.   
    10. class Person{  
    11.     int a;  
    12.     public Person(){  
    13.         a=1;  
    14.     }  
    15.     public void disp(){  
    16.         System.out.println(a);  
    17.     }  
    18. }  
    19.   
    20. class Student extends Person{  
    21.     int a;  
    22.     public Student(){  
    23.         a=2;  
    24.     }  
    25.     public void disp(){  
    26.         System.out.println(a);  
    27.     }  
    28. }  

    解析:上面的程序输出的是1;

    即使在Student类中从新定义了一遍a,并且p指向了Student的实例,上面输出的是依然是Person的a而不是Student的a,属性是没有多态现象的。和上面一样,在子类中定义父类中已经定义了的属性,是没有意义的,既然父类已经有了某个属性,子类直接继承就是了,重写一遍从道理上根本说不清。很多初学者,对继承理解不是很透彻,很多论坛上都在问很多关于在子类中复写了父类的属性,访问中遇到的问题,其实这是自找麻烦。

    展开全文
  • 1、对于一个引用类型的变量,java编译器按照它...所有能应用父类的地方,都能换成子类,但反过来是不成立的。所以,一个类的实例包括其本身的累的实例,也包括其实子类或间接子类的实例。3、第一条说道是在编译期,...
  • 继承是面向对象语言的一个重要特征,在进行大型项目开发的时候其优点尤其明显,这里对java中应用继承时的几点注意事项(容易出错的地方)进行了总结。笔者本打算将这几种现象从基本原理上解释一下,但是想来想去都感觉...
  • java异常分为两种: checked exception和runtime exception checked 属于可恢复异常,继承自exception 而runtime属于不可恢复异常,继承自RuntimeException think in java里提到异常可能会被遗漏...
  • Java的继承

    2020-05-04 23:45:21
    继承中需要注意的地方,列出来提醒我自己 继承继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的...
  • 1、有子父类继承,2、子类重写父类方法,3、父类是子类对象引用 多态子父类中成员变量和成员方法之间关系: 1、成员变量:父类有,子类有,拿父类成员方法 父类有,子类没有,拿父类成员方法 父类...
  • java中类的继承中应该注意的问题

    千次阅读 2013-04-25 17:37:57
    每一门语言中都有很多小问题,同学们平时都注意不到,我在做题的时候也会犯同样的错误,今天写出来帮大家提个醒,以下是我在写代码的时候遇到的问题,写的不对的地方还望您能提出来,大家可以互相讨论:   1、在一...
  • 一般子类被称为派生类,父类称为基类(super)extends需要注意的地方java不允许多重继承(一个类只能继承一个父类,不能继承多个父类)、派生类会继承基类所有属性和方法,但不能直接访问基类的private私有属性实例化派生...
  • 一般子类被称为派生类,父类称为基类(super)extends需要注意的地方java不允许多重继承(一个类只能继承一个父类,不能继承多个父类)、派生类会继承基类所有属性和方法,但不能直接访问基类的private私有属性实例化派生...
  • 我们可能在一些地方需要用到(带参)构造方法(假设这个类为父类),但是某一个子类在继承父类时候发现错误,如下图所示 父类这样子: 子类是这样子: 错误提示为: 大概因为意思就是: 对于默认...
  • 之前在JavaOO(7)中讲到过继承,不过因为篇幅关系讲的比较浅,有些需要注意...由于继承的基础点都在紫薇星上的Java——JavaOO(7)这篇文章中讲过,感兴趣的同学可以去看一下,这篇文章会开始补充细节和需要注意的地方
  • java构造方法是用来初始化一个对象,并为为实例变量赋予合适初始值。因此构造方法不需要返回类型。 构造方法必须满足以下语法规则:  (1)方法名必须与类名相同;  (2)不要声明返回类型;  (3)不能被...
  • 关于继承,有好些要注意的地方。 一般资料介绍:当子类继承父类时,子类会获得父类中定义的成员变量和方法,当访问权允许的情况下,子类可以直接访问父类中定义的成员变量和方法。   可是,Java继承中对成员变量...
  • 3、如果不能确定该类以后是否不再继承于某类,那就使用接口进行扩展,因为在Java中,只允许单继承。   4、类设计应该确保父类包含它子类共同特征。   5、如果可以使用接口,就不要使用父类。应该尽量...
  • Java的继承概论

    2011-07-17 12:31:52
    Java继承代表的是一个新的类(子类)可以使用当前类(父类)里面的部分方法和属性,而在这里面又有一些需要我们注意的地方: 1.子类和父类在同意包下的时候,可继承的方法属性为public and protected 2.而他们...
  • 访问修饰符作用域:private:可以定义方法或者属性,定义方法和属性不能被外部类所访问(包括子类)。...Java继承&访问修饰符结合使用引发大混乱1.子类重载方法权限是否允许小于父类定义?其中,p...
  • 使用JAXB 将java继承的类序列化xml

    千次阅读 2014-12-28 17:00:32
    JAXB是将java实体类序列化和反序列化处理中比较方便的一个工具,在jaxb的使用中,若是实体类中存在继承的层次关系,那么就需要一些值得注意的地方了。 比如在开发百度轻应用时候就需要处理到: Xml代码 ...
  • 一、继承 1.Java中的继承是一种机制,表示的是一个类继承父类的所有属性与方法。 2.面向对象的编程允许从已经...关于继承应该注意的地方: 子类并不是父类的一个子集,一个子类通常比它的父类包含更多的信息。 父...
  • java继承时,需要遵循里氏替换原则(Liskov Substitution Principle,LSP) 定义 如果对每一个类型为S对象o1,都有类型为T对象o2,使得以T定义所有程序P在所有对象o1都代换成o2时,程序P行为没有发生变 化...
  • JAVA中内部类的继承和覆盖问题

    千次阅读 2017-07-26 10:31:14
    JAVA的内部类继承与覆盖问题还是有一些细节方面需要注意的地方
  • 不同类型泛型类是等价(Pair与Pair是属于同一个类型Pair), 这一点要特别注意,即如果a instanceof Pair==true话,并不代表a.getFirst()返回值是一个String类型3、泛型类不可以继承Exception类,...
  • Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。 可以理解为,接口就是多个类的...
  • 这里需要注意的是参数不同需要满足 2 个条件:一个是参数的个数不同;一个是参数个数相同,但参数列表中对应的某个参数的类型不同。最常用的地方就是构造器的重载。 重载的要求如下: 方法名相同; 方法的参数...
  • C++转JAVA需要注意的几点

    千次阅读 2010-05-11 17:45:00
    篇文章是最近刚看到的,虽然是说程序员从C++转JAVA需要注意的地方,但是很详细的说出了C++和JAVA的不同的地方,对于JAVA中为什么没有指针、为什么没有内存泄露、接口和C++中多重继承的关系、异常机制等问题也描述的...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 293
精华内容 117
关键字:

java继承注意的地方

java 订阅