JavaSE学习总结第08天_面向对象3

08.01 工具类中使用静态

例:

 1 class ArrayTool
 2 {
 3     //将构造方法私有，外界不能创建该类的对象
 4     private ArrayTool(){}
 5     //遍历数组
 6     public static void print(int[] arr)
 7     {
 8         System.out.print("[");
 9         for(int i = 0;i < arr.length;i++)
10         {
11             if(i == arr.length-1)
12             {
13                 System.out.print(arr[i]+"]");
14             }
15             else
16                 System.out.print(arr[i]+",");
17         }
18         System.out.println();
19     }
20 }
21 
22 class Demo
23 {
24     public static void main(String[] args)
25     {
26         int[] arr = {23,53,12,27,32,85,25};
27         //通过类名直接调用
28         ArrayTool.print(arr);
29     }
30 }
31     

运行结果:

[23,53,12,27,32,85,25]

08.02 工具类的完善

 1 class ArrayTool
 2 {
 3     //将构造方法私有，外界不能创建该类的对象
 4     private ArrayTool(){}
 5     //遍历数组
 6     public static void print(int[] arr)
 7     {
 8         System.out.print("[");
 9         for(int i = 0;i < arr.length;i++)
10         {
11             if(i == arr.length-1)
12             {
13                 System.out.print(arr[i]+"]");
14             }
15             else
16                 System.out.print(arr[i]+",");
17         }
18         System.out.println();
19     }
20     //获取数组中的最大值
21     public static int getMax(int[] arr)
22     {
23         int max = arr[0];
24         for(int i = 1;i < arr.length;i++)
25         {
26             if(arr[i] > max)
27                 max = arr[i];
28         }
29         return max;
30     }
31     //获取数组中的元素第1次出现的位置
32     public static int getIndex(int[] arr,int key)
33     {
34         for(int i = 0;i< arr.length;i++)
35         {
36             if(arr[i] == key)
37                 return i;
38         }
39         return -1;
40     }
41 }
42 
43 class Demo
44 {
45     public static void main(String[] args)
46     {
47         int[] arr = {23,53,12,27,32,85,25};
48         ArrayTool.print(arr);
49         System.out.println("最大值是:"+ArrayTool.getMax(arr));
50         System.out.println("位置:"+ArrayTool.getIndex(arr,12));
51     }
52 }

运行结果:

[23,53,12,27,32,85,25]
最大值是:85
位置:2

08.03 说明书的制作过程

第1步:写一个工具类

第2步:在工具类中使用JAVA中特有的注释符/** */对代码进行注释

第3步:使用javadoc命令创建帮助文档

格式:javadoc -d 目录 -author -version ArrayTool.java

解释:

-d:输出文件的目标目录

目录:帮助文档存放的路径

-author:包含的-author信息

-version:包含的-version信息

ArrayTool.java:需要生成帮助文档的JAVA源文件

注意:类必须是公共或受保护的才可以文档化，否则，将报以下错误

第4步:执行javadoc命令后会创建一个文件夹，文件夹里就是帮助文档的网页文件，点击index.html即可查看所有的注释文档

例:

 1 /**
 2 * 这是对数组进行操作的工具类
 3 * @author ZHY
 4 * @version V1.0
 5 */
 6 public class ArrayTool
 7 {
 8     //将构造方法私有，外界不能创建该类的对象
 9     private ArrayTool(){}
10     /**
11     * 这是遍历数组的方法，遍历后的格式是:[元素1,元素2,元素3...]
12     * @param arr 需要被遍历的数组
13     */
14     public static void print(int[] arr)
15     {
16         System.out.print("[");
17         for(int i = 0;i < arr.length;i++)
18         {
19             if(i == arr.length-1)
20             {
21                 System.out.print(arr[i]+"]");
22             }
23             else
24                 System.out.print(arr[i]+",");
25         }
26         System.out.println();
27     }
28     /**
29     * 这是获取数组中的最大值的方法
30     * @param arr 需要被遍历的数组
31     * @return 返回数组中的最大值
32     */
33     public static int getMax(int[] arr)
34     {
35         int max = arr[0];
36         for(int i = 1;i < arr.length;i++)
37         {
38             if(arr[i] > max)
39                 max = arr[i];
40         }
41         return max;
42     }
43     /**
44     * 这是获取数组中指定元素第1次出现的位置的方法
45     * @param arr 需要被查找的数组
46     * @param key 需要被查找的元素
47     * @return 返回元素第1次出现的位置，不存在则返回-1
48     */
49     //
50     public static int getIndex(int[] arr,int key)
51     {
52         for(int i = 0;i< arr.length;i++)
53         {
54             if(arr[i] == key)
55                 return i;
56         }
57         return -1;
58     }
59 }

