Java SE 09_Generics

Java SE 9th day

1、本次课程知识点

1、泛型的作用

2、泛型的基本使用

2、具体内容

2.1 泛型的产生

要求设计一个可以表示坐标的类，（X、Y）

但是此坐标可以同时满足以下几种要求：

● x = 10、y = 100

● x = 10.3、y = 50.2

● x = “东经180度”、y = “北纬210度”

问，这样的坐标类该如何设计？

分析：

因为现在的程序中可以接收三种数据类型的数据，所以为了保证程序的正确性，最好使用Object完成，因为Object可以接收任意的引用数据类型：

现在有三种类型的数据：int、float、String，回想自动装箱的操作

● int → Integer → Object

● float → Float → Object

按照以上特点，完成程序：

package org.util;

 

public class Point { // 表示坐标

    private Object x;

    private Object y;

 

    public Object getX() {

       return x;

    }

 

    public void setX(Object x) {

       this.x = x;

    }

 

    public Object getY() {

       return y;

    }

 

    public void setY(Object y) {

       this.y = y;

    }

}

此时，Point类完成了。

此时，设置一个整形数字，那么来观察是否可以操作：

package org.util;

 

public class Math {

    public static void main(String args[]) {

       Point p = new Point();

       p.setX(11); // int →Integer→Object

       p.setY(20); // int →Integer→Object

       int x = (Integer) p.getX();// 取出x坐标

       int y = (Integer) p.getY();// 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

x的坐标是：11

y的坐标是：20

此时，达到了设置整数的目的，那么下面继续完成设置小数的操作。

package org.util;

 

public class Math {

    public static void main(String args[]) {

       Point p = new Point();

       p.setX(11.3f);

       p.setY(20.3f);

       float x = (Float) p.getX();// 取出x坐标

       float y = (Float) p.getY();// 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

x的坐标是：11.3

y的坐标是：20.3

下面继续设置字符串作为x和y的坐标

public class Math02 {

    public static void main(String args[]) {

       Point p = new Point();

       p.setX("东经180度");

       p.setY("北纬220度");

       String x = (String) p.getX(); // 取出x坐标

       String y = (String) p.getY(); // 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

x的坐标是：东经180度

y的坐标是：北纬220度

此时，基本的功能已经实现了，但是此种操作是否存在问题呢？

在此操作之中，可以发现所有的内容都是以Object进行操作的，那么就意味着，可以设置任意的类型，即：X可以是整形，Y可以是字符串。

package org.util;

 

public class Math03 {

    public static void main(String args[]) {

       Point p = new Point();

       p.setX(11);

       p.setY("北纬220度");

       int x = (Integer) p.getX();// 取出x坐标

       int y = (Integer) p.getY();// 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

此时程序在编译的时候没有任何的问题，但是在执行的时候出现了以下的错误提示：

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer

    at org.util.Math03.main(Math03.java:9)

之所以会这样，因为在程序中的所有的属性都可以向Object进行转换，那么此时程序的入口就显得不那么规范了，而且存在安全的漏洞。

但是，从之前所学习过的全部代码来讲，此处只能应用到这里了，没有更好的方法了。

2.2 JDK 1.5新特性 —— 泛型

JDK 1.5之后出现了新的技术 —— 泛型，此技术的最大特点是在类中的属性的类型可以由外部决定。

泛型类定义格式：

[访问权限] class类名称<泛型类型1，泛型类型2，……泛型类型n>{

       [访问权限] 泛型类型标识 变量名称；

       [访问权限] 泛型类型标识 方法名称（）{}

       [访问权限] 返回值类型声明 方法名称（泛型类型标识 变量名称）{}

}

泛型对象定义：

类名称<具体类>对象名称 = new 类名称<具体类>();

注意：在泛型的指定中是无法指定基本数据类型的，必须设置成一个类，这样在设置一个数字的时候就必须使用包装类。

那么使用如上的操作格式来修改之前的操作类。

package genericsdemo;

 

public class Point<T> { // 表示坐标

    private T x;

    private T y;

 

    public T getX() {

       return x;

    }

 

    public void setX(T x) {

       this.x = x;

    }

 

    public T getY() {

       return y;

    }

 

    public void setY(T y) {

       this.y = y;

    }

}

此时，程序中加入泛型操作之后，可以发现一切的操作类型此时都不再由程序固定设置，而是由实例化对象的时候在外部进行了指定。

package genericsdemo;

 

public class Math {

    public static void main(String args[]) {

       Point<Integer> p = new Point<Integer>();

       p.setX(11);

       p.setY(20);

       float x = p.getX();// 取出x坐标

       float y = p.getY();// 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

x的坐标是：11.0

y的坐标是：20.0

发现此时在使用Point类的时候，需要加入一个属性类型的声明，而且加入之后再取出属性的时候本身也变得非常容易，不用再使用向下转型了。

而且，使用上面的操作有一点最方便之处，如果此时设置的内容不是整形，那么程序中将出现错误。

package genericsdemo;

 

public class Math {

    public static void main(String args[]) {

       Point<Integer> p = new Point<Integer>();

       p.setX(11);

        p.setY("北纬220度");// 错误，不能设置String类型

       float x = p.getX();// 取出x坐标

       float y = p.getY();// 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

加入泛型之后，可以对程序的操作起到更加安全的目的。

2.3 泛型的其他注意点

在使用泛型操作的时候，实际上有很多小的注意点，例如：构造方法上依然可以使用泛型或者有一种称为泛型的擦除。

2.3.1 在构造方法上应用泛型

一般开发中，经常使用构造方法设置属性的内容。那么此时实际上构造方法上依然可以使用泛型的类型。

格式：

[访问权限] 构造方法 ( [<泛型类型参数名称>] ){}

范例：

package genericsdemo;

 

public class Point<T> { // 表示坐标

    private T x;

    private T y;

 

    public Point(T x, T y) {

       this.setX(x);

       this.setY(y);

    }

 

    public T getX() {

       return x;

    }

 

    public void setX(T x) {

       this.x = x;

    }

 

    public T getY() {

       return y;

    }

 

    public void setY(T y) {

       this.y = y;

    }

}

那么此时在调用的时候就需要使用构造方法设置内容，当然，设置的内容本身依然由泛型指定。

package genericsdemo;

 

public class Math {

    public static void main(String args[]) {

       Point<Integer> p = new Point<Integer>(10, 20);

       int x = p.getX(); // 取出x坐标

       int y = p.getY(); // 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

x的坐标是：10

y的坐标是：20

2.3.2 擦除泛型

如果在使用的时候没有指定泛型的话，则表示擦除泛型。

泛型一旦擦除后，将按照Object进行接收，以保证程序不出现任何错误。

package genericsdemo;

 

public class Math {

    public static void main(String args[]) {

       Point p = new Point(10, 20);

       int x = (Integer) p.getX(); // 取出x坐标

       int y = (Integer) p.getY(); // 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

但是在以上的操作代码中依然会存在警告信息，那么该如何去掉警告信息呢？

package genericsdemo;

 

public class Math {

    public static void main(String args[]) {

       Point<Object> p = new Point<Object>(10, 20);

       int x = (Integer) p.getX();// 取出x坐标

       int y = (Integer) p.getY();// 取出y坐标

       System.out.println("x的坐标是：" + x);

       System.out.println("y的坐标是：" + y);

    }

}

但是，以上的操作虽然去掉了警告信息，但是没有意义。

不指定泛型流程图：

2.4 通配符

在泛型中通配符使用较多，而且在日后的系统类库中有很多的地方都要使用这些操作

例如：现在有如下的操作代码

package genericsdemo03;

public class Test {

    public static void main(String[] args) {

       Object obj = "Hello";

    }

}

以上的语法实际上是表示进行了向上的转型操作，因为String是Object的子类，但是现在在泛型中却没有此概念。

2.4.1 ？

在进行对象转换的时候可以使用自动的向上转型，但是在使用泛型的时候却没有此种操作。

package genericsdemo03;

public class Point<T> { // 表示坐标

    private T x;

    private T y;

 

    public T getX() {

       return x;

    }

    public void setX(T x) {

       this.x = x;

    }

 

    public T getY() {

       return y;

    }

    public void setY(T y) {

       this.y = y;

    }

}

那么下面定义两个Point类的对象。

package genericsdemo03;

 

public class Math {

    public static void main(String args[]) {

       Point<Object> p1 = new Point<Object>();

       Point<Integer> p2 = new Point<Integer>();

       p1 = p2; //此时无法转型

    }

}

D:\javatest>javac Math.java

Math.java:28: 错误: 不兼容的类型

                p1 = p2; // 此时无法转型

                     ^

  需要: Point<Object>

  找到:    Point<Integer>

1 个错误

此时的程序发现，根本就无法进行转换操作。

引用传递时同样存在以上无法转换问题，如下，对主方法进行修改。

范例：泛型类中使用引用传递

public class Math {

    public static void main(String args[]) {

        Point<Integer> p = new Point<Integer>();

        fun(p);

    }

 

    public static void fun(Point<Object> temp) {//如果去掉<Object>则程序可正常运行

        System.out.println("内容：" + temp);

    }

}

D:\javatest>javac Math.java

Math.java:27: 错误: 无法将类 Math中的方法 fun应用到给定类型;

                fun(p);

                ^

  需要: Point<Object>

  找到: Point<Integer>

  原因: 无法通过方法调用转换将实际参数Point<Integer>转换为Point<Object>

1 个错误

此时的程序实际上已经不完全属于对象的转型操作了，属于一个大的类型和小的类型的划分。

例如：将“Point<Object> p1 = new Point<Object>();”表示为整个商场的全部商品，而“Point<Integer> p2 =new Point<Integer>();”表示每一个顾客购买的商品。如果现在执行“p1 = p2;”那么就意味着，本顾客所购买的商品就是商场中的全部商品。这样肯定说不通，所以不能接收。

不能使用以上的方式接收最大的影响在于方法的参数接收上。

package genericsdemo03;

public class Math {

    public static void main(String args[]) {

       Point<Object> p1 = new Point<Object>();

       Point<Integer> p2 = new Point<Integer>();

       fun(p1);

       fun(p2);

    }

 

    public static void fun(Point<?> po) {// 表示此时可以接收任意的类型

       System.out.println(po.getX());

       System.out.println(po.getY());

    }

}

null

null

null

null

程序中的“？”表示可以接收任意的泛型类型，但是只是接收输出，并不能修改。

2.4.2 泛型上限

上限就指一个的操作泛型最大的操作父类，例如，现在最大的上限设置成“Number”类型，那么此时，所能够接收到的类型只能是Number及其子类（如Integer）。

泛型上限设置格式：

声明对象：

类名称<？ extends类>对象名称

定义类：

[访问权限]类名称<泛型标识 extends类>{}

范例：在Point类中只能设置数字的坐标

package genericsdemo03;

public class Point<T extends Number> {// 表示坐标,最高只能是Number

    private T x;

    private T y;

 

    public T getX() {

       return x;

    }

 

    public void setX(T x) {

       this.x = x;

    }

 

    public T getY() {

       return y;

    }

 

    public void setY(T y) {

       this.y = y;

    }

}

以上的泛型类型明确的指出，最大的操作父类是Number，能设置的内容只能是其子类Integer、Float等等。

package genericsdemo03;

public class Math {

    public static void main(String args[]) {

       Point<Integer> p1 = new Point<Integer>();// 设置的是Number的子类

    }

}

如果此时设置了泛型是字符串的话，则会出现错误。

而且，使用泛型的上限也可以在方法上使用，例如：接收参数。

范例：传递中声明对象

class Point<T> {// 此处不设置上限，由方法设置

……

}

 

public class Math {

    public static void main(String args[]) {

       Point<Integer> p2 = new Point<Integer>();

       fun(p2);

    }

 

    public static void fun(Point<?extends Number> po) {// 表示此时可以接收Number的子类

       System.out.println(po.getX());

       System.out.println(po.getY());

    }

}

null

null

当然，也可以用于直接声明对象：

class Point<T> {// 此处不设置上限，由方法设置

……

}

 

public class Math {

    public static void main(String args[]) {

       Point<? extends Number>p = null;

       p = new Point<Integer>();

    }

}

2.4.3 泛型下限

泛型下限指的是只能设置其具体的类或者父类。

泛型下限设置格式：

声明对象：

类名称<？ super类>对象名称

定义类：

[访问权限]类名称<泛型标识 extends类>{}

注意：以上的定义类存在问题，待考究！！！

范例：定义一个方法，此方法只能接收String或Object类型的泛型对象。

package genericsdemo03;

public class Point<T> {

    private T x;

    private T y;

 

    public T getX() {

       return x;

    }

 

    public void setX(T x) {

       this.x = x;

    }

 

    public T getY() {

       return y;

    }

 

    public void setY(T y) {

       this.y = y;

    }

}

在方法中设置泛型的下限：

package genericsdemo03;

public class Math {

    public static void main(String args[]) {

       Point<String> p1 = new Point<String>();

       Point<Object> p2 = new Point<Object>();

       fun(p1);

       fun(p2);

    }

    public static void fun(Point<?super String> po) {

       System.out.println(po.getX());

       System.out.println(po.getY());

    }

}

2.5 泛型接口

泛型不光可以在类上使用，还可以在接口中进行定义。操作的语法如下：

Interface 接口名称<泛型类型，泛型类型，……>（）

范例：定义泛型接口

package genericsdemo04;

 

public interface Demo<T> { // 定义泛型接口

    public void print(T param); // 此抽象方法中使用了泛型类型

}

泛型接口定义完成之后，下面就需要定义子类实现此接口，实现的方法有两种。

范例：第一种实现手段（在子类的定义上声明泛型类型）

package genericsdemo04;

 

public class DemoImp<T> implements Demo<T> {

    public void print(T param) {

       System.out.println("param = " + param);

    }

}

下面对以上的程序进行测试：

package genericsdemo04;

 

public class Test {

    public static void main(String args[]) {

       Demo<String> demo = new DemoImp<String>();

       demo.print("hello");

    }

}

param = hello

范例：第二种实现手段（直接在接口中指定具体类型）

package genericsdemo04;

public class DemoImp2 implements Demo<DemoImp2> {

    public void print(DemoImp2 param) {

       System.out.println("param = " + param);

    }

}

此时print（）方法中只能接收DemoImp2对象实例。

package genericsdemo04;

public class Test {

    public static void main(String args[]) {

       Demo demo = new DemoImp2();

       demo.print(new DemoImp2());

    }

}

param = genericsdemo04.DemoImp2@1ff61bcf

2.6 泛型方法

泛型除了在类中定义之外，还可以在方法上定义，而且在方法上使用泛型，此方法所在的类不一定是泛型的操作类。

泛型方法的简单定义：

[访问权限] <泛型标识>泛型标识 方法名称([泛型标识 参数名称])

范例：定义一个泛型方法

package genericsdemo05;

public class Demo {

    public <T> T print(T param) { // 定义泛型方法

       return param;

    }

}

Demo类中的print（）方法里面接收泛型的类型，而且此方法的返回值也是指定的泛型类型。下面使用以上的类型操作。

package genericsdemo05;

public class Test {

    public static void main(String[] args) {

       Demo d = new Demo();

       System.out.println(d.print(1));// 如果输入1表示类型是Integer

    }

}

1

当然，也可以将此方法的返回值定义成一个泛型的数组。

范例：泛型数组的应用（重要）

publicclass Math {

    public static void main(String args[]) {

       Integer i[] = fun(1, 2, 3, 4, 5);//注意此处同样不能使用基本数据类型，如int

       String j[] = { "A", "B", "C", "D" };

       Object k[] = fun(1, 0.1, 'a', "Hello", true);// 接收各种数据类型

       print(i);

       print(fun(j));

       print(fun(k));

       System.out.println("主方法输出：");

       for (Integer t : i) {// 此处可以为比i大的操作父类，如Number、Object

           System.out.print(t + "、");

       }

       System.out.println();

       for (String t : j) {// 此处可该为Object

           System.out.print(t + "、");

       }

       System.out.println();

       for (Object t : k) {// 此处只能是Object

           System.out.print(t + "、");

       }

    }

 

    public static <T> T[] fun(T... param) {// 接收可变数组,此处不能写出

                                       //(Tparam[]),否则不能接收数组i和k

       return param;

    }

 

    public static <T> void print(T param[]) {// 此处也可以写成(T...param)

       for (T x : param) {// 注意与主方法输出做比较，此处只能为T

           System.out.print(x + "、");

       }

       System.out.println();

    }

}

1、2、3、4、5、

A、B、C、D、

1、0.1、a、Hello、true、

主方法输出：

1、2、3、4、5、

A、B、C、D、

1、0.1、a、Hello、true、

2.7 泛型的嵌套的设置

现在只是突出语法，具体的操作意义需要等待后面的类库之中才能够更加明白。

package genericsdemo06;

public class Info<T> {

    private T param;

 

    public T getParam() {

       return param;

    }

 

    public void setParam(T param) {

       this.param = param;

    }

}

之后定义一个Person类型。

package genericsdemo06;

public class Person<T> {

    private T info;

 

    public T getInfo() {

       return info;

    }

 

    public void setInfo(T info) {

       this.info = info;

    }

}

此时如果要将Info的类型设置到Person之中，那么同时即要指定Person的泛型类型，又要指定Info中的泛型类型。

package genericsdemo06;

public class Test {

    public static void main(String[] args) {

       Person<Info<String>> per = new Person<Info<String>>();

       per.setInfo(new Info<String>());

       per.getInfo().setParam("MLDN.java");

       System.out.println(per.getInfo().getParam());

    }

}

MLDN.java

以上的操作在后面将会有所应用。

2.8 泛型的操作范例

现在有如下的题目要求：

要求设计一个程序，定义一个Person类，Person类中要存放具体的信息，但是信息分为基本信息或联系方式等等，那么此时该如何设计呢？

此时最好的设计是需要定义一个表示信息的操作标准。但是此时这个标准肯定使用接口实现，但是现在在接口并不编写任何的操作。

范例：定义标识接口——信息

package genericsdemo07;

public interface Info {

}

接口没有任何的操作代码，所以，此种接口在设计上称为标识接口，表示一种能力。

之后定义Person类，Person类中的信息只能由Info的子类决定，所以此时指定了上限。

范例：定义Person类

package genericsdemo07;

class Person<T extends Info> {// 此处指定了上限，必须是Info接口的子类

    private T info; // 此变量的类型由外部决定

 

    public Person() {

 

    }

 

    public Person(T info) {

       setInfo(info);

    }

 

    public T getInfo() {

       return info;

    }

 

    public void setInfo(T info) {

       this.info = info;

    }

 

    public String toString() {// 覆写Object类中的toString()方法

       return this.info.toString();

    }

}

以上的操作中，能设置的内容只能是Info的子类。

范例：定义第一个表示信息的类——个人基本信息，此类实现接口

package genericsdemo07;

public class Basic implements Info {

    private String name;

    private int age;

 

    public Basic() {

       super();

    }

 

    public Basic(String name,int age) {

       super();

       this.name = name;

       this.age = age;

    }

 

    public String getName() {

       return name;

    }

 

    public void setName(String name) {

       this.name = name;

    }

 

    public int getAge() {

       return age;

    }

 

    public void setAge(int age) {

       this.age = age;

    }

 

    public String toString() {

       return "人的信息：\n" +

                "\t|- 姓名：" +this.getName() + "\n" +

                "\t|- 年龄："+this.getAge();

    }

}

以上只是基本信息，但是在人中还有联系方式的子类。

范例：定义第二个表示信息的类——联系方式，此类实现接口

package genericsdemo07;

public class Contact implements Info {

    private String address;

    private String zipcode;

 

    public Contact() {

       super();

    }

 

    public Contact(String address, String zipcode) {

       super();

       this.address = address;

       this.zipcode = zipcode;

    }

 

    public String getAddress() {

       return address;

    }

 

    public void setAddress(String address) {

       this.address = address;

    }

 

    public String getZipcode() {

       return zipcode;

    }

 

    public void setZipcode(String zipcode) {

       this.zipcode = zipcode;

    }

 

    public String toString(){

       return "地址信息:\n"+

              "\t|- 地址："+this.getAddress()+ "\n" +

              "\t|- 邮编："+this.getZipcode();

    }

}

范例：设置测试类

public class Math {

    public static void main(String[] args) {

       // 将Basic类型设置为泛型类型，声明并实例化Person对象

       Person<Basic> per = new Person<Basic>();

       // 实例化Basic匿名对象，并将其对象同serInfo()方法传入Person对象中

       per.setInfo(new Basic("张三", 30));

       // 通过调用Person类中的getInfo()方法取得信息并输出

       System.out.println(per.getInfo());

      

       // 实例化Person对象，同时设置info属性的信息

       Person<Contact> perc = new Person<Contact>(new Contact("高州","525200"));

       // 通过调用toString()方法直接输出

       System.out.println(perc);

    }

}

人的信息：

    |- 姓名：张三

    |- 年龄：30

地址信息:

    |- 地址：高州

    |- 邮编：525200

以上的Person中的信息属性只能是Info的子类，从而保证了操作的正确性。

注意：比较以上两种实例化对象的方法，以及输出方法。

3、总结

1、本章只是阐述了泛型的基本操作及基本语法。

2、可以通过“?”、“？ extends 类”、“? super 类”指定泛型的操作界限

3、泛型如果没有设置的话，则将会进行擦除，擦除之后按照Object进行接收

4、泛型可以在接口上设置，指定泛型接口的子类需要明确的给出操作类型

4、作业 —— 宠物商店

实现一个宠物店，一个宠物商店中存在多种宠物。

定义宠物标准：Pet

package org.petshopdemo;

public interface Pet { // 如果有需要则 扩展此处接口即可

    public String getName();// 得到宠物的名字

 

    public int getAge(); // 得到宠物的年龄

 

    public float getPrice(); // 得到宠物的价格

}

宠物标准定义完成之后，下一步最关心的是宠物商店。

一个宠物商店要包含多种宠物。

定义宠物商店：PetShop

package org.petshopdemo;

public class PetShop {

    private Pet pets[]; // 表示有多个宠物

    private int foot; // 定义脚标

 

    public Petshop(int len) {// 宠物的个数可以通过外部指定

        if (len > 0) { // 判断输入的个数长度是否大于0

            this.pets =new Pet[len];

        } else {

            this.pets =new Pet[1];//至少保留一个宠物

        }

    }

 

    public boolean add(Pet pet) {// 增加宠物，返回是否增加成功的信息

        if (this.foot <this.pets.length) {// 可以增加宠物

            this.pets[this.foot] = pet;// 保存宠物

            this.foot++;// 修改脚标

            return true; // 增加成功

        } else {

            return false; // 增加失败

        }

    }

 

    // 因为查询的时候可能返回多个内容，所以还应该以数组的形式表示

    public Pet[] search(String keyWord) {// 根据关键字查询

        Pet[] result = null;//声明数组，但是，大小不指定

        int count = 0; // 记录有多少中宠物符合信息

        for (int i = 0; i <this.pets.length; i++) {

            if (this.pets[i] !=null) { // 表示有宠物信息

                if (this.pets[i].getName().indexOf(keyWord) != -1) {//查询到结果

                    count++; // 修改查询个数

                }

            }

        }

        result = new Pet[count];// 根据查找的个数开辟数组空间

        count = 0;

        for (int i = 0; i <this.pets.length; i++) {

            if (this.pets[i] !=null) { // 表示有宠物信息

                if (this.pets[i].getName().indexOf(keyWord) != -1) {//查询到结果

                    result[count] = this.pets[i];// 返回查询的内容

                    count++; // 修改查询个数

                }

            }

        }

        return result;

    }

}

定义宠物猫：

package org.petshopdemo;

public class Cat implements Pet {

    private String name;

    private int age;

    private float price;

 

    public Cat(String name,int age, float price) {

        super();

        this.name = name;

        this.age = age;

        this.price = price;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public int getAge() {

        return age;

    }

 

    public void setAge(int age) {

        this.age = age;

    }

 

    public float getPrice() {

        return price;

    }

 

    public void setPrice(float price) {

        this.price = price;

    }

 

    public String toString() {

        return "宠物猫的名字：" + this.name +"，年龄：" + this.age +"，价格：" + this.price;

    }

}

定义宠物狗：

package org.petshopdemo;

public class Dog implements Pet {

    private String name;

    private int age;

    private float price;

 

    public Dog(String name,int age, float price) {

        super();

        this.name = name;

        this.age = age;

        this.price = price;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public int getAge() {

        return age;

    }

 

    public void setAge(int age) {

        this.age = age;

    }

 

    public float getPrice() {

        return price;

    }

 

    public void setPrice(float price) {

        this.price = price;

    }

 

    public String toString() {

        return "宠物狗的名字：" + this.name +"，年龄：" + this.age +"，价格：" + this.price;

    }

}

建立测试类，测试类之间的关系。

package org.petshopdemo;

public class TestPetShop {

    public static void main(String[] args) {

       Petshop shop = new Petshop(5);// 定义能存放5个宠物的商店

       shop.add(new Cat("黑猫", 3, 89.4f));// 增加宠物,成功

       shop.add(new Cat("白猫", 2, 19.4f));// 增加宠物,成功

       shop.add(new Cat("花猫", 3, 89.4f));// 增加宠物,成功

       shop.add(new Dog("白狗", 3, 89.4f));// 增加宠物,成功

       shop.add(new Dog("黑狗", 3, 89.4f));// 增加宠物,成功

       shop.add(new Dog("猪狗", 3, 89.4f));// 增加宠物,失败

       Pet p[] = shop.search("白");

       for (int x = 0; x < p.length; x++) {

           System.out.println(p[x]);

       }

    }

}

实际上从开发中此种模式也是经常使用到的。所以一定要理解其代码的意义，使用接口进行解耦合操作。所有类之间的关联使用接口完成，使程序具有更大的灵活性。