继承(extends)
 
1. 父类与子类
 
 
父类也叫基类、超类
 
 
子类也叫派生类
 
 
在继承的而关系中，“子类就是一个父类“。也就是说，子类可以被当做父类来看待。例如父类是员工，子类是老师，那么我们可以说**”老师就是一个员工“**。
 
 
2. 继承的格式
 
2.1 定义父类的格式：(一个普通的类定义)
 
public class 父类名称{
    //.....
}
 
2.2 定义子类的格式
 
public class 子类名称 extends 父类名称{
    //.....
}
 
2.3 代码演示（老师类继承员工类）
 
2.3.1 Employee类
 
public class Employee(){
    public void method(){
        System.out.println("方法执行")
    }
}
 
2.3.2 Teacher类，继承自Employee类
 
public class Teacher extends Employee{
	//我们先不在里面添加任何东西
}

 
2.3.3 在main中，创建一个Teacher类的对象
 
public class Main {

    public static void main(String[] args) {
	    Teacher one = new Teacher();
        //Teacher类继承了Empolyee类的方法
	    one.method();
    }
}
/*输出结果：
    执行方法
 */
 
2.3.4 小结论
 
Teacher类继承了Employee类，也就继承了它的 public void method() 方法，达到了代码复用的效果，当父类有我们子类需要用的方法时，我们就不用再去重新打一次，直接可以拿来用。
 
3. 继承中成员变量的访问特点
 
3.1 成员变量之间的访问 (变量不重名的情况)
 
3.1.1 先创立一个父类Fu
 
public class Fu {
    public int numFu = 10;  //关键字为public，可以直接通过（对象.变量名）访问，方便说明问题
}
 
3.1.2 再创立一个子类Zi
 
public class Zi extends Fu{
    public int numZi = 20;
}
 
3.1.3 在main中分别建立父类和子类的对象
 
public class Demo02ExtendsField {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        //父类只能找到自己的成员numFu，并没有找到子类的成员numZi
        System.out.println(fu.numFu);

        //创立一个子类对象
        Zi zi = new Zi();
        //子类对象既可以打印父类的成员numFu，也可以打印自己的成员numZi
        //还是那句"先人不知道后人的事情，而后人知道先人的事情"
        System.out.println(zi.numFu);
        System.out.println(zi.numZi);
    }
}
 
3.2 成员变量之间的访问 (变量重名的情况)
 
有两种情况：
 
 
直接通过对象访问成员变量：
 
等号左边是谁，就优先用谁，没有则向上找
 
 
间接通过成员方法访问成员变量
 
该方法属于谁，就优先用谁，没有则向上找
 
 
 
假设现在父类 Fu 和子类 Zi 都有一个变量名叫num
 
 
Fu 类
 
public class Fu {
    public int num = 10;

    public void methodFu(){
        //这里打印的num，一定是本类的，不会再往下找子类的
        System.out.println(num);
    }
}
 
 
Zi类
 
public class Zi extends Fu{
    public int num = 20;

    public void methodZi(){
        //这里打印的num，如果本类有，就优先打印本类的，如果没有再往上找
        System.out.println(num);
    }
}
 
 
第一种情况：直接通过对象访问成员变量
 
等号左边是谁，就优先用谁，没有则向上找。Fu fu = new Zi();等号的左边是父类
 
public class Demo02ExtendsField {
    public static void main(String[] args) {
     // Zi zi = new Fu(); 不能通过父类来构造子类，先人（父类）根本不知道后人（子类）长什么样子
        Fu fu = new Zi(); //可以通过子类来构造父类，这时等号左边是父类
        System.out.println(fu.num);  //10，打印的是父类的num
    }
}
 
第二种情况：间接通过成员方法访问成员变量
 
public class Demo02ExtendsField {
    public static void main(String[] args) {

        Fu fu = new Fu();
        Zi zi = new Zi();

        //打印的是父类的num，因为该类没有继承其它类，他自己肯定有一个num，才能写出这个方法
        fu.methodFu();  //父类的num 10，补充：没有fu.methodZi(), 先人不知道后人的方法

        //如果子类有一个num，那就优先打印本类的，没有的话再往父类那里找
        zi.methodZi();  //子类的num 20

        //重点！子类用的是父类的方法打印num，这就要看这个方法属于谁，是谁定义的这个方法
        //因为methodFu()这个方法是属于父类的，打印的当然就是父类的num
        zi.methodFu();  //父类的num 10
    }
}
 
