1 package cn.temptation; 2  3 public class Sample01 { 4     public static void main(String[] args) { 5         // 继承关系中的private访问权限：子类只能访问父类中的非私有的成员 6     } 7 } 8  9 //// 父类10 //class Father {11 //    // 成员变量12 //    // 子类从父类继承时，父类的private的成员变量（私有的成员变量）对于子类来说是无法访问的13 //    private String secret = "秘密";14 //    // 子类从父类继承时，父类的public的成员变量（公有的成员变量）对于子类来说是可以访问的15 //    public String info = "信息";16 //    17 //    // 成员方法18 //    // 子类从父类继承时，父类的private的成员方法（私有的成员方法）对于子类来说是无法访问的19 //    private void showByFatherPrivate() {20 //        System.out.println("这是Father类的私有成员方法");21 //    }22 //    23 //    // 子类从父类继承时，父类的public的成员方法（公有的成员方法）对于子类来说是可以访问的24 //    public void showByFatherPublic() {25 //        System.out.println("这是Father类的公有成员方法");26 //    }27 //}28 //29 //// 子类30 //class Baby extends Father {31 //    // 成员方法32 //    public void showByBaby() {33 //        System.out.println("这是Baby的成员方法");34 //    }35 //    36 //    public void use() {37 //        System.out.println(info);38 //        // 语法错误：The field Father.secret is not visible39 ////        System.out.println(secret);40 //        41 //        showByFatherPublic();42 //        // 语法错误：The method showByFatherPrivate() from the type Father is not visible    43 ////        showByFatherPrivate();44 //        showByBaby();45 //    }46 //}

 1 package cn.temptation; 2  3 public class Sample02 { 4     public static void main(String[] args) { 5         // 【继承使用的场合：在描述类与类之间是一种"is a(an)"的关系时，推荐使用继承】 6         // 使用时，千万不要为了继承而继承 7          8         TestC testC = new TestC(); 9         testC.method1();10         testC.method3();11         // 因为滥用继承，这时TestC对象多出了method2这个行为的12         testC.method2();13     }14 }15 16 class TestA {17     public void method1() {18         System.out.println("method1");19     }20     21     public void method2() {22         System.out.println("method2");23     }24 }25 26 //class TestB {27 //    public void method2() {28 //        System.out.println("method2");29 //    }30 //    31 //    public void method3() {32 //        System.out.println("method3");33 //    }34 //}35 36 // 出于为了节省TestB中代码的考虑，也就是为了不想写method2方法，选择从TestA继承37 class TestB extends TestA{38     public void method3() {39         System.out.println("method3");40     }41 }42 43 //class TestC {44 //    public void method1() {45 //        System.out.println("method1");46 //    }47 //    48 //    public void method3() {49 //        System.out.println("method3");50 //    }51 //}52 53 // 出于为了节省TestC中代码的考虑，也就是为了不想写method1方法，选择从TestB继承54 class TestC extends TestB {55     56 }

 1 package cn.temptation; 2  3 public class Sample03 { 4     public static void main(String[] args) { 5         // 需求：苹果是一种水果，颜色是红色的，吃起来是甜的，可以做手机； 6         //        香蕉也是一种水果，颜色是黄色的，吃起来是软的，可以打架 7          8         Apple apple = new Apple(); 9         apple.setName("苹果");10         apple.setColor("红色");11         System.out.println("水果的名称为：" + apple.getName() + "，颜色为：" + apple.getColor());12         apple.taste("甜");13         apple.makePhone();14         15         Banana banana = new Banana();16         banana.setName("香蕉");17         banana.setColor("黄色");18         System.out.println("水果的名称为：" + banana.getName() + "，颜色为：" + banana.getColor());19         banana.taste("软");20         banana.fight();21     }22 }23 24 // 水果类（父类）25 class Fruit {26     // 成员变量27     // 名字28     private String name;29     // 颜色30     private String color;31 32     // 成员方法33     public String getName() {34         return name;35     }36 37     public void setName(String name) {38         this.name = name;39     }40 41     public String getColor() {42         return color;43     }44 45     public void setColor(String color) {46         this.color = color;47     }48     49     // 自定义的成员方法50     public void taste(String feeling) {51         System.out.println("味道是：" + feeling + "的！");52     }53 }54 55 // 苹果类（子类）56 class Apple extends Fruit {57     // 成员变量58     59     // 成员方法60     public void makePhone() {61         System.out.println("做手机");62     }63 }64 65 // 香蕉类（子类）66 class Banana extends Fruit {67     // 成员变量68     69     // 成员方法70     public void fight() {71         System.out.println("用来打架");72     }73 }

 1 package cn.temptation; 2  3 public class Sample04 { 4     public static void main(String[] args) { 5         // 类的常见结构（写法约定：从上向下） 6         // 成员变量 7         // 静态代码块 8         // 构造代码块 9         // 无参构造函数10         // 有参构造函数11         // get/set方法12         // 自定义成员方法13         14         // 说到继承，自然考虑形成继承关系的两个类的结构间互相关系15         16         // 对于成员变量而言17         // 1、子类的成员变量 和 父类的成员变量名字不同，只要父类的成员变量非私有的，在子类中就可以访问18         // 2、子类的成员变量 和 父类的成员变量名字相同，只要父类的成员变量非私有的，子类的成员方法访问同名的成员变量时，依旧遵循"就近原则"19         //        调用子类的成员方法有两种：均遵循"就近原则"20         //         子类自己的成员方法访问子类自己有且父类也有的成员变量21         //        子类继承自父类的成员方法访问子类自己有且父类也有的成员变量22         // 3、子类没有而父类有的成员变量，只要父类的成员变量非私有的，在子类中就可以访问23         24         // 思考：继承关系的子类和父类，变量的访问规则是什么？25         // 对于子类的成员方法中的语句来说，最近的是成员方法的局部变量（如果局部变量存在的话）26         // 如果局部变量不存在，则在子类的成员变量中找（如果子类的成员变量存在的话）27         // 如果子类的成员变量不存在，则在父类的非私有的成员变量中找（如果父类的非私有的成员变量存在的话）28         // 如果父类的非私有的成员变量不存在，则语法出错，提示找不到该变量29         30         Parent parent = new Parent();31         parent.showByParent();                    // 232         33         Child child = new Child();34         child.showByChild();                    35         child.showByParent();                    // 2（同样也是就近原则，访问的是父类中的成员变量i的值，虽然是子类对象的调用）36         child.showByChildEx(6);37     }38 }39 40 // 子类41 class Child extends Parent {42     // 成员变量43     public int i = 4;44     public int j = 3;45     46     // 成员方法47     public void method() {48         System.out.println("增加一些距离");49         System.out.println("增加一些距离");50         System.out.println("增加一些距离");51         System.out.println("增加一些距离");52         System.out.println("增加一些距离");53         System.out.println("增加一些距离");54         System.out.println("增加一些距离");55         System.out.println("增加一些距离");56         System.out.println("增加一些距离");57         System.out.println("增加一些距离");58         System.out.println("增加一些距离");59         System.out.println("增加一些距离");60         System.out.println("增加一些距离");61         System.out.println("增加一些距离");62     }63     64     public void showByChild() {65         System.out.println("Child类中访问i：" + i);        // 466         System.out.println("Child类中访问j：" + j);        // 367         // 语法出错：k cannot be resolved to a variable68 //        System.out.println("Child类中访问k：" + k);69     }70     71     public void showByChildEx(int i) {72         System.out.println("Child类中访问局部变量i：" + i);            // 673         System.out.println("Child类中访问成员变量i：" + this.i);        // 474     }75 }76 77 //父类78 class Parent {79     // 成员变量80     public int i = 2;81     82     // 成员方法83     public void showByParent() {84         System.out.println("Parent类中访问i：" + i);        // 285     }86 }

 1 package cn.temptation; 2  3 public class Sample05 { 4     public static void main(String[] args) { 5         // 使用子类的成员方法分别访问  局部变量、子类的成员变量、父类的成员变量 6         // 1、局部变量：直接访问 7         // 2、子类的成员变量：使用this.成员变量进行访问 8         // 3、父类的成员变量：Java中提供了  super  关键字，使用super.成员变量进行访问 9         10         Baby baby = new Baby();11         baby.showByBaby();12         13         // 注意：super关键字是无法访问父类的成员方法中的局部变量的，也是无法访问父类的私有成员变量14     }15 }16 17 // 父类18 class Father {19     // 成员变量20     public int i = 2;21     private int x = 5;22     23     // 成员方法24     public void showByFather() {25         System.out.println("父类的show方法");26         // 局部变量27         int y = 6;28         System.out.println("父类的成员方法中的局部变量y：" + y);29     }30 }31 32 // 子类33 class Baby extends Father {34     // 成员变量35     public int i = 3;36     37     // 成员方法38     public void showByBaby() {39         // 局部变量40         int i = 4;41         42         System.out.println("子类的show方法");43         44         System.out.println("子类的局部变量i：" + i);45         System.out.println("子类的成员变量i：" + this.i);46         System.out.println("父类的成员变量i：" + super.i);47         // 语法错误：The field Father.x is not visible48 //        System.out.println("父类的私有成员变量x：" + super.x);49         50         super.showByFather();51     }52 }

 1 package cn.temptation; 2  3 public class Sample06 { 4     public static void main(String[] args) { 5         // 继承关系的父类子类创建对象时的执行顺序（结合断点观察，子类创建对象使用无参构造函数） 6         // 1、实例化子类，因为new的是子类，所以先走到子类的无参构造函数 7         // 2、并没有走入子类的无参构造函数中，而是依据extends继承关系，找到其父类的无参构造函数 8         // 3、走入父类的无参构造函数中，执行父类的无参构造函数要做的相关操作 9         // 4、接着再走入子类的无参构造函数中，执行子类的无参构造函数要做的相关操作10         Son son = new Son();11         System.out.println(son);12         13         // 继承关系的父类子类创建对象时的执行顺序（结合断点观察，子类创建对象使用有参构造函数）14         // 1、实例化子类，因为new的是子类，所以先走到子类的有参构造函数15         // 2、并没有走入子类的有参构造函数中，而是依据extends继承关系，找到其父类的无参构造函数16         // 3、走入父类的无参构造函数中，执行父类的无参构造函数要做的相关操作17         // 4、接着再走入子类的有参构造函数中，执行子类的有参构造函数要做的相关操作18 //        Son son = new Son(6);19 //        System.out.println(son);20         21         // 注意：22         // 1、子类对象的创建，会依据继承关系找到父类的无参构造函数，走入其中，那么也就在堆中开辟了相应的空间存储父类对象（想一想，super关键字可以访问父类的非私有成员）23         // 2、子类对象的创建，会依据继承关系找到父类的无参构造函数，为什么找的是父类的无参构造函数而不是有参构造函数？24         //         答：因为不写构造函数，JDK会自动生成无参构造函数，显然子类在依据继承关系时，找父类的无参构造函数即可（不论是自己写的还是JDK生成），找有参构造函数可能找不到25         // 3、所谓的new，就是去调用合适（匹配参数列表）的构造函数，构造有构建创造的意思，new的执行会调用并走入构造函数中26         //        换句话说，执行了构造函数，就在堆内存中开辟了空间27         28         // this.子类自身的成员（this指的是当前对象）29         // super.父类的成员（super指的是当前对象的父类对象）30         31         // super()        ：当前对象的父类的无参构造函数32         // super(param)    ：当前对象的父类的有参构造函数33         34         // 1、子类的构造函数中不显式的指明对父类构造函数的调用，默认会执行对父类无参构造函数的调用35         // 2、子类的构造函数中显式的指明对父类无参构造函数的调用，会执行对父类无参构造函数的调用36         // 3、子类的构造函数中显式的指明对父类有参构造函数的调用，会执行对父类有参构造函数的调用，不会执行对父类无参构造函数的调用37     }38 }39 40 // 父类41 class Dad {42     // 成员变量43     44     // 构造函数45     public Dad() {46         System.out.println("父类的无参构造函数");47     }48     49     public Dad(int param) {50         System.out.println("父类的有参构造函数");51     }52 }53 54 // 子类55 class Son extends Dad {56     // 成员变量57     58     // 构造函数59     public Son() {60         // 调用父类的无参构造函数61 //        super();62         // 调用父类的有参构造函数63 //        super(100);64         System.out.println("子类的无参构造函数");65         66         // 注意：子类的构造函数中的父类构造函数调用必须位于子类构造函数中的第一行，写在其他语句之后会产生语法错误67         // 语法错误：Constructor call must be the first statement in a constructor68 //        super();69     }70     71     public Son(int param) {72         System.out.println("子类的有参构造函数");73     }74 }

 1 package cn.temptation; 2  3 public class Sample07 { 4     public static void main(String[] args) { 5         // 在父类中手写了有参构造函数，但是没有手写无参的构造函数，子类中不论是无参构造函数还是有参构造函数均提示语法错误 6         // 语法错误：Implicit super constructor FatherEx() is undefined. Must explicitly invoke another constructor 7         // 原因：在类中，不手写无参构造函数，JDK为类自动创建无参构造函数；一旦手写了有参构造函数，JDK不会为类自动创建无参构造函数 8         //        而子类从父类继承，创建子类对象时会去找父类的无参构造函数，自然找不到了，所以语法出错 9         // 解决方案：使用构造函数时，都补上无参构造函数，这样可以避免语法出错10     }11 }12 13 // 父类14 class FatherEx {15     // 构造函数（有参）16     public FatherEx(int param) {17         System.out.println("这是父类的有参构造函数");18     }19 }20 21 // 子类22 //class SonEx extends FatherEx {23 //    // 构造函数（无参）24 //    // 语法错误：Implicit super constructor FatherEx() is undefined. Must explicitly invoke another constructor25 ////    public SonEx() {26 ////        System.out.println("这是子类的无参构造函数");27 ////    }28 //    29 //    // 语法错误：Implicit super constructor FatherEx() is undefined. Must explicitly invoke another constructor30 ////    public SonEx(int param) {31 ////        System.out.println("这是子类的无参构造函数");32 ////    }33 //}

 1 package cn.temptation; 2  3 public class Sample08 { 4     public static void main(String[] args) { 5         // 类中常用的三个部分：成员变量、构造函数、成员方法 6          7         // 有继承关系的子类的实例化时，会涉及到几块内容？ 8         // 答：涉及到父类 和 子类的成员变量、构造函数，但是和成员方法无关 9         10         // 有继承关系的子类的实例化的顺序（结合断点）11         // 1、实例化子类，因为new的是子类，所以先走到子类的构造函数12         // 2、并没有走入子类的构造函数中，而是依据extends继承关系，找到其父类的构造函数13         // 3、并没有走入父类的构造函数中，而是对父类中的成员变量执行初始化操作14         // 4、走入父类的构造函数中，执行父类构造函数要做的相关操作15         // 5、接着对子类中的成员变量执行初始化操作16         // 4、走入子类的构造函数中，执行子类构造函数要做的相关操作17         18         SonDemo son = new SonDemo();19         System.out.println(son);20         son.showBySon();21     }22 }23 24 // 父类25 class FatherDemo {26     // 成员变量27     private int age = 40;28     public String name = "父亲";29 30     // 构造函数31     public FatherDemo() {32 //        super();33         System.out.println("父类的构造函数");34     }35 36     // 成员方法37     public int getAge() {38         return age;39     }40 41     public void setAge(int age) {42         this.age = age;43     }44 45     public String getName() {46         return name;47     }48 49     public void setName(String name) {50         this.name = name;51     }52     53     // 自定义的成员方法54     public void showByFather() {55         System.out.println("父类的show方法");56     }57 }58 59 // 子类60 class SonDemo extends FatherDemo {61     // 成员变量62     private int weight = 5;63     public String info = "孩子";64 65     // 构造函数66     public SonDemo() {67 //        super();68         System.out.println("子类的构造函数");69     }70 71     // 成员方法72     public int getWeight() {73         return weight;74     }75 76     public void setWeight(int weight) {77         this.weight = weight;78     }79 80     public String getInfo() {81         return info;82     }83 84     public void setInfo(String info) {85         this.info = info;86     }87     88     // 自定义的成员方法89     public void showBySon() {90         System.out.println("子类的show方法");91     }92 }

 1 package cn.temptation; 2  3 public class Sample09 { 4     public static void main(String[] args) { 5         // 有继承关系的子类 和 父类结构中有静态代码块、构造代码块、构造函数、成员变量等，子类的实例化执行顺序是什么样的？ 6          7         // 1、首先走到子类的实例化语句 8         // 2、走到父类的静态成员变量，进行初始化 9         // 3、走到父类的静态代码块10         // 4、走到子类的静态成员变量，进行初始化11         // 5、走到子类的静态代码块12         // 6、走到子类的构造函数，但是不走入其中13         // 7、走到父类的构造函数，但是不走入其中14         // 8、走到父类的非静态成员变量，进行初始化15         // 9、走到父类的构造代码块16         // 10、走到父类的构造函数中17         // 11、走到子类的非静态成员变量，进行初始化18         // 12、走到子类的构造代码块19         // 13、走到子类的构造函数中20         21         ChildEx child1 = new ChildEx();22         System.out.println(child1);23         24         ChildEx child2 = new ChildEx();25         System.out.println(child2);26     }27 }28 29 // 父类30 class ParentEx {31     // 成员变量32     private int age = 40;33     public String name = "父亲";34     // 静态成员变量35     public static String gender = "男";36     37     // 静态代码块38     static {39         System.out.println("父类的静态代码块");40     }41     42     // 构造代码块43     {44         System.out.println("父类的构造代码块");45     }46 47     // 构造函数48     public ParentEx() {49 //        super();50         System.out.println("父类的构造函数");51     }52 }53 54 // 子类55 class ChildEx extends ParentEx {56     // 成员变量57     private int weight = 5;58     public String info = "孩子";59     // 静态成员变量60     public static String country = "中国";61     62     // 静态代码块63     static {64         System.out.println("子类的静态代码块");65     }66     67     // 构造代码块68     {69         System.out.println("子类的构造代码块");70     }71     72     // 构造函数73     public ChildEx() {74 //        super();75         System.out.println("子类的构造函数");76     }77 }

 1 package cn.temptation; 2  3 public class Sample10 { 4     public static void main(String[] args) { 5         // 继承关系中父类子类的成员方法的使用 6         // 1、子类的成员方法 和 父类的成员方法不同名时，子类对象随便调用，都可以访问 7         // 2、子类的成员方法 和 父类的成员方法同名时，使用的是子类的成员方法 8         //        此时，好像父类虽然把其成员（非私有的）都给了子类，但是子类把从父类继承过来的同名的成员进行了覆盖一样 9         10         // Java中这种现象称为    重写（覆盖）Override11         12 //        ChildSample child = new ChildSample();13 //        child.showByParent();    // 父类的showByParent方法14 //        child.showByChild();    // 子类的showByChild方法15 //        child.show();            // 子类的show方法16         17         /*18          * 对比：说明Override  和  Overload 的区别？19          * Override：重写（覆盖），子类的成员 和 父类的成员同名时，子类对象使用时使用子类成员的现象20          * Overload：重载，描述的是方法使用时，相同的方法名，不同的参数列表的现象21          */22     }23 }24 25 //// 父类26 //class ParentSample {27 //    // 成员方法28 //    public void showByParent() {29 //        System.out.println("父类的showByParent方法");30 //    }31 //    32 //    public void show() {33 //        System.out.println("父类的show方法");34 //    }35 //}36 //37 //// 子类38 //class ChildSample extends ParentSample {39 //    // 成员方法40 //    public void showByChild() {41 //        System.out.println("子类的showByChild方法");42 //    }43 //    44 //    public void show() {45 //        System.out.println("子类的show方法");46 //    }47 //}

 1 package cn.temptation; 2  3 public class Sample11 { 4     public static void main(String[] args) { 5         // 重写的特点： 6         // 1、重写时，子类的方法和父类的方法不但方法名相同，而且参数列表相同（参数类型相同，参数名可以不同） 7         // 2、重写时，子类的方法和父类的方法不但方法名相同，而且参数列表相同，而且返回值类型也要相同 8         // 3、重写时，子类既可以继续使用父类的成员方法，又可以不使用父类的成员方法 9         //        这里有两层含义：10         //        A：完全覆盖：完全不用父类的成员方法的内容，重新来一套11         //        B：部分覆盖：父类的成员方法的内容还继续用，加一些新的内容形成自己的成员方法12         //            只需要在子类的成员方法中使用super.父类的成员方法就可以继续使用父类的成员方法的内容13         ChildSample child = new ChildSample();14         child.method(123);15         child.use();16     }17 }18 19 // 父类20 class ParentSample {21     // 成员方法22     public void showByParent() {23         System.out.println("父类的showByParent方法");24     }25     26     public void show() {27         System.out.println("父类的show方法");28     }29     30     public void method(int i) {31         System.out.println("父类的有参method方法");32     }33     34     public void use() {35         System.out.println("父类的use方法");36     }37 }38 39 // 子类40 class ChildSample extends ParentSample {41     // 成员方法42     public void showByChild() {43         System.out.println("子类的showByChild方法");44     }45     46     public void show() {47         System.out.println("子类的show方法");48     }49     50     // 如下这个method方法就覆盖了父类中继承过来的method方法51 //    public void method(int x) {52 //        System.out.println("子类的有参method方法");53 //    }54     55     // 如下这个method方法，如果父类中没有method方法，这样写是没有语法错误的56     // 但是父类中有method方法，如下的写法因为返回值类型和父类中的不一致，产生语法错误57     // 语法错误：The return type is incompatible with ParentSample.method(int)58 //    public String method(int i) {59 //        System.out.println("子类的有参method方法");60 //        return "返回值";61 //    }62     63     public void use() {64         super.use();65         System.out.println("子类的use方法");66     }67 }

 1 package cn.temptation; 2  3 public class Sample12 { 4     public static void main(String[] args) { 5         // 关于重写的一些问题： 6         // 1、父类的私有成员方法   和  子类的公有成员方法，同名、参数列表相同，这是不是重写？            答：这种不是重写 7         //        原因：因为子类都访问不到父类的私有成员方法，还谈什么覆盖呢？ 8         // 2、父类的公有成员方法  和 子类的私有成员方法，同名、参数列表相同，语法错误：Cannot reduce the visibility of the inherited method from ParentTest 9         //         不能修改子类中继承自父类（重写父类）方法的访问修饰符权限10         // 3、重写时，子类的方法 和 父类的方法建议写的完全一致（指的是形式的完全一致，方法的内容可以不一致）11         //        IDE提供了重写的便捷操作：在子类中书写和父类中相同的成员方法名，会自动生成相同的方法结构12         ChildTest child = new ChildTest();13         child.show();14     }15 }16 17 // 父类18 class ParentTest {19     private void show(){20         System.out.println("父类的私有show方法");21     }22     23     public void use() {24         System.out.println("父类的公有use方法");25     }26     27     public void test(String param) {28         System.out.println("父类的公有有参test方法");29     }30 }31 32 // 子类33 class ChildTest extends ParentTest {34     public void show(){35         System.out.println("子类的公有show方法");36     }37     38     // 语法错误：Cannot reduce the visibility of the inherited method from ParentTest39 //    private void use() {40 //        System.out.println("子类的私有use方法");41 //    }42     43     @Override44     public void test(String param) {45         super.test(param);46     }47 }

  1 package cn.temptation;  2   3 public class Sample13 {  4     public static void main(String[] args) {  5         // 需求：使用继承、重写等技术点实现如下功能：  6         //         Tom猫是一种动物，3岁，吃鱼喝着牛奶，晒太阳  7         //        Snoppy狗是一种动物，2岁，吃肉喝着可乐，看大门  8           9         Cat cat = new Cat("Tom", 3); 10         cat.eat("鱼"); 11         cat.bask("太阳"); 12          13         Dog dog = new Dog("Snoppy", 2); 14         dog.eat("肉"); 15         dog.guard("大门"); 16     } 17 } 18  19 // 动物类（父类） 20 class Animal { 21     // 成员变量 22     // 姓名 23     private String name; 24     // 年龄 25     private int age; 26  27     // 构造函数 28     public Animal() { 29         super(); 30     } 31  32     public Animal(String name, int age) { 33         super(); 34         this.name = name; 35         this.age = age; 36     } 37  38     // 成员方法 39     public String getName() { 40         return name; 41     } 42  43     public void setName(String name) { 44         this.name = name; 45     } 46  47     public int getAge() { 48         return age; 49     } 50  51     public void setAge(int age) { 52         this.age = age; 53     } 54      55     // 自定义成员方法 56     public void eat(String food) { 57         // 一般的动物，就知道吃，吃的时候不知道喝 58         System.out.print("吃" + food); 59     } 60 } 61  62 // 猫类 63 class Cat extends Animal { 64     // 构造函数 65     public Cat() { 66         super(); 67     } 68      69     public Cat(String name, int age) { 70         // 写法1、使用局部变量 71 //        System.out.println("名字为：" + name + "，年龄为：" + age); 72          73         // 写法2、使用父类对象的成员变量 74 //        super.setName(name); 75 //        super.setAge(age); 76 //        System.out.println("名字为：" + super.getName() + "，年龄为：" + super.getAge()); 77          78         // 写法3、使用子类对象的成员变量（这里的成员变量继承自父类对象） 79         this.setName(name); 80         this.setAge(age); 81         System.out.println("名字为：" + this.getName() + "，年龄为：" + this.getAge()); 82     } 83      84     // 成员方法 85     /** 86      * 重写父类的eat方法 87      */ 88     @Override 89     public void eat(String food) { 90         super.eat(food); 91         System.out.println("喝牛奶"); 92     } 93      94     public void bask(String obj) { 95         System.out.println("晒" + obj); 96     } 97 } 98  99 // 狗类100 class Dog extends Animal {101     // 构造函数102     public Dog() {103         super();104     }105     106     public Dog(String name, int age) {107         System.out.println("名字为：" + name + "，年龄为：" + age);108     }109     110     // 成员方法111     /**112      * 重写父类的eat方法113      */114     @Override115     public void eat(String food) {116         super.eat(food);117         System.out.println("喝可乐");118     }119     120     public void guard(String obj) {121         System.out.println("看" + obj);122     }123 }