08.04 工具类配合说明书的使用

注意:如果测试类与工具类的class文件不在同一个目录，需要设置classpath路径

08.05 如何使用JDK提供的帮助文档

1:找到文档，打开文档。

2:点击左上角的显示变成隐藏，然后点击索引

3:在输入框里面输入要找的类，然后回车。

4:看这个类的结:如果是java.lang包下的类，是可以直接使用的。否则，就需要导包才能使用。

5:看看这个类的说明以及该类的版本。

6:看这个类的结构(需不需要导包)

类的  成员变量  对应API的  字段摘要

类的  构造方法  对应API的  构造方法摘要

类的  成员方法  对应API的  方法摘要

7:看构造方法

   A:有构造方法，那么，就通过构造方法创建对象使用。

   B:没有构造方法，那么，这个类的成员一般都是静态。通过类名调用。

8:看成员方法

   左边:

      是否静态:如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。

      是否有明确返回值:如果是void类型，就直接调用即可。否则，就可以输出或者赋值。

   右边:

      看方法名:不要写错了。

      看参数:看参数类型及个数。

08.06 通过JDK的帮助文档学习Math类的随机数功能

Math类概述:Math包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

Math类特点:没有构造方法，因为成员都是静态的

Math类的一个方法:获取随机数

public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

例1:System.out.println(Math.random());

运行结果:0.7751943866930362

例2:获取1~100之间的随机数

int num = (int)(Math.random()*100)+1;

System.out.println(num);

运行结果:

86

08.07 猜数字小游戏案例

 1 import java.util.Scanner;
 2 class Demo
 3 {
 4     public static void main(String[] args)
 5     {
 6         int num = (int)(Math.random()*100)+1;
 7         //记录猜的次数
 8         int count = 1;
 9         Scanner sc = new Scanner(System.in);
10         System.out.println("请输入一个数:");
11         int guess = sc.nextInt();
12         while(guess != num)
13         {
14             if(guess > 100 || guess < 1)
15             {
16                 System.out.println("数据只能在1~100之间，请重新输入:");
17                 guess = sc.nextInt();
18             }    
19             else if(guess > num)
20             {
21                 System.out.print("你猜的数"+guess+"大了，");
22                 count++;
23                 System.out.println("进行第"+count+"次猜数:");
24                 guess = sc.nextInt();
25             }
26             else
27             {
28                 System.out.print("你猜的数"+guess+"小了，");
29                 count++;
30                 System.out.println("进行第"+count+"次猜数:");
31                 guess = sc.nextInt();
32             }
33         }
34         System.out.println("恭喜你，猜对了，用了"+count+"次机会");
35     }
36 }

运行结果:

08.08 代码块的概述和分类

代码块:在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程部分)。

局部代码块:在方法中出现；限定变量生命周期，及早释放，提高内存利用率

构造代码块:在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

静态代码块:在类中方法外出现，加了static修饰在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。

例:

 1 class Code
 2 {
 3     static
 4     {
 5         int x = 10;
 6         System.out.println("静态代码块，x="+x);
 7     }
 8     //构造代码块
 9     {
10         int y = 10;
11         System.out.println("构造代码块，y="+y);
12     }
13     //构造方法
14     public Code()
15     {
16         System.out.println("构造方法");
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         new Code();
24         //局部代码块
25         {
26             int z = 20;
27             System.out.println("局部代码块，z="+z);
28         }
29         new Code();
30     }
31 }

运行结果:

静态代码块，x=10
构造代码块，y=10
构造方法
局部代码块，z=20
构造代码块，y=10
构造方法

总结:

执行顺序:静态代码块>构造代码块>构造方法

静态代码块:只执行一次

构造代码块:每次调用构造方法都执行

08.09 代码块看程序写结果

 1 class Student 
 2 {
 3     static 
 4     {
 5         System.out.println("Student 静态代码块");
 6     }
 7     
 8     {
 9         System.out.println("Student 构造代码块");
10     }
11     public Student() 
12     {
13         System.out.println("Student 构造方法");
14     }
15 }
16 class Demo
17 {
18     static 
19     {
20         System.out.println("Demo 静态代码块");
21     }
22     public static void main(String[] args)
23     {
24         System.out.println("main方法");
25         Student s1 = new Student();
26         Student s2 = new Student();
27     }
28 }