4. 区分子类方法中的重名
 
假如有好多个num，父类有一个，子类有两个，怎么才能正确地打印想要的那个num呢？
 
 
4.1 父类
 
public class Fu {
    public int num = 10;
}
 
 
4.2 子类
 
public class Zi extends Fu {
    public int num = 20;

    public void methodZi(){
        int num = 30;
        System.out.println(num);      //30, 局部变量
        System.out.println(this.num); //20, 本类的成员变量
        System.out.println(super.num);//10, 父类的成员变量
    }
}
 
 
4.3 看看子类方法 methodZi() 能不能正确区分三个num
 
public class Demo03Main {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi();  //30, 20, 10
    }
}
 
 
4.4 总结：要想正确地打印想要的num，可以这样打
 
  
局部变量，上面的那个num = 30，就可以直接写
本类的成员变量，上面的num = 20, 用this.成员变量名
父类的成员变量，上面的num = 10, 用super.成员变量名
 
 
5. 继承中成员方法重名的问题
 
假如子类和父类都有一个方法叫 method() , 那怎么知道用的是哪一个呢？
 
 
5.1 父类
 
public class Fu {
    public void method(){
        System.out.println("父类重名方法执行");
    }
}
 
 
5.2 子类
 
public class Zi extends Fu {
    public void method(){
        System.out.println("子类重名方法执行");
    }
}
 
 
5.3 在main中调用 method() 方法
 
public class Demo04Main {
    public static void main(String[] args) {
        Fu fu1 = new Fu();
        Fu fu2 = new Zi(); //通过子类来构造fu2
        Zi zi = new Zi();

        fu1.method(); //父类重名方法执行, 用的是父类方法
        fu2.method(); //子类重名方法执行，用的是子类方法
        zi.method();  //子类重名方法执行， 用的是子类方法
    }
}
 
 
结论 :
 
 
创建的对象是谁，用谁的类来构造对象的，就优先用谁，如果没有就向上找。比如Fu fu2 = new Zi();，fu2是用子类来构造的，那fu2.method()就是用的子类的方法
注意！无论是成员变量还是成员方法，如果没有都是向上找父类，绝对不会向下找子类的。
 
6. 继承方法中的覆盖重写
 
由 5. 继承中成员方法重名的问题，我们可以引出重写（Override）的概念
 
 
 
重写：在继承关系中，方法的名称一样，参数列表也一样
 
 
 
6.1 重写 (Override) 和 重载 (Overload) 的区别
 
重写：方法的名称一样，参数列表【也一样】。也叫覆盖、覆写
 
重载：方法的名称一样，参数列表【不一样】。
 
 
6.2 覆盖重写的注意事项 (了解)
 
  
 
6.2.1 必须保证父子类之间方法的名称相同，参数列表也相同，否则无法进行覆盖重写
 
 
6.2.2 注解：@Override，这个注解写在方法的前面，用来检验是不是有效的覆盖重写，例如当方法名写错了，@Override底下就会出现红色的波浪线，提示你这不是有效的覆盖重写。
 
public class Zi extends Fu {
    @Override
    public void method(){
        System.out.println("子类重名方法执行");
    }
}
 
这个注解可写可不写，但是强烈推荐把它写上去。
 
 
6.2.3 子类方法的返回值必须【小于等于】父类方法的返回值范围。java.lang.Object是所有类的公共最高父类（祖宗类），每个类都默认继承了它，例如String类就是Object的子类。下面代码会报错，是因为返回值的范围问题
 
    
 
6.2.3.1 父类
 
public class Fu {
    public String method(){
        System.out.println("父类重名方法执行");
    }
}
 
 
6.2.3.2 子类
 
public class Zi extends Fu {
    @Override
    public Object method(){  //范围：Object > String 报错
        System.out.println("子类重名方法执行");
    }
}
 
 
 
6.2.4 子类方法的权限必须【大于等于】父类方法的权限修饰符。权限的排名：public > protected > (default) > private。备注：（default）不是关键字default，而是什么都不写，留空，例如：
 
public class Fu{
    int num; //num的访问权限是default
}
 
下面的代码会因为重写方法的权限问题而报错：
 
    
 
6.2.4.1 父类
 
public class Fu {
    public void method(){
        System.out.println("父类重名方法执行");
    }
}
 
 
6.2.4.2 子类
 
