class Link{ //一个管理类，负责产生Node类对象 以及 根数据
private Node root;//根节点
private int count=0;//计数
private int foot;//给每个节点一个脚标
private Object[] retArray;//设置一个返回数据类型 这个数据可以同时被外部类和内部类同时访问
public void add(Object data){//关键点：增加对象时，直接将数据(可以换成对象),包装进Node类
Node newNode=new Node(data);
if(this.rootnull){ //如果根节点为空，那么就将对象赋值给根节点
this.root=newNode;
}else{ //如果不为空，那么就交由Node类去匹配引用关系
this.root.addNode(newNode);
}
this.count++;//每次增加一个对象 就计数一次
}
public void print(){ //输出 ： 如果root不为空，那么交由Node类输出
if(this.root!=null){
this.root.printNode();
}
}
public int size(){
return this.count;
}
public boolean contains(Object data){ //查找数据的方法
if(datanull||this.rootnull){ //如果数据和根节点都为空，说明没有要查找的数据 返回 false
return false;
}
return this.root.containsNode(data); //如果不为空，那么就交由Node类去匹配数据
}
public boolean isEmpty(){
if(this.count0||this.rootnull){
System.out.println(“这是个空链表”);
return true;
}else{
System.out.println(“这不是空链表”);
return false;
}
}
public Object get(int index){//根据脚标取得相应数据
if(index>this.count){ //如果脚标大于链表长度，那么就结束方法调用
return null;
}
this.foot=0;//每次查询都从根节点查询
return this.root.getNode(index);//从Node类开始查询
}
//删除分两种情况 ： 1 是根节点 2 非根节点
public void remove(Object data){//如果删除的数据刚好是根节点
if(this.contains(data)){//主要是判断数据是否存在
if(data.equals(this.root.data)){
this.root=this.root.next;
}else {//难点 ：如果删除的不是根节点，那么就要把 删除节点的上一个节点的next指向 删除节点的下一个节点
//所以要传入 上一个节点 和 要查询的数据
this.root.next.removeNode(this.root,data);
//如果不是根节点，那么就要传入
//那么根节点就指向根节点的下一个节点
}
this.count–;
}
}
public void set(int index,Object data){//根据编号设置数据
if(index>this.count){
return ;
}
this.root.setNode(index,data);
}
public Object[] toArray(){ //返回数组的方法
if(this.rootnull){
return null;
}
this.retArray=new Object[this.count];
this.root.toArrayNode();//数据的处理交由Node类去执行
return this.retArray;//返回处理后的数组
}
//内部类======
private class Node{//内部类
private Object data;//Node中所要包装的数据
private Node next;//Node类中对象对下一个对象的关系引用
public Node(Object data){
this.data=data;
}
public Object getData(){
return this.data;
}
public void addNode(Node newNode){//由Node类匹配引用关系
/*重点：第一次调用：this=Link.root;
第二次调用：this=Link.root.next;
第三次调用：this.=Link.root.next;
*/
if(this.nextnull){ //如果 当前节点为空，那么就把数据给当前节点，
this.next=newNode;
}else{ //如果不为空，那么就看下一个节点
this.next.addNode(newNode);
}
}
public void printNode(){
/*重点：第一次调用：this=Link.root;
第二次调用：this=Link.root.next;
第三次调用：this.=Link.root.next;
*/
System.out.println(this.data); //打印当前对象的数据
if(this.next!=null){//如果当前对象的指向不为空，那么就递归继续输出
this.next.printNode();
}
}
public boolean containsNode(Object data){
if(data.equals(this.data)){ //当前节点为要查询的数据
return true; //后面就不再查询了
}else{ //当前节点数据不满足查询要求
if(this.next!=null){ //后续还有节点
return this.next.containsNode(data);
}else{ //没有后续节点
return false; //没得查了
}
}
}
public Object getNode(int index){
if(Link.this.foot++index){//重点，加了Link 表示调用外部类的this，否则表示调用内部类的this
return this.data; //如果脚标与查询相同，那么就返回当前数据
}else {
return this.next.getNode(index);//如果当前节点不是要查询的，那么就继续往下查询
}
}
//此方法专门负责删除非根节点
public void removeNode(Node previous, Object data){ //previous指的是上一个节点
if(data.equals(this.data)){
previous.next=this.next;//如果是删除当前数据，那么就把当前的next 给到自己的上一个节点
}else{
this.next.removeNode(this,data);
}
}
public void setNode(int index,Object data){//交由Node类来设置数据
if(Link.this.foot++index){
this.data=data;
}else{
this.next.setNode(index,data);
}
}
public void toArrayNode(){//由Node类执行数据添加
Link.this.retArray[Link.this.foot++]=this.data; //将数据添加进数组
if(this.next!=null){
this.next.toArrayNode();
}
}
}
//=以上为内部类========
}
interface Pet{ //定义一个宠物类的标准 暂时以姓名 年龄
public abstract String getName();
public abstract int getAge();
}
class Petshop{ //一个宠物商店 有增加宠物 删除宠物 模糊查询等功能
private Link pets=new Link();//要操作Link类 必须要一个实例化对象才能调用Link类的方法
public void add(Pet pet){
this.pets.add(pet);
}
public void delete(Pet pet){
this.pets.remove(pet);
}
public void print(){
this.pets.print();
}
public Link seach(String keyWork){
if(keyWorknull){
return null;
}
Link result=new Link();
Object [] obj=this.pets.toArray();//将链表内容转成数组 然后逐一比较
for(int i=0;i<obj.length;i++){
Pet p=(Pet)obj[i];
if(p.getName().contains(keyWork)){
result.add§;
}
}
return result;
}
}
class Dog implements Pet{
private String name;
private int age;
public Dog(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public String toString(){
return “狗的名字：”+this.name+",狗的岁数："+this.age;
}
public boolean equals(Object obj){
if(thisobj){
return true;
}
if(objnull){
return false;
}
if(! (this instanceof Dog)){
return false;
}
Dog dog=(Dog)obj;
if(this.name.equals(dog.name)&&this.agedog.age){
return true;
}
return false;
}
}
class Cat implements Pet{
private String name;
private int age;
public Cat(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public String toString(){
return “猫的名字：”+this.name+",猫的岁数："+this.age;
}
public boolean equals(Object obj){
if(thisobj){
return true;
}
if(objnull){
return false;
}
if(! (this instanceof Cat)){
return false;
}
Cat cat=(Cat)obj;
if(this.name.equals(cat.name)&&this.agecat.age){
return true;
}
return false;
}
}
class Fish implements Pet{
private String name;
private int age;
public Fish(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public String toString(){
return “鱼的名字：”+this.name+",鱼的岁数："+this.age;
}
public boolean equals(Object obj){
if(thisobj){
return true;
}
if(objnull){
return false;
}
if(! (this instanceof Fish)){
return false;
}
Fish f=(Fish)obj;
if(this.name.equals(f.name)&&this.agef.age){
return true;
}
return false;
}
}
public class Test_petshop{
public static void main(String[] args){
Petshop shop=new Petshop();
shop.add(new Cat(“波斯猫”,8));
shop.add(new Cat(“英短猫”,6));
shop.add(new Cat(“中华田园猫”,15));
shop.add(new Dog(“二狗子”,15));
shop.add(new Dog(“黑狗”,9));
shop.add(new Dog(“斑点狗”,5));
shop.add(new Fish(“金龙”,2));
shop.add(new Fish(“银龙”,5));
shop.add(new Fish(“鹦鹉鱼”,2));
shop.delete(new Dog(“黑狗”,9));
Link all=shop.seach(“猫”);
Object obj[]=all.toArray();
for(int i=0;i<obj.length;i++){
System.out.println(obj[i]);
}
shop.print();
}
}
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