运行结果:

Demo 静态代码块
main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

08.10 继承的引入和概述

继承概述:多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

通过extends关键字可以实现类与类的继承:class 子类名 extends 父类名 {} 

单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。

08.11 继承案例和继承的好处

例:

 1 class Person 
 2 {
 3     public void eat()
 4     {
 5         System.out.println("吃饭");
 6     }
 7     public void sleep()
 8     {
 9         System.out.println("睡觉");
10     }
11 }
12 //继承
13 class Student extends Person
14 {
15 
16 }
17 //继承
18 class Teacher extends Person
19 {
20 
21 }
22 class Demo
23 {
24     public static void main(String[] args)
25     {
26         Student s = new Student();
27         s.eat();
28         s.sleep();
29         Teacher t = new Teacher();
30         t.eat();
31         t.sleep();
32     }
33 }

运行结果:

吃饭
睡觉
吃饭
睡觉

继承的好处:

1.提高了代码的复用性，多个类相同的成员可以放到同一个类中

2.提高了代码的维护性，如果功能的代码需要修改，修改一处即可

3.让类与类之间产生了关系，是多态的前提。其实这也是继承的一个弊端:类的耦合性很强

08.12 继承的弊端

设计原则:低耦合高内聚

简单的理解:内聚就是自己完成某件事情的能力。耦合就是类与类之间的关系。

在设计的时候原则是:自己能完成的就不麻烦别人，这样将来别人产生了修改，就对我的影响较小。

08.13 Java中类的继承特点

1.Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。

例:

class SubDemo extends Demo{} //正确

class SubDemo extends Demo1,Demo2...//错误

2.Java支持多层继承(继承体系)

例:

class A{}

class B extends A{}

class C extends B{}

08.14 继承的注意事项和什么时候使用继承

注意事项:

1.子类只能继承父类所有非私有的成员(成员方法和成员变量)，这也体现了继承的另一个弊端:打破了封装性

2.子类不能继承父类的构造方法，但是可以通过super(后面讲解)关键字去访问父类构造方法。

3.不要为了部分功能而去继承

当继承中类与类之间体现的是:”is a”的关系就时候使用继承。例如学生是人的一种

08.15 继承中成员变量的关系

继承中成员变量的关系:

A:子类中的成员变量和父类中的成员变量名称不一样，直接调用即可。

B:子类中的成员变量和父类中的成员变量名称一样时，在子类方法中访问一个变量的查找顺序:

①　在子类方法的局部范围找，有就使用

②　在子类的成员范围找，有就使用

③　在父类的成员范围找，有就使用

④　如果还找不到，就报错

例:

 1 class Fu
 2 {
 3     //父类成员位置
 4     public int num = 10;
 5 }
 6 class Zi extends Fu
 7 {
 8     //子类成员位置
 9     public int num2 = 20;
10     public int num = 30;
11     public void show()
12     {
13         //子类方法局部位置
14         System.out.println(num);
15         System.out.println(num2);
16     }
17 }
18 class Demo
19 {
20     public static void main(String[] args)
21     {
22         Zi z = new Zi();
23         z.show();
24     }
25 }

运行结果:

30
20

08.16 this和super的区别和应用

例:

 1 class Fu
 2 {
 3     public int num = 10;
 4 }
 5 class Zi extends Fu
 6 {
 7     public int num = 20;
 8     public void show()
 9     {
10         int num = 30;
11         //局部范围的num
12         System.out.println(num);
13         //本类成员范围的num
14         System.out.println(this.num);
15         //父类成员范围的num
16         System.out.println(super.num);
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         Zi z = new Zi();
24         z.show();
25     }
26 }

super的用法和this很像，this代表本类对应的引用，super代表父类存储空间的标识(可以理解为父类引用)

用法:

访问成员变量: this.成员变量    super.成员变量

访问构造方法: this(...)       super(...)

访问成员方法: this.成员方法() super.成员方法()

08.17 继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中空参数的构造方法

例:

 1 class Fu
 2 {
 3     Fu()
 4     {
 5         System.out.println("父类无参构造方法");
 6     }
 7     Fu(String name)
 8     {
 9         System.out.println("父类带参构造方法");
10     }
11 }
12 class Zi extends Fu
13 {
14     Zi()
15     {
16         System.out.println("子类无参构造方法");
17     }
18     Zi(String name)
19     {
20         System.out.println("子类带参构造方法");
21     }
22 }
23 class Demo
24 {
25     public static void main(String[] args)
26     {
27         Zi z1 = new Zi();
28         Zi z2 = new Zi("小明");
29     }
30 }

