Java学习之面向对象---继承

继承：子继承父，子可以拥有父的所有。

继承的好处：
　　1.提高了代码的复用性
　　2.让类与类之间产生了关系。有了这个关系，才有了多态的特性

Java 只支持单继承，不支持多继承

class A
{
    void show()
    {
        System.out.println("a");
    }
}
class B
{
    void show()
    {
        System.out.println("b");
    }
}

class C extends A,B
{

}
new C().show();不确定show方法

Java 支持多层继承

因为有继承关系，所以子类就包含父类中的成员

类中成员：
1.变量：子父类中有同名的成员变量（不会这样设计类）
　　this:代表当前类对象的引用，super：代表当前类的父类对象的引用

2.函数：有重写特性
　　如果子类中也有和父类相同的成员函数，会重写
　　如果子类没有父类的成员函数，那子类就直接继承。
　　重写：子父类的成员函数要完全一样

3.构造函数
　　子类实例化时，会默认在子类构造函数第一行隐式追加super();
　　所以子类只要实例化时，都会访问父类的无参构造函数（super()）
　　如果想访问指定的父类构造函数可以在子类构造函数第一行中指定父类的构造函数（super("XXXX")）

 class ExtendsDemo
 {
     public static void main(String[] args)
     {
         Student s=new Student();
         //1.子类可以直接使用父类变量
         s.name="zhangsan";
         s.sleep();

         Student s2=new Student("Student_Name");

         Student s3=new Student("Student_Name",20);
     }
 }

 class Person
 {
     //3.
     Person()
     {
         System.out.println("Person Run");
     }

     Person(String name)
     {
         System.out.println("Person Run====="+name);
     }

     int num=4;
     String name;
     int age;
     //2.
     void sleep()
     {
         System.out.println("Person sleep");
     }
 }

 class Student extends Person
 {
     //3.
     Student()
     {
         //隐式语句super();
         System.out.println("Student Run");
     }

     Student(String name)
     {
         //隐式语句super();
         System.out.println("Student Run----"+name);
     }

     Student(String name,int age)
     {
         //指定父类的构造函数
         super(name);
         System.out.println("Student Run----"+name+"==="+age);
     }

     int num =5;
     void study()
     {
         System.out.println("good study");
     }

     //2.重写父类方法
     void sleep()
     {
         //保留父类功能，使用super
         super.sleep();
         System.out.println("Student sleep");
     }
 }

 class worker extends Person
 {
     void work()
     {
         System.out.println("good work");
     }
 }

结果：

知识点：final关键字

final：最终。是一个修饰符

1、可以修饰类，函数，变量

2、修饰类，此类不能被继承，此类不能有子类

final class XXX{     ..........     }

3、修饰函数，函数不能被重写

final void show(){  ....  }

4、修饰变量，变量就是一个常量（字母全部大写，单词之间下划线分割），变量只能赋值一次

 class Demo
 {
     void show()
     {
         final int y=4;
         //y++;//出错：不可以再赋值
         System.out.println(y);
     }

     //final int num的作用范围再方法体内，就说明num变量再方法体中是不可改变的。
     void show1(final int num)
     {
         //num++；//这个是错误的
         System.out.println(num);
     }
 }

 class FinalDemo
 {
     public static void main(String[] args)
     {
         Demo d=new Demo();
         d.show1(1);//这都是正确的
         d.show1(2);
     }
 }

结果：