/*继承*/
1.java只支持单继承不支持多继承
原因：会带来安全隐患，因为当继承多个类中相同功能不同内容时，子类不知道继承哪一个。
2.当有多继承时，应创建最子类的对象，因为最子类对象可以使用最多的功能。

/*子父类中变量的特点*/
三个方面进行思考：
1.变量，
2.函数，
3.构造函数。

/*子父类中变量的特点*/
情况一：
class Fu
{
        int num=3;
}
class Zi extends Fu
{
        int num=5;
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                System.out.println(z.num);                                                                        //打印结果为5，表明当子父类出现同名变量时，优先打印子类变量
        }
}
情况二：
class Fu
{
        private int num3=4;
        int num1=3;
}
class Zi extends Fu
{
        int num2=5;
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                System.out.println(z.num1+"......"+z.num2+"....");                        //表明子类继承父类可以继承父类中未被私有的变量
        }
}
情况三：
/*关键字：super*/
class Fu
{
        int num=3;
}
class Zi extends Fu
{
        int num=5;
        public void show()
        {
                System.out.println(super.num+"....."+num);                                        //当子父类出现同名变量时，super.表示父类对象
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                z.show();
        }       
}
情况四：
class Fu
{
        int num=3;
}
class Zi extends Fu
{
        //int num=5;
        public void show()
        {
                System.out.println(this.num);                                                                //打印结果为3，这可以看作子类继承父类，子类中含父类变量
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                z.show();
        }       
}

/*子父类函数的特点*/
情况一：
class Fu
{
        void show1()
        {
                System.out.println("Fu show");
        }
}
class Zi extends Fu
{
        void show2()
        {
                System.out.println("Zi show");
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                z.show1();
                z.show2();                                                                                        //打印结果为：Fu show
        }                                                                                                                                          Zi show
}                                                                                                                        //表示子类继承父类会继承父类未私有的函数

情况二：
/*重写或覆盖*/
//当子类和父类有相同函数名，但内容不同时，子类会将父类该函数覆盖（重写）掉
class Fu
{
        void show()
        {
                System.out.println("Fu show");
        }
}
class Zi extends Fu
{
        void show()
        {
                System.out.println("Zi show");
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                z.show();                                                                //打印结果为 Zi show
        }
}

情况三：
/*子父类函数中super的利用*/
class Fu
{
        void show()
        {
                System.out.println("Fu show");
        }
}
class Zi extends Fu
{
        void show()
        {
                //System.out.println("Fu show");
                super.show();                                                        //当子类需要用到父类功能中的内容时，利用super.可以简化代码
                System.out.println("Zi show");
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Zi z=new Zi();
                z.show();
        }
}
注意事项：1.对于覆盖来说，子类的权限必须大于或等于父类 权限大小比较： public > protected > private
                  2.静态只能覆盖静态。

/*重载和重写的区别*/
/*重载*/
同一个类下的同名函数，例如：
class Q1
{
        public int tool(int a,int b)
        {
                //
        }
        public void tool(int a,int b,double c)
        {
                //
        }
}
//overload重载只和参数列表有关系，参数个数，参数类型，参数顺序，与返回值类型无关。
/*重写*/
//在子父类中，同名定义(返回值类型相同)相同内容不同的函数，子类会覆盖父类，父类仍然存在，只是没用被调用

/*子父类构造函数的特点*/
this(),super()        使用的前提是必须是构造函数
//this()        用于本类中构造函数1调用构造函数2的内容
//super()        用于子父类中构造函数1调用构造函数2的内容
例一：//this()
class Person
{
        Person()
        {
                System.out.println("阿秋");
        }
        Person(int x)
        {
                this();                                                                //调用Person()中的内容
                System.out.println("阿秋来了")                //注意this(),super()必须放在构造函数内容的第一行
        }
}

例二：//super()
class Fu
{
        Fu()
        {
                System.out.println("阿秋");
        }
}
class Zi extends Fu
{
        Zi()
        {
                //super();                                                        //注意，这是一个隐式的调用子类构造函数的代码
                System.out.println("阿秋来了");
        }
}

/*子父类super的其他作用*/
class Person
{
        private String name;
        Person(String name)
        {
                this.name=name;
        }
        void show()
        {
                System.out.println(name);
        }
}
class Student extends Person
{
        Student(String name)                                        //父类已经定义了name的属性，子类省略
        {
                super(name);                                                //super对于构造函数调用的格式
        }
        void method()
        {
                super.show();                                                //super对于一般函数调用的方式
        }
}
class Q1
{
        public static void main(String[] args)
        {
                Student ss=new Student("阿秋");
                ss.method();
        }
}

/*this(),super()都必须是第一行*/
当this()占据第一行时，隐式的super()会消失，但并不影响调用父类构造函数，因为this()被调用时还是会访问空参的构造函数，而
空参的本类构造函数还是会访问隐式的super().

/*父类的构造函数也有super()*/
所有类的父类是 Object 类。

/*关键字final*/
特点：
1.final 可以修饰类，函数，变量;
2.被 final 修饰的类不能被继承，最终类(用处：为了避免子类继承父类将父类功能覆写);
3.被 final 修饰的方法不能被覆写;(会有一个类中有能被覆写的和不能被覆写的);
4.被 final 修饰的变量是一个常量，既可以是成员变量也可以是局部变量。
   a.被修饰的变量确定永久是该值，无法更改;
   b.final 修饰的常量名各个字母都大写，如果由多个单词组成，用_(下划线)隔开
public static final 全局常量

/*抽象类*/
1.抽象方法必须放在抽象类中
2.抽象方法和类必须用 abstract 关键字修饰
3.抽象类不允许创建对象，不能new
4.要想调用抽象类其中的方法，必须由子类覆写其全部方法后，创立子类对象调用，如果子类只覆写了抽象类一部分方法
        那么该子类仍然是抽象类。
5.抽象类可以强制子类覆写功能。
例如：
例一：
abstract class Student
{
         abstract void study();                                        //抽象类格式
}

例二：
abstract class Student
{
         abstract void study();
         abstract void study1();
}
abstract class BaseStudent extends Student
{
        void study()
        {
                System.out.println("阿秋");       
        }
//要想调用父类的方法，子类必须覆写父类全部方法，只调用其中一部分，则子类也是抽象类
}
例三：
abstract class Student
{
        abstract void study();
        abstract void study1();
        void sleep()                                                        //抽象类也可以加入常规函数
        {
                System.out.println("躺着睡");
        }
}
class AdvStudent extends Student
{
        void study()
        {
                System.out.println("学习");                        //并且子类可以继承
        }
        void study1(){}
}
class Q1
{
        public static void main(String[] args)
        {
                AdvStudent ss=new AdvStudent();
                ss.sleep();                                                        //建立子类对象还可以调用
                ss.study();
        }
}

不错，加油

不错，加油

支持，楼主写得不错

继续努力~