运行结果:

父类无参构造方法
子类无参构造方法
父类无参构造方法
子类带参构造方法

为什么子类中所有的构造方法默认都会访问父类中空参数的构造方法？

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

每一个构造方法的第一条语句默认都是:super()

08.18 继承中构造方法的注意事项

如何父类中没有构造方法，该怎么办呢?

如果父类没有无参的构造方法，那么子类的构造方法将报错

1.子类可以通过super去显示调用父类其他的带参的构造方法

2.子类可以通过this去调用本类的其他构造方法，本类其他构造也必须首先访问了父类构造

注意:super(...)或者this(...)必须出现在第一条语句上

08.19 继承中的面试题1

 1 class Fu
 2 {
 3     public int num = 10;
 4     public Fu()
 5     {
 6         System.out.println("fu");
 7     }
 8 }
 9 class Zi extends Fu
10 {
11     public int num = 20;
12     public Zi()
13     {
14         System.out.println("zi");
15     }
16     public void show()
17     {
18         int num = 30;
19         System.out.println(num);
20         System.out.println(this.num);
21         System.out.println(super.num);
22     }
23 }
24 class Demo
25 {
26     public static void main(String[] args)
27     {
28         Zi z = new Zi();
29         z.show();
30     }
31 }

运行结果:

fu
zi
30
20
10

08.20 继承中的面试题2

1.静态随着类的加载而加载。

2.静态代码块>构造代码块>构造方法

3.只要有子父关系，肯定先初始化父亲的数据，然后初始化子类的数据。

 1 class Fu 
 2 {
 3     static 
 4     {
 5         System.out.println("静态代码块Fu");
 6     }
 7 
 8     {
 9         System.out.println("构造代码块Fu");
10     }
11 
12     public Fu()
13     {
14         System.out.println("构造方法Fu");
15     }
16 }
17 
18 class Zi extends Fu 
19 {
20     static 
21     {
22         System.out.println("静态代码块Zi");
23     }
24 
25     {
26         System.out.println("构造代码块Zi");
27     }
28 
29     public Zi()
30     {
31         System.out.println("构造方法Zi");
32     }
33 }
34 
35 class Demo
36 {
37     public static void main(String[] args)
38     {
39         Zi z = new Zi();
40     }
41 }

运行结果:

静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi

08.21 继承中的面试题3

铺垫知识:

1:成员变量有基本类型和引用类型的

2:类的初始化过程，加载class文件、堆中开辟空间、变量的默认初始化、变量的显示初始化、构造代码块初始化、构造方法初始化

3:类与类有继承关系时，先初始化父类数据，然后初始化子类数据。

 1 class X 
 2 {
 3     Y b = new Y();
 4     X() 
 5     {
 6         System.out.print("X");
 7     }
 8 }
 9 class Y 
10 {
11     Y() 
12     {
13         System.out.print("Y");
14     }
15 }
16 
17 class Demo extends X 
18 {
19     Y y = new Y();
20     Demo() 
21     {
22 　　　　　//super();super在这里仅仅表示要先初始化父类数据
23         System.out.print("Z");
24     }
25     public static void main(String[] args)
26     {
27         new Demo();
28     }
29 }

运行结果:

YXYZ

08.22 继承中成员方法关系

继承中成员方法的关系:

1:子类中的方法和父类中的方法声明不一样，直接调用方法即可。

2:子类中的方法和父类中的方法声明一样，通过子类对象调用方法:

①　先找子类中，看有没有这个方法，有就使用

②　再看父类中，有没有这个方法，有就使用

③　如果没有就报错

例:

 1 class Fu
 2 {
 3     public void show() 
 4     {
 5         System.out.println("fu show run");
 6     }
 7 }
 8 class Zi extends Fu
 9 {
10     public void show() 
11     {
12         System.out.println("zi show run");
13     }
14 }
15 
16 class Demo 
17 {
18     public static void main(String[] args)
19     {
20         Zi z = new Zi();
21         z.show();
22     }
23 }

运行结果:

zi show run

08.23 方法重写的应用

方法重写概述:子类中出现了和父类中方法声明一模一样的方法，也被称为方法覆盖，方法复写。

使用特点:

如果方法名不同，就调用对应的方法

