1. /*
   
2.         猫狗案例
   
3.                 具体事物：猫，狗
   
4.                 共性：姓名，年龄，吃饭
   
5. 
   
6.         分析：从具体到抽象
   
7.                 猫:
   
8.                         成员变量：姓名，年龄
   
9.                         构造方法：无参，带参
   
10.                         成员方法：吃饭(猫吃鱼)
    
11.                        
    
12.                 狗:
    
13.                         成员变量：姓名，年龄
    
14.                         构造方法：无参，带参
    
15.                         成员方法：吃饭(狗吃肉)
    
16.                        
    
17.                 因为有共性的内容，所以就提取了一个父类。动物。
    
18.                 但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
    
19.                 而方法是抽象的类，类就必须定义为抽象类。
    
20.                
    
21.                 抽象动物类：
    
22.                         成员变量：姓名，年龄
    
23.                         构造方法：无参，带参
    
24.                         成员方法：吃饭();
    
25.        
    
26.         实现：从抽象到具体
    
27.                 动物类:
    
28.                         成员变量：姓名，年龄
    
29.                         构造方法：无参，带参
    
30.                         成员方法：吃饭();
    
31.                        
    
32.                 狗类：
    
33.                         继承自动物类
    
34.                         重写吃饭();
    
35.                        
    
36.                 猫类：
    
37.                         继承自动物类
    
38.                         重写吃饭();
    
39. */
    
40. //定义抽象的动物类
    
41. abstract class Animal {
    
42.         //姓名
    
43.         private String name;
    
44.         //年龄
    
45.         private int age;
    
46.        
    
47.         public Animal() {}
    
48.        
    
49.         public Animal(String name,int age) {
    
50.                 this.name = name;
    
51.                 this.age = age;
    
52.         }
    
53.        
    
54.         public String getName() {
    
55.                 return name;
    
56.         }
    
57.        
    
58.         public void setName(String name) {
    
59.                 this.name = name;
    
60.         }
    
61.        
    
62.         public int getAge() {
    
63.                 return age;
    
64.         }
    
65.        
    
66.         public void setAge(int age) {
    
67.                 this.age = age;
    
68.         }
    
69.        
    
70.         //定义一个抽象方法
    
71.         public abstract void eat();
    
72. }
    
73. 
    
74. //定义具体的狗类
    
75. class Dog extends Animal {
    
76.         public Dog() {}
    
77.        
    
78.         public Dog(String name,int age) {
    
79.                 super(name,age);
    
80.         }
    
81.        
    
82.         public void eat() {
    
83.                 System.out.println("狗吃肉");
    
84.         }
    
85. }
    
86. 
    
87. //定义具体的猫类
    
88. class Cat extends Animal {
    
89.         public Cat() {}
    
90.        
    
91.         public Cat(String name,int age) {
    
92.                 super(name,age);
    
93.         }
    
94.        
    
95.         public void eat() {
    
96.                 System.out.println("猫吃鱼");
    
97.         }
    
98. }
    
99. 
    
100. //测试类
     
101. class AbstractTest {
     
102.         public static void main(String[] args) {
     
103.                 //测试狗类
     
104.                 //具体类用法
     
105.                 //方式1：
     
106.                 Dog d = new Dog();
     
107.                 d.setName("旺财");
     
108.                 d.setAge(3);
     
109.                 System.out.println(d.getName()+"---"+d.getAge());
     
110.                 d.eat();
     
111.                 //方式2：
     
112.                 Dog d2 = new Dog("旺财",3);
     
113.                 System.out.println(d2.getName()+"---"+d2.getAge());
     
114.                 d2.eat();
     
115.                 System.out.println("---------------------------");
     
116.                
     
117.                 Animal a = new Dog();
     
118.                 a.setName("旺财");
     
119.                 a.setAge(3);
     
120.                 System.out.println(a.getName()+"---"+a.getAge());
     
121.                 a.eat();
     
122.                
     
123.                 Animal a2 = new Dog("旺财",3);
     
124.                 System.out.println(a2.getName()+"---"+a2.getAge());
     
125.                 a2.eat();
     
126.                
     
127.                 //练习：测试猫类
     
128.         }
     
129. }

复制代码

对于方式2 有调用到下面两个方法吗？
public void setAge(int age)
{
                this.age = age;
}
public void setName(String name) {
                this.name = name;
        }

谢谢解答 不胜感激！

把name age 赋值给  public Animal(String name,int age) {
                this.name = name;
                this.age = age;
        }
然后调用getName  和getA 方法

还没学呢，默默看着

Dog d2 = new Dog("旺财",3);是用的有参构造函数初始化的,所以不用setXxx();方法,二回用getXxx();获取值

当然没有调用啦，你看看你的构造函数
创建对象时是用这个函数给变量赋值的：

1. public Animal(String name,int age) {
   
2.                 this.name = name;
   
3.                 this.age = age;
   
4.         }

复制代码

建议你再看看老师讲的关于构造函数的内容

总结的挺好哒 收藏了 嘿嘿