[零基础学JAVA]Java SE面向对象部分-19.面向对象高级（07）

上季内容回顾： 代理设计、适配器设计
抽象类和接口的区别 本季主要知识点： 本季以题目讲解为主，详细的讲解了抽象类和接口的实际应用及典型的实例分析。 练习题一 abstract class Employee    
{    
        private String name;    
        private int age;    
        private String sex;    
        public Employee(){}    
        public Employee(String name,int age,String sex)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setSex(sex);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setSex(String sex)    
        {    
                this.sex = sex;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getSex()    
        {    
                return this.sex;    
        }    
        //显示数据    
        public abstract String getInfo();    
}    

class Manager extends Employee    
{    
        //职务    
        private String job;    
        //年薪    
        private float income;    
        public Manager(){}    
        public Manager(String name,int age,String sex,String job,float income)    
        {    
                super(name,age,sex);    
                this.setJob(job);    
                this.setIncome(income);    
        }    
        public void setJob(String job)    
        {    
                this.job = job;    
        }    
        public void setIncome(float income)    
        {    
                this.income = income;    
        }    
        public String getJob()    
        {    
                return this.job;    
        }    
        public float getIncome()    
        {    
                return this.income;    
        }    
        public String getInfo()    
        {    
                return "管理层信息："+"\n"    
                                +"\t|- 姓名： "+super.getName()+"\n"    
                                +"\t|- 年龄： "+super.getAge()+"\n"    
                                +"\t|- 性别： "+super.getSex()+"\n"    
                                +"\t|- 职务： "+this.getJob()+"\n"    
                                +"\t|- 年薪： "+this.getIncome();    
        }    
}    

class Worker extends Employee    
{    
        private String dept;    
        private float salary;    
        public Worker(){}    
        public Worker(String name,int age,String sex,String dept,float salary)    
        {    
                super(name,age,sex);    
                this.setDept(dept);    
                this.setSalary(salary);    
        }    
        public void setDept(String dept)    
        {    
                this.dept = dept;    
        }    
        public void setSalary(float salary)    
        {    
                this.salary = salary;    
        }    
        public String getDept()    
        {    
                return this.dept;    
        }    
        public float getSalary()    
        {    
                return this.salary;    
        }    
        public String getInfo()    
        {    
                return "职员信息："+"\n"    
                                +"\t|- 姓名： "+super.getName()+"\n"    
                                +"\t|- 年龄： "+super.getAge()+"\n"    
                                +"\t|- 性别： "+super.getSex()+"\n"    
                                +"\t|- 部门： "+this.getDept()+"\n"    
                                +"\t|- 月薪： "+this.getSalary();    
        }    
}    
public class Demo01    
{    
        public static void main(String args[])    
        {    
                Employee w = new Worker("张三",30,"男","技术部",5000.0f);    
                Employee m = new Manager("李四",35,"女","经理",10000.0f);    
                System.out.println(w.getInfo());    
                System.out.println(m.getInfo());    
        }    
}
练习题二（重点来咯~~~） 分析：
  只要是宠物则肯定可以向宠物商店中加入
   猫  --> 宠物
   狗  --> 宠物
  宠物商店存放宠物 五种宠物？如果说不是五种，可能是更多种了，那该如何？
  5种宠物 --> 5个接口对象 --> 对象数组 //宠物    
interface Pet    
{    
}    
//宠物商店    
class PetShop    
{    
}    
//小狗    
class Dog implements Pet    
{    
}    
//小猫    
class Cat implements Pet    
{    
}
宠物信息： 
・ 名字 
・ 年龄
・ 颜色
・ 价钱
还应该具备一个返回全部信息的方法。 我们继续看下面哈~ //宠物    
interface Pet    
{    
        //返回宠物的名字    
        public String getName();    
        //返回宠物的年龄    
        public int getAge();    
        //返回宠物的颜色    
        public String getColor();    
        //返回宠物的价钱    
        public float getPrice();    
        //返回宠物的全套信息    
        public String getInfo();    
}    
//宠物商店    
class PetShop    
{    
        //必须有一个对象数组可以保存全部的宠物    
        private Pet p[] = null;    
        //必须定义一个当前已经加到了多少个宠物    
        private int foot = 0;    
        //对象数组的大小，可以由程序运行时动态分配    
        //len表示对象数组的长度    
        public PetShop(int len)    
        {    
                //动态得开辟了对象数组空间    
                this.p = new Pet[len];    
        }    
        //增加宠物    
        //假设说宠物商店里面的宠物已经够多了，那还可以继续增加吗？    
        public boolean add(Pet p)    
        {    
                if (this.foot<this.p.length)    
                {    
                        //还有地方加入宠物    
                        this.p[foot] = p;    
                        //宠物数量增加    
                        this.foot++;    
                        return true;    
                }    
                else    
                {    
                        return false;    
                }    
        }    
        //查找宠物信息的方法    
        public Pet[] search(String keyWord)    
        {    
                //要返回的对象数组    
                Pet pet[] = null;    
                //最后要根据count的内容开辟对象数组pet，把此数组返回    
                int count =0;    
                //pet的大小是否确定呢？    
                //先求出符合关键字的全部宠物信息    
                //循环验证    
                for (int i=0;i<this.p.length ;i++ )    
                {    
                        //判断返回的信息是否有指定的关键字存在    
                        if (this.p[i].getInfo().indexOf(keyWord)!=-1)    
                        {    
                                //如果不等于-1，表示已经找到了    
                                //就表示可以增加一个记录    
                                count++;    
                        }    
                }    
                //经过以上代码之后，肯定count包含了全部已经满足要求的宠物信息个数    
                if (count!=0)    
                {    
                        //已经有内容    
                        pet = new Pet[count];    
                        count = 0;    
                        //还需要重新循环一次    
                        for (int i=0;i<this.p.length;i++)    
                        {    
                                //判断返回的信息是否有指定的关键字存在    
                                if(this.p[i].getInfo().indexOf(keyWord)!=-1)    
                                {    
                                        //如果不等于-1，表示已经查找到了    
                                        //表示向返回的对象数组中加入内容    
                                        pet[count]=this.p[i];    
                                }    
                        }    
                        //表示全部符合要求的对象数组    
                        return pet;    
                }    
                else    
                {    
                        //表示没有查询到内容    
                        return null;    
                }    
        }    
}    
//小狗    
class Dog implements Pet    
{    
        private String name;    
        private int age;    
        private String color;    
        private float price;    
        //加入两个构造方法    
        public Dog(){}    
        public Dog(String name,int age,String color,float price)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setColor(color);    
                this.setPrice(price);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setColor(String color)    
        {    
                this.color = color;    
        }    
        public void setPrice(float price)    
        {    
                this.price = price;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getColor()    
        {    
                return this.color;    
        }    
        public float getPrice()    
        {    
                return this.price;    
        }    
        public String getInfo()    
        {    
                return "狗的信息："+"\n"    
                                +"\t|- 狗的名字： "+this.name+"\n"    
                                +"\t|- 狗的颜色： "+this.color+"\n"    
                                +"\t|- 狗的年龄： "+this.age+"\n"    
                                +"\t|- 狗的价格： "+this.price+"\n";    
        }    
}    
//小猫    
class Cat implements Pet    
{    
        private String name;    
        private int age;    
        private String color;    
        private float price;    
        //加入两个构造方法    
        public Cat(){}    
        public Cat(String name,int age,String color,float price)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setColor(color);    
                this.setPrice(price);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setColor(String color)    
        {    
                this.color = color;    
        }    
        public void setPrice(float price)    
        {    
                this.price = price;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getColor()    
        {    
                return this.color;    
        }    
        public float getPrice()    
        {    
                return this.price;    
        }    
        public String getInfo()    
        {    
                return "猫的信息："+"\n"    
                                +"\t|- 猫的名字： "+this.name+"\n"    
                                +"\t|- 猫的颜色： "+this.color+"\n"    
                                +"\t|- 猫的年龄： "+this.age+"\n"    
                                +"\t|- 猫的价格： "+this.price+"\n";    
        }    
}    
//编写主方法进行测试    
public class Demo02    
{    
        public static void main(String args[])    
        {    
                //指定里面存放宠物的个数    
                PetShop shop = new PetShop(5);    
                //向商店中增加宠物    
                System.out.println(shop.add(new Dog("拉布拉多",3,"黄色",5000.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Cat("黑猫",2,"黑色",500.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Dog("美卡",1,"金色",2000.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Cat("波斯猫",2,"白色",2800.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Dog("哈巴狗",3,"棕色",120.0f))?"添加宠物成功！":"添加宠物失败！");    
                //这个是第六个宠物，已经放不下了，所以就不放了    
                System.out.println(shop.add(new Dog("人造狗",1,"杂色",10.0f))?"添加宠物成功！":"添加宠物失败！");    
                //增加成功之后进行查询    
                //返回的应该是一个对象数组（即接口数组）    
                Pet p[] = shop.search("狗");    
                for (int i=0;i<p.length ;i++ )    
                {    
                        System.out.println(p[i].getInfo());    
                }    
        }    
} 出现空指向错误哈~主要原因在于count的值没有改变，则其他的元素都是null，我们加入count++就可以了哈~ //宠物    
interface Pet    
{    
        //返回宠物的名字    
        public String getName();    
        //返回宠物的年龄    
        public int getAge();    
        //返回宠物的颜色    
        public String getColor();    
        //返回宠物的价钱    
        public float getPrice();    
        //返回宠物的全套信息    
        public String getInfo();    
}    
//宠物商店    
class PetShop    
{    
        //必须有一个对象数组可以保存全部的宠物    
        private Pet p[] = null;    
        //必须定义一个当前已经加到了多少个宠物    
        private int foot = 0;    
        //对象数组的大小，可以由程序运行时动态分配    
        //len表示对象数组的长度    
        public PetShop(int len)    
        {    
                //动态得开辟了对象数组空间    
                this.p = new Pet[len];    
        }    
        //增加宠物    
        //假设说宠物商店里面的宠物已经够多了，那还可以继续增加吗？    
        public boolean add(Pet p)    
        {    
                if (this.foot<this.p.length)    
                {    
                        //还有地方加入宠物    
                        this.p[foot] = p;    
                        //宠物数量增加    
                        this.foot++;    
                        return true;    
                }    
                else    
                {    
                        return false;    
                }    
        }    
        //查找宠物信息的方法    
        public Pet[] search(String keyWord)    
        {    
                //要返回的对象数组    
                Pet pet[] = null;    
                //最后要根据count的内容开辟对象数组pet，把此数组返回    
                int count =0;    
                //pet的大小是否确定呢？    
                //先求出符合关键字的全部宠物信息    
                //循环验证    
                for (int i=0;i<this.p.length ;i++ )    
                {    
                        //判断返回的信息是否有指定的关键字存在    
                        if (this.p[i].getInfo().indexOf(keyWord)!=-1)    
                        {    
                                //如果不等于-1，表示已经找到了    
                                //就表示可以增加一个记录    
                                count++;    
                        }    
                }    
                //经过以上代码之后，肯定count包含了全部已经满足要求的宠物信息个数    
                if (count!=0)    
                {    
                        //已经有内容    
                        pet = new Pet[count];    
                        count = 0;    
                        //还需要重新循环一次    
                        for (int i=0;i<this.p.length;i++)    
                        {    
                                //判断返回的信息是否有指定的关键字存在    
                                if(this.p[i].getInfo().indexOf(keyWord)!=-1)    
                                {    
                                        //如果不等于-1，表示已经查找到了    
                                        //表示向返回的对象数组中加入内容    
                                        pet[count]=this.p[i];    
                                        // count的值没有改变，则其他的元素都是null    
                                        count++;    
                                }    
                        }    
                        //表示全部符合要求的对象数组    
                        return pet;    
                }    
                else    
                {    
                        //表示没有查询到内容    
                        return null;    
                }    
        }    
}    
//小狗    
class Dog implements Pet    
{    
        private String name;    
        private int age;    
        private String color;    
        private float price;    
        //加入两个构造方法    
        public Dog(){}    
        public Dog(String name,int age,String color,float price)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setColor(color);    
                this.setPrice(price);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setColor(String color)    
        {    
                this.color = color;    
        }    
        public void setPrice(float price)    
        {    
                this.price = price;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getColor()    
        {    
                return this.color;    
        }    
        public float getPrice()    
        {    
                return this.price;    
        }    
        public String getInfo()    
        {    
                return "狗的信息："+"\n"    
                                +"\t|- 狗的名字： "+this.name+"\n"    
                                +"\t|- 狗的颜色： "+this.color+"\n"    
                                +"\t|- 狗的年龄： "+this.age+"\n"    
                                +"\t|- 狗的价格： "+this.price+"\n";    
        }    
}    
//小猫    
class Cat implements Pet    
{    
        private String name;    
        private int age;    
        private String color;    
        private float price;    
        //加入两个构造方法    
        public Cat(){}    
        public Cat(String name,int age,String color,float price)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setColor(color);    
                this.setPrice(price);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setColor(String color)    
        {    
                this.color = color;    
        }    
        public void setPrice(float price)    
        {    
                this.price = price;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getColor()    
        {    
                return this.color;    
        }    
        public float getPrice()    
        {    
                return this.price;    
        }    
        public String getInfo()    
        {    
                return "猫的信息："+"\n"    
                                +"\t|- 猫的名字： "+this.name+"\n"    
                                +"\t|- 猫的颜色： "+this.color+"\n"    
                                +"\t|- 猫的年龄： "+this.age+"\n"    
                                +"\t|- 猫的价格： "+this.price+"\n";    
        }    
}    
//编写主方法进行测试    
public class Demo02    
{    
        public static void main(String args[])    
        {    
                //指定里面存放宠物的个数    
                PetShop shop = new PetShop(5);    
                //向商店中增加宠物    
                System.out.println(shop.add(new Dog("拉布拉多",3,"黄色",5000.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Cat("黑猫",2,"黑色",500.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Dog("美卡",1,"金色",2000.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Cat("波斯猫",2,"白色",2800.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Dog("哈巴狗",3,"棕色",120.0f))?"添加宠物成功！":"添加宠物失败！");    
                //这个是第六个宠物，已经放不下了，所以就不放了    
                System.out.println(shop.add(new Dog("人造狗",1,"杂色",10.0f))?"添加宠物成功！":"添加宠物失败！");    
                //增加成功之后进行查询    
                //返回的应该是一个对象数组（即接口数组）    
                Pet p[] = shop.search("狗");    
                for (int i=0;i<p.length ;i++ )    
                {    
                        System.out.println(p[i].getInfo());    
                }    
        }    
} 现在我们就查出了带狗的信息哈~~~ 如果我们要查找带卡的宠物呢？ //宠物    
interface Pet    
{    
        //返回宠物的名字    
        public String getName();    
        //返回宠物的年龄    
        public int getAge();    
        //返回宠物的颜色    
        public String getColor();    
        //返回宠物的价钱    
        public float getPrice();    
        //返回宠物的全套信息    
        public String getInfo();    
}    
//宠物商店    
class PetShop    
{    
        //必须有一个对象数组可以保存全部的宠物    
        private Pet p[] = null;    
        //必须定义一个当前已经加到了多少个宠物    
        private int foot = 0;    
        //对象数组的大小，可以由程序运行时动态分配    
        //len表示对象数组的长度    
        public PetShop(int len)    
        {    
                //动态得开辟了对象数组空间    
                this.p = new Pet[len];    
        }    
        //增加宠物    
        //假设说宠物商店里面的宠物已经够多了，那还可以继续增加吗？    
        public boolean add(Pet p)    
        {    
                if (this.foot<this.p.length)    
                {    
                        //还有地方加入宠物    
                        this.p[foot] = p;    
                        //宠物数量增加    
                        this.foot++;    
                        return true;    
                }    
                else    
                {    
                        return false;    
                }    
        }    
        //查找宠物信息的方法    
        public Pet[] search(String keyWord)    
        {    
                //要返回的对象数组    
                Pet pet[] = null;    
                //最后要根据count的内容开辟对象数组pet，把此数组返回    
                int count =0;    
                //pet的大小是否确定呢？    
                //先求出符合关键字的全部宠物信息    
                //循环验证    
                for (int i=0;i<this.p.length ;i++ )    
                {    
                        //判断返回的信息是否有指定的关键字存在    
                        if (this.p[i].getInfo().indexOf(keyWord)!=-1)    
                        {    
                                //如果不等于-1，表示已经找到了    
                                //就表示可以增加一个记录    
                                count++;    
                        }    
                }    
                //经过以上代码之后，肯定count包含了全部已经满足要求的宠物信息个数    
                if (count!=0)    
                {    
                        //已经有内容    
                        pet = new Pet[count];    
                        count = 0;    
                        //还需要重新循环一次    
                        for (int i=0;i<this.p.length;i++)    
                        {    
                                //判断返回的信息是否有指定的关键字存在    
                                if(this.p[i].getInfo().indexOf(keyWord)!=-1)    
                                {    
                                        //如果不等于-1，表示已经查找到了    
                                        //表示向返回的对象数组中加入内容    
                                        pet[count]=this.p[i];    
                                        // count的值没有改变，则其他的元素都是null    
                                        count++;    
                                }    
                        }    
                        //表示全部符合要求的对象数组    
                        return pet;    
                }    
                else    
                {    
                        //表示没有查询到内容    
                        return null;    
                }    
        }    
}    
//小狗    
class Dog implements Pet    
{    
        private String name;    
        private int age;    
        private String color;    
        private float price;    
        //加入两个构造方法    
        public Dog(){}    
        public Dog(String name,int age,String color,float price)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setColor(color);    
                this.setPrice(price);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setColor(String color)    
        {    
                this.color = color;    
        }    
        public void setPrice(float price)    
        {    
                this.price = price;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getColor()    
        {    
                return this.color;    
        }    
        public float getPrice()    
        {    
                return this.price;    
        }    
        public String getInfo()    
        {    
                return "狗的信息："+"\n"    
                                +"\t|- 狗的名字： "+this.name+"\n"    
                                +"\t|- 狗的颜色： "+this.color+"\n"    
                                +"\t|- 狗的年龄： "+this.age+"\n"    
                                +"\t|- 狗的价格： "+this.price+"\n";    
        }    
}    
//小猫    
class Cat implements Pet    
{    
        private String name;    
        private int age;    
        private String color;    
        private float price;    
        //加入两个构造方法    
        public Cat(){}    
        public Cat(String name,int age,String color,float price)    
        {    
                this.setName(name);    
                this.setAge(age);    
                this.setColor(color);    
                this.setPrice(price);    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public void setColor(String color)    
        {    
                this.color = color;    
        }    
        public void setPrice(float price)    
        {    
                this.price = price;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        public String getColor()    
        {    
                return this.color;    
        }    
        public float getPrice()    
        {    
                return this.price;    
        }    
        public String getInfo()    
        {    
                return "猫的信息："+"\n"    
                                +"\t|- 猫的名字： "+this.name+"\n"    
                                +"\t|- 猫的颜色： "+this.color+"\n"    
                                +"\t|- 猫的年龄： "+this.age+"\n"    
                                +"\t|- 猫的价格： "+this.price+"\n";    
        }    
}    
//编写主方法进行测试    
public class Demo02    
{    
        public static void main(String args[])    
        {    
                //指定里面存放宠物的个数    
                PetShop shop = new PetShop(5);    
                //向商店中增加宠物    
                System.out.println(shop.add(new Dog("拉布拉多",3,"黄色",5000.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Cat("黑猫",2,"黑色",500.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Dog("美卡",1,"金色",2000.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Cat("波斯猫",2,"白色",2800.0f))?"添加宠物成功！":"添加宠物失败！");    
                System.out.println(shop.add(new Dog("哈巴狗",3,"棕色",120.0f))?"添加宠物成功！":"添加宠物失败！");    
                //这个是第六个宠物，已经放不下了，所以就不放了    
                System.out.println(shop.add(new Dog("人造狗",1,"杂色",10.0f))?"添加宠物成功！":"添加宠物失败！");    
                //增加成功之后进行查询    
                //返回的应该是一个对象数组（即接口数组）    
                Pet p[] = shop.search("卡");    
                for (int i=0;i<p.length ;i++ )    
                {    
                        System.out.println(p[i].getInfo());    
                }    
        }    
} 思想总结出来：
  一切就是操作接口，本程序如果可以清楚的掌握，并且可以写出类似的题目，则基本的概念就算具备了。 ###############################################################

本文出自 “王乾De技术博客” 博客，谢绝转载！