如果方法名相同，最终使用的是子类自己的

方法重写的应用:

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

例:

 1 class Phone
 2 {
 3     public void call(String name) 
 4     {
 5         System.out.println("给"+name+"打电话");
 6     }
 7 }
 8 class NewPhone extends Phone
 9 {
10     public void call(String name) 
11     {
12         //保留父类功能
13         super.call(name);
14         //定义子类特有内容
15         System.out.println("发图片");
16     }
17 }
18 
19 class Demo 
20 {
21     public static void main(String[] args)
22     {
23         NewPhone np = new NewPhone();
24         np.call("小明");
25     }
26 }

运行结果:

给小明打电话
发图片

08.24 方法重写的注意事项

方法重写的注意事项:

1.父类中私有方法不能被重写

2.子类重写父类方法时，访问权限不能更低

3.父类静态方法，子类也必须通过静态方法进行重写

08.25 两个面试题

1.方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写(Override)是指在子类中出现了方法声明与父类一模一样的方法

方法重载(Overload)是指在同一个类中出现的方法名相同，参数列表不同的方法

方法重载能改变返回值类型,因为它和返回值无关

2.this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

super的用法和this很像，this代表本类对应的引用，super代表父类存储空间的标识(可以理解为父类引用)

用法:

访问成员变量: this.成员变量    super.成员变量

访问构造方法: this(...)       super(...)

访问成员方法: this.成员方法() super.成员方法()

08.26 使用继承前的学生和老师案例 

  1 /*
  2     学生案例和老师案例讲解
  3     
  4     学生:
  5         成员变量:姓名，年龄
  6         构造方法:无参，带参
  7         成员方法:getXxx()/setXxx()
  8     老师:
  9         成员变量:姓名，年龄
 10         构造方法:无参，带参
 11         成员方法:getXxx()/setXxx()
 12 */
 13 //定义学生类
 14 class Student 
 15 {
 16     //姓名
 17     private String name;
 18     //年龄
 19     private int age;
 20     
 21     public Student() 
 22     {
 23     }
 24 
 25     public Student(String name,int age) 
 26     {
 27         this.name = name;
 28         this.age = age;
 29     }
 30     
 31     public String getName() 
 32     {
 33         return name;
 34     }
 35     
 36     public void setName(String name) 
 37     {
 38         this.name = name;
 39     }
 40     
 41     public int getAge() 
 42     {
 43         return age;
 44     }
 45     
 46     public void setAge(int age) 
 47     {
 48         this.age = age;
 49     }
 50 }
 51 
 52 //定义老师类
 53 class Teacher 
 54 {
 55     //姓名
 56     private String name;
 57     //年龄
 58     private int age;
 59     
 60     public Teacher() 
 61     {
 62     }
 63 
 64     public Teacher(String name,int age) 
 65     {
 66         this.name = name;
 67         this.age = age;
 68     }
 69     
 70     public String getName() 
 71     {
 72         return name;
 73     }
 74     
 75     public void setName(String name) 
 76     {
 77         this.name = name;
 78     }
 79     
 80     public int getAge() 
 81     {
 82         return age;
 83     }
 84     
 85     public void setAge(int age) 
 86     {
 87         this.age = age;
 88     }
 89 }
 90 class Demo 
 91 {
 92     public static void main(String[] args)
 93     {
 94         //创建学生对象并测试
 95         //方式1
 96         Student s1 = new Student();
 97         s1.setName("旺财");
 98         s1.setAge(5);
 99         System.out.println(s1.getName()+"---"+s1.getAge());
100         
101         //方式2
102         Student s2 = new Student("旺财",5);
103         System.out.println(s2.getName()+"---"+s2.getAge());
104     }
105 }

