对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继承的弊端：

提高了耦合性，一定程度上打破了封装！

Java 面向对象编程中的继承

2015-07-21
Java