【原】Java学习笔记017 - 面向对象

 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 visible
39 ////        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();                    // 2
32         
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);        // 4
66         System.out.println("Child类中访问j：" + j);        // 3
67         // 语法出错：k cannot be resolved to a variable
68 //        System.out.println("Child类中访问k：" + k);
69     }
70     
71     public void showByChildEx(int i) {
72         System.out.println("Child类中访问局部变量i：" + i);            // 6
73         System.out.println("Child类中访问成员变量i：" + this.i);        // 4
74     }
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);        // 2
85     }
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 visible
48 //        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 constructor
68 //        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 constructor
25 ////    public SonEx() {
26 ////        System.out.println("这是子类的无参构造函数");
27 ////    }
28 //    
29 //    // 语法错误：Implicit super constructor FatherEx() is undefined. Must explicitly invoke another constructor
30 ////    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中这种现象称为    重写（覆盖）Override
11         
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 ParentTest
39 //    private void use() {
40 //        System.out.println("子类的私有use方法");
41 //    }
42     
43     @Override
44     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     @Override
115     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 }