08.27 使用继承后的学生和老师案例

 1 /*
 2     学生案例和老师案例讲解
 3     
 4     学生:
 5         成员变量:姓名，年龄
 6         构造方法:无参，带参
 7         成员方法:getXxx()/setXxx()
 8     老师:
 9         成员变量:姓名，年龄
10         构造方法:无参，带参
11         成员方法:getXxx()/setXxx()
12     
13     看上面两个类的成员，发现了很多相同的东西，所以我们就考虑抽取一个共性的类:
14     人:
15         成员变量:姓名，年龄
16         构造方法:无参，带参
17         成员方法:getXxx()/setXxx()
18         
19         学生 继承 人
20         老师 继承 人
21 */
22 //定义人类
23 class Person 
24 {
25     //姓名
26     private String name;
27     //年龄
28     private int age;
29     
30     public Person() 
31     {
32     }
33 
34     public Person(String name,int age) 
35     {
36         this.name = name;
37         this.age = age;
38     }
39     
40     public String getName() 
41     {
42         return name;
43     }
44     
45     public void setName(String name) 
46     {
47         this.name = name;
48     }
49     
50     public int getAge() 
51     {
52         return age;
53     }
54     
55     public void setAge(int age) 
56     {
57         this.age = age;
58     }
59 }
60 //定义学生类
61 class Student extends Person
62 {
63     Student()
64     {
65     }
66     Student(String name,int age)
67     {
68         super(name,age);
69     }
70 }
71 //定义老师类
72 class Teacher extends Person
73 {
74     
75 }
76 class Demo 
77 {
78     public static void main(String[] args)
79     {
80         //创建学生对象并测试
81         //方式1
82         Student s1 = new Student();
83         s1.setName("旺财");
84         s1.setAge(5);
85         System.out.println(s1.getName()+"---"+s1.getAge());
86         
87         //方式2
88         Student s2 = new Student("旺财",5);
89         System.out.println(s2.getName()+"---"+s2.getAge());
90     }
91 }

08.28 猫狗案例分析

猫狗案例讲解

   先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。

   猫:

      成员变量:姓名，年龄，颜色

      构造方法:无参，带参

      成员方法:

            getXxx()/setXxx()

            eat()

            palyGame()

   狗:

      成员变量:姓名，年龄，颜色

      构造方法:无参，带参

      成员方法:

            getXxx()/setXxx()

            eat()

            lookDoor()

把共性定义到一个类中，这个类的名字叫:动物。

动物类:

      成员变量:姓名，年龄，颜色

      构造方法:无参，带参

      成员方法:

         getXxx()/setXxx()

         eat()

猫: 

   构造方法:无参，带参

   成员方法:palyGame()

狗:

   构造方法:无参，带参

   成员方法:lookDoor()

08.29 猫狗案例实现及测试 

 1 //定义动物类
 2 class Animal 
 3 {
 4     //姓名
 5     private String name;
 6     //年龄
 7     private int age;
 8     //颜色
 9     private String color;
10     
11     public Animal() {}
12     public Animal(String name,int age,String color) 
13     {
14         this.name = name;
15         this.age = age;
16         this.color = color;
17     }
18     public String getName() 
19     {
20         return name;
21     }
22     public void setName(String name) 
23     {
24         this.name = name;
25     }
26     public int getAge() 
27     {
28         return age;
29     }
30     public void setAge(int age) 
31     {
32         this.age = age;
33     }
34     public String getColor() 
35     {
36         return color;
37     }
38     public void setColor(String color) 
39     {
40         this.color = color;
41     }
42     public void eat() 
43     {
44         System.out.println("吃饭");
45     }
46 }
47 
48 //定义猫类
49 class Cat extends Animal 
50 {
51     public Cat() {}
52     public Cat(String name,int age,String color) 
53     {
54         super(name,age,color);
55     }
56     public void playGame() 
57     {
58         System.out.println("猫玩游戏");
59     }
60 }
61 
62 //定义狗类
63 class Dog extends Animal 
64 {
65     public Dog() {}
66     public Dog(String name,int age,String color) 
67     {
68         super(name,age,color);
69     }
70     public void lookDoor() 
71     {
72         System.out.println("狗看家");
73     }
74 }
75 class Demo 
76 {
77     public static void main(String[] args)
78     {
79         //测试猫
80         //方式1
81         Cat c1 = new Cat();
82         c1.setName("Tom");
83         c1.setAge(3);
84         c1.setColor("黄色");
85         System.out.println("猫的名字是:"+c1.getName()+" 年龄是:"+c1.getAge()+" 颜色是:"+c1.getColor());
86         c1.eat();
87         c1.playGame();
88         System.out.println("---------------");
89         
90         //方式2
91         Cat c2 = new Cat("旺财",5,"黑色");
92         System.out.println("猫的名字是:"+c2.getName()+" 年龄是:"+c2.getAge()+" 颜色是:"+c2.getColor());
93         c2.eat();
94         c2.playGame();
95     }
96 }

运行结果:

猫的名字是:Tom 年龄是:3 颜色是:黄色
吃饭
猫玩游戏
---------------
猫的名字是:旺财年龄是:5 颜色是:黑色
吃饭
猫玩游戏