1 Java中承继的总括
特别注意：上图面世的承继的特征！
2 承继的文件格式
// 派生类publicclassFu{// 核心成员表达式// 核心成员方式// 算式}// 常量publicclassZiextendsFu{// 核心成员表达式// 核心成员方式// 算式 }
模拟：
/*派生类！*/publicclassFu {// 定义核心成员表达式privateintnumber=10;// 定义核心成员方式publicvoidshow(){System.out.println(“number:”+number); }}
/*常量： 通过extends关键字来建立Fu与Zi的承继关系！*/publicclassZiextendsFu {}
/*测试类*/publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象Zizi=newZi();// 调用方式zi.show(); // 从派生类承继过来的！ }}
3 常量无法从派生类承继的内容
常量无法承继派生类被private修饰的内容(核心成员表达式)！但是可以使用派生类提供方式(getter and setter)
/*派生类！*/publicclassFu {// 定义核心成员表达式privateintnumber=10;// 定义方式publicvoidsetNumber(intnumber){this.number=number; }publicintgetNumber(){returnnumber; }// 定义核心成员方式publicvoidshow(){System.out.println(“number:”+number); }}
/*常量： 通过extends关键字来建立Fu与Zi的承继关系！*/publicclassZiextendsFu {}
/*测试类*/publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象Zizi=newZi();// 调用方式，从派生类承继过来的！zi.show(); // 常量没有核心成员表达式number，但是派生类有，我们使用从派生类承继过来的核心成员表达式！// zi.number= 100;常量不能承继派生类被private修饰的内容(核心成员表达式)zi.setNumber(100);System.out.println(zi.getNumber()); }}
4 承继之后常量的特征(核心成员表达式)
* 常量与派生类的核心成员表达式不重名访问的就是派生类的核心成员表达式！【当然也可以直接访问常量自己独有的核心成员表达式】* 常量与派生类的核心成员表达式重名 默认访问的是常量自己的重名核心成员表达式访问派生类的核心成员表达式(与常量重名的核心成员表达式)super.重名的核心成员表达式名称
模拟：
/*派生类*/publicclassFu {// 定义核心成员表达式intnumber=10;}
/*常量*/publicclassZiextendsFu{// 常量独有的核心成员表达式intcount=5;// 常量与派生类重名的核心成员表达式intnumber=200;// 核心成员方式publicvoidshow(){// 常量没有定义核心成员表达式number，那么sout(number)访问的是派生类的核心成员表达式！// 常量定义了与派生类重名的核心成员表达式，sout(number)访问的是常量的！System.out.println(“访问常量的number:”+this.number);// 通过supper访问派生类重名的核心成员表达式！System.out.println(“访问派生类的number:”+super.number); }}
/*测试类*/publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象Zizi=newZi();zi.show(); }}
5 承继之后常量的特征(核心成员方式)
* 子类与派生类的核心成员方式未重名通过你调用的方式名称来区分：* 是从派生类承继过来的核心成员方式* 还是常量独有的核心成员方式* 常量与派生类的核心成员方式重名默认调用的是常量与派生类重名的核心成员方式* this.重名的核心成员方式() 调用的依旧是常量！* supper.重名的核心成员方式() 调用的是派生类！
模拟：
/*派生类*/publicclassFu {// 定义核心成员方式publicvoidfuMethod(){System.out.println(“派生类的核心成员方式执行了。。。”); }}
/*常量*/publicclassZiextendsFu {// 常量独有的核心成员publicvoidziMethod(){System.out.println(“常量独有的核心成员方式执行了。。。”); }// 常量与派生类重名的方式publicvoidfuMethod(){System.out.println(“常量与派生类重名的核心成员方式执行了。。。”); }publicvoidshow(){// 调用常量独有的核心成员方式ziMethod();// 若常量没有提供fuMethod，那么调用fuMethod调用的是从派生类承继过来的！// 常量提供了fuMethod方式，调用常量与派生类重名的方式//fuMethod();this.fuMethod(); // 调用派生类与常量重名的方式super.fuMethod(); }}
/*测试类*/publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象Zizi=newZi();// 调用常量与派生类重名的核心成员方式zi.show(); }}
6 承继之后子类特征(核心成员方式—方式覆盖重写)
类似的方式重载Overload
* 有三个条件：① 多个方式在同一个类中！② 多个方式的方式名称完全一致！③ 多个方式的参数列表不同！(参数的个数，类型)
方式覆盖重写Override
* 有两个条件：① 存在于多个类(接口)中，多个类要有承继或者实现关系！② 多个类中的方式签名得完全一致！(除了访问权限修饰符以外<常量的访问权限不得低于派生类>)访问权限修饰符(范围从大到小)：public protected default privatedefault：在定义方式的时候没有写任何的权限修饰符！【特别注意：：不是写default】* 为了让我们在常量中成功的覆盖重写派生类的方式，JDK提供了一个注解@Override注解：它与注释不同！(注释是给人看得，不参与程序的执行；注解是给机器看的，参与程序的执行！)不同的注解，其功能也不一样！【我们可以通过自定义注解来指定注解的具体功能】@Override注解是JDK提供的，其功能已经注定了！在编译阶段对方式进行语法检查(一旦不符合方式覆盖重写的要求就会报错！)
模拟：
/*派生类*/publicclassFu {// 定义核心成员方式publicvoidshow(){System.out.println(“小鲁班腿很短。。。”); }}
/*常量*/publicclassZiextendsFu {// 覆盖重写派生类的方式@Overridepublicvoidshow(){//System.out.println(“小鲁班腿很短。。。”);super.show(); // 功能等价于上面的那行代码！// 对派生类的方式进行增强(在派生类这个方式里面添加的额外的功能代码)！System.out.println(“但是它的走位很骚。。。”); }}
/*测试类*/publicclassTest {publicstaticvoidmain(String[]args) {// 创建常量对象Zizi=newZi();zi.show(); }}
方式的覆盖重写有好处： 可以对派生类的方式进行增强！
7 承继之后常量的特征(算式)
* 常量不能承继派生类的算式！*在常量的算式中的第一行，都默认去调用了派生类的无参算式！可以在常量的算式里面，使用super(实参)来调用派生类指定的算式！
/*派生类*/publicclassFu {Stringfu=“派生类核心成员表达式”;// 派生类的无参算式publicFu(){System.out.println(“派生类的无参算式执行了。。。”); }publicFu(Stringfu){this.fu=fu; }}
/*常量*/publicclassZiextendsFu {Stringzi;// 常量的无参算式publicZi(){// 默认在此处(第一行)去调用了派生类的无参算式super(); // 写不写都一样！System.out.println(“常量的无参算式执行了。。。”); }// 常量的带参算式publicZi(Stringzi){// 通过参数类指定，调用派生类的哪种算式！super(zi);this.zi=zi;System.out.println(“常量的带参算式执行了。。。”); }}
/*测试类*/publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象Zizi=newZi(“常量的核心成员表达式！”); }}
8 super和this小结
* 基本使用：① this: 区分重名的核心成员表达式和局部表达式！代表的是本类的对象！谁调用当前这个方式，那么这个方式中的this就代表谁核心成员表达式：this.核心成员表达式名称核心成员方式：this.核心成员方式名称(实参)算式：this(实参); ② supper:代表派生类！区分派生类与常量重名的内容(核心成员表达式、核心成员方式)与算式派生类核心成员表达式：super.核心成员表达式名称派生类核心成员方式：super.核心成员方式名称(实参);派生类算式：super(实参);
模拟：
/*派生类*/publicclassFu {// 核心成员表达式intnumber=10;// 核心成员方式publicvoidmethod(){System.out.println(“派生类核心成员方式执行了。。。”); }// 算式publicFu(){System.out.println(“派生类无参算式执行了。。。”); }}
/*常量*/publicclassZiextendsFu {// 核心成员表达式intnumber=20;// 核心成员方法publicvoidmethod() {System.out.println(“常量的核心成员方式执行了。。。”); }// 算式publicZi() {// 默认要调用派生类的无参算式！super();System.out.println(“常量的无参算式执行了。。。”);System.out.println(“常量：”+this.number); // 调用常量的核心成员表达式System.out.println(“派生类：”+super.number); // 调用派生类的核心成员表达式System.out.println(“=============”);this.method(); // 调用常量的核心成员方式super.method(); // 调用派生类的核心成员方式 }publicZi(intnumber) {// 调用本类的无参算式this();this.number=number;System.out.println(this.number); }}
/*测试类*/publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象Zizi=newZi(100); }}
9 super内存图
publicclassPersonextendsObject{privateStringname;privateintage;publicStringgetName() {returnname; }publicvoidsetName(Stringname) {this.name=name; }publicintgetAge() {returnage; }publicvoidsetAge(intage) {this.age=age; }publicPerson(){ }publicPerson(Stringname, intage) {this.name=name;this.age=age; }}
publicclassStudentextendsPerson{// 常量从派生类承继了2个核心成员表达式 name agepublicStudent(){ }publicStudent(Stringname, intage) {// 由于派生类没有提供无参算式，所以这里必须调用派生类的带参构造！【创建常量对象，必定先要创建派生类对象！】super(name, age); // 调用派生类的带参算式，创建派生类对象！【为派生类的核心成员表达式赋值！】 }}
publicclassTest {publicstaticvoidmain(String[] args) {// 创建常量对象/*Student student = new Student(“jack”, 38);System.out.println(student.name + “, ” + student.age);*/Studentstudent=newStudent();student.setName(“jack”); }}
在每次创建常量对象时，先初始化派生类空间，再创建其常量对象本身。目的在于常量对象中包含了其对应的派生类空间，便可以包含其派生类的核心成员，如果派生类核心成员非private修饰，则常量可以随意使用派生类核心成员。代码体现在常量的构造器调用时，一定先调用派生类的构造器。
2.10 承继的特征以及好处总结
★ 特征：
* 一个派生类可以拥有多个常量！【爸爸可以有多个亲生儿子】public class A extends B{ …… }public class C extends B{ …… }* 一个常量只能拥有一个派生类！【儿子只能有1个亲爹】=====>>> 单承继！public class A extends B{ …… }public class A extends B,C{} // 错误！！！ 【不允许多承继！】* Java允许多级承继！public class A extends B{ …… } public class B extends C{ …… }* Java顶层派生类是Object任何一个类没有明确去承继Object,其实已经默认承继了！！！
★ 好处：
* 在常量中对派生类的方式进行增强！【方式的覆盖重写】* 简化代码，提高开发效率！【共性抽取到派生类！】* 承继也有局限性：占用了承继位(置) 【java是单承继的！】public class A extends B{// 重写B类中的方式进行增强！ }
举报/反馈
