Java 面向对象编程中的继承

文章类别 in java

##对java的疑问:

  • 为什么要用到java继承呢?
  • java继承需要注意什么?
  • java继承有什么好处呢?
  • 有没有什么弊端呢?

继承

继承,就像大象和小象有一些共同的属性,一只大象生了一只小象,而小象拥有了大象的功能属性,然后小象还可以自己学习很多东西,扩展了自己的功能和属性!

代码提现继承

//父类
    public class Elephant_Father {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}


//子类

public class Elephant_Son extends Elephant_Father {

    public void LOL()
    {
        System.out.println("hahahhahahah");
    }   
}


//实现类:
public class MainDemo {

    public static void main(String[] args) {

            Elephant_Son son = new Elephant_Son();
            son.setAge(15);
            son.setName("little elephant");
            System.out.println("son.name:" 
            + son.getName()+ " ,son.age:" + son.getAge());
            son.LOL();  
    }

}

控制台显示结果:

son.name:little elephant ,son.age:15
hahahhahahah

从代码中可以看出:当Elephant_Son extends Elephant_Father的时候,son自己本身并没有setName()、getName()等功能,可是它继承了它的爸爸后就可以用它爸爸身上的东西了。

**由此可见继承简化了代码,son在继承了father的基本功能后,在自己的类中还可以实现自己扩展出来的东西,这也简单的回答了第一个问题(java为什么要用继承!) **


可是,当father拥有了一个吃的方法,而son也有吃的方法,可是他们像吃的东西不同,比如father想吃饭,而son想吃方便面!那么当son继承了father后怎么办呢?难道也要跟着吃饭吗?no!!

代码体现:

//父类
public class Elephant_Father {

     public void eat()
     {
         System.out.println("father:我要吃饭!!!");
     }

}

//子类
public class Elephant_Son extends Elephant_Father {
	//TODO	
}

public class MainDemo {

//实现类
public static void main(String[] args) {

        Elephant_Son son = new Elephant_Son();
        son.eat();

        Elephant_Father father = new Elephant_Father();
        father.eat();
}

}

输出结果:

 father:我要吃饭!!!
 father:我要吃饭!!!

son继承了father后,son.eat()是吃饭啊,可是想吃方便面啊!!怎么办? 这时候son想了个方法,把继承父亲吃的这个方法给重写掉!多么聪明的son呀,说来就来:

 //父类
 public class Elephant_Father {

     public void eat()
     {
         System.out.println("father:我要吃饭!!!");
     }

}

//子类
public class Elephant_Son extends Elephant_Father {
        @Override
        public void eat() {
            System.out.println("son:爸爸要吃饭我又不吃,我改了,我要吃方便面!");
        }

}

//实现类
public class MainDemo {

    public static void main(String[] args) {


            Elephant_Son son = new Elephant_Son();
            son.eat();

            Elephant_Father father = new Elephant_Father();
            father.eat();
    }

}

输出结果:

son:爸爸要吃饭我又不吃,我改了,我要吃方便面!
father:我要吃饭!!!

**由此可见,在继承中有一个东西叫做重写(覆盖),爸爸有的东西不一定是我要的,那么我就改掉!!! **


父亲呢!有时候有些东西是不想给孩子看到(你懂的),有些父亲甚至不想有孩子,想“断子绝孙”,这个时候父亲就想到了把一些东西占为己有,私有(private)掉, 而想“断子绝孙”的父亲就把自己成为最终态(final)!

java的修饰符private

比如,father有一个思考事情的方法,但是他不想让继承他的son知道!就用private私有:

class Elephant_Father {

      private void think()
      {
          System.out.println("father:我一直在思考,让你了解我的好");
      }
}

这个时候,son是继承不到father的think方法的!

java的修饰符final

再比如想要断子绝孙的父亲:

final class Elephant_Father {

}

这个时候,它就没有son了,也就是说,son继承不了他,因为他final了!

java的修饰符static

又:当父亲有static来修饰方法的时候,子类是不能重写的!比如:

//父类
class Elephant_Father {

     //static修饰
     public static void eat()
     {
         System.out.println("吃饭");
     }
}

//子类
public class Elephant_Son extends Elephant_Father {

 public static void eat()
 {
     System.out.println("吃面");
 }
}

//实现类
public class MainDemo {

    public static void main(String[] args) {


            Elephant_Son son = new Elephant_Son();

            son.eat();

            Elephant_Father father = new Elephant_Father();
            father.eat();

    }

}

输出:

 吃面
 吃饭

咋一看好像真的重写了呢!! 可是有没有看到子类的eat方法上面没有@Override字样儿! 其实并不是重写而是子类自己写的一个静态方法,static修饰的方法和一般的方法不同,它是静态绑定的,所属类的!所以是不会有重写的!

所以可以对以上的描述拿来简单回答第二个问题(继承需要注意什么)。

但还有一个细节就是java是不能多继承的,

什么意思? 就是son extends father,mother,…,这样是不行的,

但是java可以传递性的继承,什么意思呢? 就是 son extends father, grandson extends son ….;


最后浅谈一下:

java继承的好处:

除了刚才讲过的简化了代码,提高了代码的复用性,而且还提高了代码的维护性; 再者,使得类与类之间产生了关系,产生了关系的作用在前面的例子可 以看到,还有它的另一作用是多态的前提!

java继承的弊端:

提高了耦合性,一定程度上打破了封装!

我的相关文章

相关资料