public class Zi extends Fu {
    @Override
    protected void method(){  //protected < public 报错
        System.out.println("子类重名方法执行");
    }
}

 
 
 
 
6.3 覆盖重写实战演练
 
假如旧手机的功能有打电话、发短信、来电显示（显示号码）
 
新手机的功能有来电显示、发短信、来电显示（显示号码、显示头像、显示姓名）
 
可见新旧手机的打电话和发短信功能是一样的，但是新手机的来电显示功能比旧手机多了显示头像、显示姓名。
 
我们可以把旧手机当做父类，把新手机当做子类，新手机只需要重写旧手机的来电显示功能即可
 
  
 
6.3.1 旧手机是父类，名为Oldphone类
 
public class Oldphone {  
    //打电话功能
    public void call(){
        System.out.println("打电话");
    }
    //发短信功能
    public void send(){
        System.out.println("发短信");
    }
    //来电显示功能
    public void show(){
        System.out.println("显示号码");
    }
}
 
 
6.3.2 新手机是子类，名为Newphone类
 
public class Newphone extends Oldphone{

    @Override
    public void show() {
        super.show();  //不要修改原来的代码，直接通过super调用它，后面再添加新的内容
        System.out.println("显示头像");
        System.out.println("显示姓名");
    }
}
 
 
6.3.3 在main中实验一下
 
public class Demo05Main {
    public static void main(String[] args) {
        Newphone newphone = new Newphone();
        newphone.call();
        newphone.send();
        newphone.show();
    }
}
/*输出结果：
    打电话
    发短信
    显示号码
    显示头像
    显示姓名
 */
 
 
 
7. 继承中构造方法的访问特点
 
7.1 概述
 
子类的构造方法启动时，一定会先跑去启动父类的构造方法，等父类的构造方法执行完后，再去执行子类（本类）的构造方法。
 
7.2 代码说明一下7.1
 
 
7.2.1 父类（只有无参构造方法）
 
public class Fu {
    //父类的无参构造方法
    public Fu(){
        System.out.println("父类构造方法执行");
    }
}

 
 
7.2.2 子类
 
public class Zi extends Fu {
    //子类的无参构造方法
    public Zi(){
        System.out.println("子类构造方法执行");
    }
}

 
 
7.2.3 在main中构造一个子类
 
public class Demo06Main {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}

/*输出结果：
    父类构造方法执行
    子类构造方法执行
 */
 
 
7.2.4 小总结
 
其实子类的构造方法中隐含了super()调用，如果子类的构造方法没有写super()，编译器会帮我们默认加上去。子类就变成
 
public class Zi extends Fu {
    //子类的无参构造方法
    public Zi(){
        super();  //注意！这句必须写在第一行的位置，如果父类构造函数有参数，就是super(参数)，有                   参数的调用，必须要自己写上去，不然会默认调用无参构造
        System.out.println("子类构造方法执行");
    }
}
 
 
8. super关键字的三种用法总结
 
8.1 用法1
 
在子类的成员方法中，访问父类的成员变量，比如：
 
 
8.1.1 父类
 
public class Fu {
    public int num = 10;
}
 
 
8.1.2 子类
 
public class Zi extends Fu {
    public int num = 20;

    public void methodZi(){
       // System.out.println(num);  这样打印的一定是本类的num
        System.out.println(super.num); //打印的是父类的num
    }
}
 
 
8.2 用法2
 
在子类的成员方法中，访问父类的成员方法，比如：
 
 
8.2.1 父类
 
public class Fu {
    public void methodFu(){
        System.out.println("父类的成员方法执行");
    }
}

 
 
8.2.2 子类
 
public class Zi extends Fu{
    public void methodZi(){
        super.methodFu(); //访问父类的methodFu()方法
        System.out.println("子类的成员方法执行");
    }
}
 
 
在main中执行子类的方法
 
public class Demo07Main {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi();
    }
}
/*输出结果：
    父类的成员方法执行
    子类的成员方法执行
 */
 
 
8.3 用法3
 
在子类的构造方法中，访问父类的构造方法。就在 7. 继承中构造方法的访问特点 中，请自行查阅。
 
9. this关键字的三种用法
 
9.1 概述
 
 
 
9.1.1 在本类的成员方法中，访问本类的成员变量
 
 
9.1.2 在本类的成员方法中，访问本类的另一个成员方法
 
 
9.1.3 在本类的构造方法中，访问本类的另一个构造方法
 
 
9.2 代码说明一下
 
