继承(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语言中，一个父类可以有多个子类
 
这就好比二胎政策，一个爸爸可以有多个儿子
 

1 继承
 
1.1概念
 
继承是面向对象最显著的一个特征
 继承是从已有的类中派生出新的类,新类能吸收已有类的数据属性和行为,并扩展新的能力.
 Java继承是会用已存在的类的定义作为基础建立新类的技术
 新类的定义可以增加新的数据或者新的功能,也可以使用父类的功能,但不能选择性的继承父类(超类/基类)
 这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用.
 
1.2 特点
 
使用extends关键字来表示继承关系
相当于子类把父类的功能复制了一份
Java只支持单继承
继承可以传递(爷爷/儿子/孙子这样的关系)
父类的私有成员也会被继承，但由于私有限制访问，所以子类不能使用父类的私有资源
继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展
像是is a的关系
 
1.3 练习：继承入门案例
 
创建包: cn.tedu.oop2
 创建类: TestExtends.java
 
package cn.tedu.oop2;
/*本类用于继承的入门案例*/
public class TestExtends {
    public static void main(String[] args) {
        //5.分别创建3个类的对象
        Animal a = new Animal();
        Cat c = new Cat();
        MiaoMiao m = new MiaoMiao();
        //6.利用对象调用方法进行测试
        /*3.继承相当于是子类将父类的功能复制了一份
        继承还具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子*/
        a.eat();//爷爷类使用自己的方法
        c.eat();//爸爸类可以使用从爷爷类中继承过来的方法
        m.eat();//孙子类也可以使用从爷爷类中继承过来的方法
    }
}
/*1.我们通过extends关键字建立子类与父类的继承关系，格式：子类 extends 父类*/
/*2.Java只支持单继承，一个子类只能有一个父类，但是一个父类可以有多个子类*/
//1.创建小动物类--爷爷类
class Animal{
    //4.添加爷爷类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }
}
//2.创建小猫类--爸爸类
/*6.继承是is a的关系，比如小猫是小动物，MiaoMiao是一只小猫
* 继承要求子类必须是父类的一种下属类型，依赖性非常强，强耦合*/
class Cat extends Animal{
    //7.定义爸爸类中的属性
    int a = 10;//普通属性
    private int b = 100;//私有属性
}
//3.创建MiaoMiao类--孙子类
class MiaoMiao extends Cat{
    /*4.子类可以拥有自己独有的方法，实现了功能的拓展，青出于蓝而胜于蓝*/
    //8.定义孙子类的方法
    public void studyJava(){
        System.out.println("正在学Java");
        System.out.println(a);
        /*5.子类继承了父类以后，可以使用父类的所有非私有资源
        * 注意：这个私有资源由于被private修饰，所以没有访问权限*/
        //System.out.println(b);//不可以，私有资源被限制访问
    }
}
 
2 super
 
我们可以把super看作是父类的对象：Father super = new Father();
 1.当父类的成员变量与子类的变量同名时，使用super指定父类的成员变量
 2.使用super在子类构造方法的第一行调用父类构造方法的功能
 super();–调用的是父类的无参构造
 super(参数);–调用的是父类对应参数的构造方法
 注意:在构造方法里,出现的调用位置必须是第一行
 
3 继承的用法
 
3.1 练习：super之继承中成员变量使用
 
创建包: cn.tedu.oopextends
 创建类: TestExtends1.java
 
package cn.tedu.oop2;
/*本类用于测试继承中变量的使用*/
public class ExtendsDemo1 {
    public static void main(String[] args) {
        //7.创建子类的匿名对象，调用study()
        new Son().study();
    }
}
//1.创建父类
class Father{
    //3.创建父类的成员变量
    int sum = 1;
    int count = 2;

}
//2.创建子类
class Son extends Father{
    //4.创建子类的成员变量
    int sum = 10;
    //5.创建子类的普通方法
    public void study(){
        System.out.println("goog good study , day day up");
        //6.创建子类的局部变量
        int sum = 100;
        //8.打印子类的局部变量sum
        System.out.println(sum);//100
        //9.打印子类的成员变量sum
        System.out.println(this.sum);//10
        //10.打印父类的成员变量sum
        /*当父类的成员变量与子类的成员变量同名时，可以使用super指定父类的成员变量
        * 我们可以把super看作是父类的对象：Father super = new Father();*/
        System.out.println(super.sum);//1
        System.out.println(count);
    }
}
 
3.2 练习：super之继承中构造方法的使用
 
创建包: cn.tedu.oop2
 创建类: ExtendsDemo2.java
 
package cn.tedu.oop2;
/*本类用于测试继承中构造方法的使用
* 1.子类在创建对象时，默认会先调用父类的构造方法
* 2.原因是子类构造函数中的第一行默认存在super();--表示调用父类的无参构造
* 3.当父类没有无参构造时，可以通过super(参数)调用父类的其他含参构造
* 子类必须调用一个父类的构造函数，不管是无参还是含参，选一个即可
* 4.构造方法不可以被继承！因为语法的原因：要求构造方法的名字必须是本类类名
* 不能在子类中出现一个父类名字的构造方法*/
public class ExtendsDemo2 {
    public static void main(String[] args) {
        //6.1通过父类的无参构造创建父类对象
        //Father2 f = new Father2();
        //6.2通过父类的含参构造创建父类对象
        //Father2 f2 = new Father2("哈哈哈");
        //7.创建子类对象
        Son2 s = new Son2();
    }
}
//1.创建父类
class Father2{
    //3.创建父类的无参构造
//    public Father2(){
//        System.out.println("我是父类的无参构造");
//    }
    //4.创建父类的含参构造
    public Father2(String s){
        System.out.println("我是父类的含参构造"+s);
    }
}
//2.创建子类
class Son2 extends Father2{
    //5.创建子类的无参构造
    public Son2(){
        //super();//调用父类的无参构造
        super("你好~");
        System.out.println("我是子类的无参构造");
    }
}

 
4 方法重写Override
 
继承以后,子类就拥有了父类的功能
在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
注意: 父类的私有方法不能被重写
重写的要求:两同两小一大
 两同:方法名 参数列表 要完全一致
 两小:
 子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
 子类抛出异常小于等于父类方法抛出异常
 一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限
 
4.1 练习：继承中成员方法的使用
 
创建包: cn.tedu.oop2
 创建类: ExtendsDemo3.java
 
package cn.tedu.oop2;
/*本类用于测试继承中方法的使用*/
public class ExtendsDemo3 {
    public static void main(String[] args) {
        //4.创建对象进行测试
        Father f = new Father();
        Son s = new Son();
        f.eat();
        s.eat();
        f.play();
        s.play();
    }
}
//1.创建父类
class Father{
    //3.定义父类中的普通方法
    public void eat(){
        System.out.println("爸爸爱吃肉");
    }
    public void play(){
        System.out.println("爸爸爱放风筝");
    }
}
//2.创建子类
class Son extends Father{
    //5.如果子类对父类的方法不满意，可以重写父类的方法
    /*重写的原则：两同 两小 一大
    * 两同：子类方法的 方法名与参数列表 和父类方法的相同
    * 一大：子类方法的 方法修饰符权限 >= 父类方法的
    * 两小：子类方法的返回值类型 <= 父类方法的返回值类型
    * 注意：这里所说的<=是指子类方法的返回值类型是父类返回值类型的子类
    * 或者与父类的返回值类型一致，如果父类方法的返回值类型是void,子类保持一致即可
    * */
    @Override //注解，用来加在方法上，表示这是一个重写的方法
    public void eat(){
        System.out.println("儿子爱吃蔬菜");
    }
    @Override
    public void play(){
        System.out.println("儿子爱玩游戏");
    }
}
 
5. 拓展
 
5.1 this与super的区别
 
this代表的是本类对象的引用，我们可以把this看作是Cat this = new Cat();
 super代表的是父类对象的引用，我们可以把super看作是Father super = new Father();
 当本类的成员变量与局部变量同名时，需要使用this.变量名指定本类的成员变量
 当本类的成员变量与父类的成员变量同名时，需要使用super.变量名指定父类的成员变量
 this可以实现调用本类构造方法的功能，不能互相调用，需要写在构造方法首行
 this();表示调用本类的无参构造 this(参数);表示调用本类的对应参数的构造
 super也可以实现调用父类构造方法的功能
 super();表示调用父类的无参构造 super(参数);表示调用父类的对应参数的构造
 注意：super的使用前提是继承，没有父子类关系，就没有super
 注意：this调用构造方法或者super调用构造方法，都必须出现在构造方法的第一行
 注意：如果父类没有无参构造，需要手动在子类构造方法的第一行调用其他的含参构造
 拓展：如果子类重写了父类的方法以后，可以使用super.方法名(参数列表)来调用
 
5.2 重载Overload 与重写Override的区别
 
重载：在一个类中的现象：同一个类中，存在方法名相同，参数列表不同的方法
 重写：是指建立了继承关系以后，子类对父类的方法不满意，可以重写，遵循两同两小一大原则
 重载的意义：是为了外界调用方法时方便，不管传入什么样的参数，都可以匹配到对应的同名方法
 重写的意义：在不修改源码的情况下，进行功能的修改与拓展（OCP原则：面向修改关闭，面向拓展开放）

IntelliJ IDEA使用教程 （总目录篇）
 
在 IntelliJ IDEA 中这个查看一个类也就是当前类的所有继承关系，包括实现的所有的接口和继承的类，
 
这个继承，不仅仅是一级的继承关系，包括好几层的继承。父类的父类的父类。直到最后。
 可以很清楚明了的了解一个类的实现关系。
diagram 英[ˈdaɪəgræm] 美[ˈdaɪəˌɡræm]
 n. 图表; 示意图; 图解; [数] 线图;
 vt. 图解; 用图表示;
 
下面看这个编辑器怎么以图解的形式，查看这种继承关系。
 
 
 
 
（上面的是查看的Java源码的类的所有继承关系，最下面的这个是在查看spring项目里面的一个类的继承关系的时候，可能会有spring关系图，这个spring关系太复杂了，简直跟蜘蛛网一样，还是就看看各个类的继承图就可以啦。）
 
 
 
更新：这个地方是有放大镜功能哦。我也是意外发现的，具体看图。
 
 
20170508，追加；
 
看了楼下的评论，还真的有个uml插件，然后，就看下面的截图，要是你们是社区版的，看看下载了这个插件之后，能不能用？
 
 
2017/08/01追加
 
上面示范的是如何向上看----看一个类的继承关系；
 
下面再看看，怎么向下看，-----看一个类的子类实现关系。
 
 
先看下map接口的实现类，哇赛赛，600多个。
 
这个so far。我上面截图理解的有点问题，不是没找到，是暂时没有继续扩展，因为jdk也是一直在发展的，所以，这个map接口的实现类，以后只会多，不会少的。所以，他这个地方的so far ，就目前为止，也许再过些年，六千个也是可能的。
 
再看个少点的。
 
 
这个是我们自己写的一个类，他有四个类继承了这个类。这个少。
 
那么快捷键是啥呢？
 
 
我这个就是告诉你，怎么在你的电脑上，找到你自己对应的快捷键。我这是Ctrl + T。不知道你那是啥。
 
 
 
我写完文章，给自己点个赞，不过分吧，
 不过分，那我可就点啦啊。
 我先点为敬，你们随意。大家随意。不要客气。。。

 
 
继承
 
 
生活中的继承
 
 
 
 
类的继承格式
 
 
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
 
 
class 父类 {
}
 
class 子类 extends 父类 {
}
 
 
为什么需要继承
 
 
接下来我们通过实例来说明这个需求。
 
 
开发动物类，其中动物分别为企鹅以及老鼠，要求如下：
 
 
企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）
 
public class AA
{
	public static void main(String[] args)
	{
		dog TOM = new dog("TOM");//新建dog对象
	}
}
class dog extends Animal//继承Animal类  相当于把Animal类的东西送给dog
{
	public  dog(String name) //构造函数
	{
		this.name=name;//继承Animal的name
		System.out.print(this.name);
		eat("食物");//调用继承函数eat
		sleep();//调用继承函数sleep
	}	
}
class Animal 	//动物   包含  吃 和 睡 
{
	public String name;

	/睡睡睡
	public void sleep()
	{
		System.out.print("sleep now");
	}
	/吃吃吃
	public void eat(String something)
	{
		System.out.print(something);
	}
	
	
}
 
 
继承类型
 
 
需要注意的是 Java 不支持多继承，但支持多重继承。
 
 
 
 
继承关键字
 
 
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类
 
 
extends关键字
 
 
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
 
 
public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}
 
 
implements关键字
 
 
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
 
 
public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}
 
 
super 与 this 关键字
 
 
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
 
 
this关键字：指向自己的引用。
 
 
class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}
 
 
final关键字
 
 
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
 
 
 
声明类：
 
final class 类名 {//类体}
 
 
声明方法：
 
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
 
 
注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final
 
 
 
 
 
构造器
 
 
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
 
 
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
 
 


public class AA extends Animal
{
	public static void main(String[] args)
	{
		new AA("继承构造函数");
	}
	
	public AA(String A)
	{
		super(A);
	}
}

class Animal 	//动物   包含  吃 和 睡 
{
	
	public Animal(String A)
	{
		System.out.print(A);
	}
	
	
	
}