public class Zi extends Fu {
    private int num = 10;

    public Zi(){
        this(123);  //9.1.3 在本类的无参构造中调用有参构造
    }

    public Zi(int num){
        this.num = num;
    }

    public void methodZi(){
        System.out.println(this.num); //9.1.1 在本类的成员方法中，访问本类的成员变量
    }

    public void methodA(){
        System.out.println("A方法");
    }

    public void methodB(){
        this.methodA();  //9.1.2 在本类的成员方法中，访问本类的另一个成员方法
        System.out.println("B方法"); 

 
9.3 注意事项
 
在构造方法中调用this，那这个this调用必须是该函数中的第一个语句，也是唯一的一个
super和this两种在构造调用中，不能同时使用。两个都要排在第一行，我哪知道该怎么排。
 
10. java继承的三个特点
 
10.1 java语言是单继承的
 
一个类的直接父类只能有唯一的一个。
 
class A{}
class B extends A{}  正确写法
class C{}
class D extends A,C{} 错误写法，不能同时继承A和C
 
试想假如class A{}有一个 method() 方法，
 
Class C{}也有一个 method() 方法，
 
子类D同时继承类A和类C，那当我新建一个D类对象d后，
 
对象d想要调用父类的method方法，那它应该用A的 method() 还是C的 method() 呢？这就乱套了！
 
 
10.2 java语言是可以多级继承的
 
虽然，java语言是单继承的，一个类的直接父类只有一个，类D不能同时继承类A和类C
 
但是，可以让类A继承类C之后，类D再继承类A，C就是爷爷，A就是爸爸，D就是儿子
 
类D --> 类A --> 类C，这就叫多级继承。
 
 
10.3 java语言中，一个父类可以有多个子类
 
这就好比二胎政策，一个爸爸可以有多个儿子
 

 JAVA中extends与implements有啥区别？
 1. 在类的声明中，通过关键字extends来创建一个类的子类。一个类通过关键字implements声明自己使用一个或者多个接口。
 extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
 2.extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口 来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了
 比如
 class A extends B implements C,D,E
 
 ===========================================================
 implements
 学了好久,今天终于明白了implements,其实很简单,看下面几个例子就ok啦~~
 接口的一些概念
 public inerface Runner
 {
   int ID = 1;
   void run ();
 }
 
 
 interface Animal extends Runner
 {
   void breathe ();
 }
 
 class Fish implements Animal
 {
   public void run ()
 {
    System.out.println("fish is swimming");
 }
 
 public void breather()
 {
    System.out.println("fish is bubbing");   
 }
 }
 
 abstract LandAnimal implements Animal
 {
  
   public void breather ()
 {
    System.out.println("LandAnimal is breathing");
 }
 }
 
 class Student extends Person implements Runner
 {
    ......
    public void run ()
     {
          System.out.println("the student is running");
     }
    ......
 }
 
  
 
 interface Flyer
 {
   void fly ();
 }
 
 class Bird implements Runner , Flyer
 {
   public void run ()
    {
        System.out.println("the bird is running");
    }
   public void fly ()
    {
        System.out.println("the bird is flying");
    }
 }
 
 
 
 class TestFish
 {
   public static void main (String args[])
    {
       Fish f = new Fish();
       int j = 0;
       j = Runner.ID;
       j = f.ID;
    }
 
 }
 接口实现的注意点：
 
 a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。
 b.接口中的方法都是抽象的。
 c.多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。
 ===========================================================
 extends与implements的不同
 
  extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重 继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了
 比如
 class A extends B implements C,D,E
 
 //
    一个类通过关键字implements声明自己使用一个或者多个接口。在类的声明中，通过关键字extends来创建一个类的子类。
 class 子类名 extends 父类名 implenments 接口名
 {...
 
 }
 
 ===========================================================
 
 A a = new B();结果a是一个A类的实例，只能访问A中的方法，那么又和A a = new A();有什么区别呢？
 ==========================================================
 class B extends A
 继承过后通常会定义一些父类没有的成员或者方法。
 A a = new B();
 这样是可以的，上传。
 a是一个父类对象的实例，因而不能访问子类定义的新成员或方法。
 ==========================================================
 假如这样定义：
 class A{
 int i;
 void f(){}
 }
 class B extends A{
 int j;
 void f(){}//重写
 void g(){}
 }
 然后：
 B b = new B();
 b就是子类对象的实例，不仅能够访问自己的属性和方法，也能够访问父类的属性和方法。诸如b.i,b.j,b.f(),b.g()都是合法的。此时 b.f()是访问的B中的f()
 A a = new B();
 a虽然是用的B的构造函数，但经过upcast，成为父类对象的实例，不能访问子类的属性和方法。a.i,a.f()是合法的，而a.j,a.g()非 法。此时访问a.f()是访问B中的f()
 ==========================================================
 A a = new B(); 这条语句，实际上有三个过程：
 (1) A a;
 将a声明为父类对象，只是一个引用，未分配空间
 (2) B temp = new B();
 通过B类的构造函数建立了一个B类对象的实例，也就是初始化
 (3) a = (A)temp;
 将子类对象temp转换未父类对象并赋给a，这就是上传(upcast)，是安全的。
 经过以上3个过程，a就彻底成为了一个A类的实例。
 子类往往比父类有更多的属性和方法，上传只是舍弃，是安全的；而下传(downcast)有时会增加，通常是不安全的。
 ===========================================================
 a.f()对应的应该是B类的方法f()
 调用构造函数建立实例过后，对应方法的入口已经确定了。
 如此以来，a虽被上传为A类，但其中重写的方法f()仍然是B的方法f()。也就是说，每个对象知道自己应该调用哪个方法。
 A a1 = new B();
 A a2 = new C();
 a1,a2两个虽然都是A类对象，但各自的f()不同。这正是1楼说的多态性的体现。
 
 这类问题在《Java编程思想》上都讲的很清楚
 
  
 
  
 
  
 
implements一般是实现接口。
 
extends 是继承类。
 
 
 
接口一般是只有方法声明没有定义的，
 
那么java特别指出实现接口是有道理的，因为继承就有感觉是父类已经实现了方法，而接口恰恰是没有实现自己的方法，仅仅有声明，也就是一个方法头没有方法体。因此你可以理解成接口是子类实现其方法声明而不是继承其方法。
 
但是一般类的方法可以有方法体，那么叫继承比较合理。
 
引入包可以使用里面非接口的一切实现的类。那么是不是实现接口，这个你自己决定，如果想用到那么你不是实现，是不能调用这个接口的，因为接口就是个规范，是个没方法体的方法声明集合。我来举个例子吧：接口可以比作协议，比如我说一个协议是“杀人”那么这个接口你可以用砍刀去实现，至于怎么杀砍刀可以去实现，当然你也可以用抢来实现杀人接口，但是你不能用杀人接口去杀人，因为杀人接口只不过是个功能说明，是个协议，具体怎么干，还要看他的实现类。
 
那么一个包里面如果有接口，你可以不实现。这个不影响你使用其他类。
 
  
 
  
 
 implements
 
 　　implements是一个类实现一个接口用的关键字，他是用来实现接口中定义的抽象方法。比如：people是一个接口，他里面有say这个方法。public interface people(){ public say();}但是接口没有方法体。只能通过一个具体的类去实现其中的方法体。比如chinese这个类，就实现了people这个接口。 public class chinese implements people{ public say() {System.out.println("你好！");}}
 
 　　在java中implements表示子类继承父类，如类A继承类B写成 class A implements B{}
 
 与Extends的不同
 
 　　extends， 可以实现父类，也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。这样的好处是：架构师定义好接口，让工程师实现就可以了。整个项目开发效率和开发成本大大降低。
 
 　　implements，实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数，也会被父类取代掉。
 
 　　这两种实现的具体使用，是要看项目的实际情况，需要实现，不可以修改implements，只定义接口需要具体实现，或者可以被修改扩展性好，用extends。

最近看Java线程池相关的源码发现居然存在这样的代码：
 
public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}
 
难道Java可以多继承？？？ 瞬间凌乱了…
 后来实验发现，Java居然可以通过以下方式实现多继承：
 
interface A {
	public void aa();
}
interface B {
	public void bb();
}
interface C extends A, B {
	public void cc();
}
class D implements C {
	@Override
	public void aa() {
	}
	@Override
	public void bb() {
	}
	@Override
	public void cc() {
	}
}
 
这个有什么用呢？？？
 俺暂时还没有研究，弄明白后补上…

JAVA中extends 与implements有啥区别？

 
1. 在类的声明中，通过关键字extends来创建一个类的子类。一个类通过关键字implements声明自己使用一个或者多个接口。

 
extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用

 
2.extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了

 
比如

 
class A extends B implements C,D,E