java 中的子继承

1. 当子类父类存在相同的方法时，优先选择自己的方法，不论父类的引用是否指向子类对象的实例，都选择自己的。若子类无该属性，就继承父类。

2.当子类父类存在相同的属性时，且该属性未作为子类构造函数的参数传入，若父类的引用指向子类对象的实例，输出父类的属性。

3.当子类父类存在相同的属性时，且该属性作为子类构造函数的参数传入，输出子类的属性。

public class Pet { 

    public Pet(String type) { 
        this.type = type;
        }
    public String type="pig";
    public String egg="pitty";
    public String getPetType() { 
        return this.type; 
        }
    public void sleep(){
        System.out.println("pet sleep");
    }
    public static void main(String[] args) {
        Pet dog=new Dog();
        System.out.println(dog.egg);
        System.out.println(dog.type);
        dog.sleep();
        Dog dog2=new Dog();
        dog2.sleep();
        System.out.println(dog2.egg);
        System.out.println(dog2.type);
    }
}
class Dog extends Pet {

    public String egg="doggy";
    public Dog() { 
        super("dog");
        }
    public void sleep(){
        System.out.println("dog sleep");
    }
    }
class Cat extends Pet { 
    public Cat() { 
        super("cat"); 
        } 
    }
result:

pitty
dog
dog sleep
dog sleep
doggy
dog

4.

package algorithm;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author SAMSUNG
 *猫狗队列 【题目】 宠物、狗和猫的类如下：
public class Pet { private String type;
public Pet(String type) { this.type = type; }
public String getPetType() { return this.type; }
}
public class Dog extends Pet { public Dog() { super("dog"); } }
public class Cat extends Pet { public Cat() { super("cat"); } }
实现一种狗猫队列的结构，要求如下： 用户可以调用add方法将cat类或dog类的
实例放入队列中； 用户可以调用pollAll方法，将队列中所有的实例按照进队列
的先后顺序依次弹出； 用户可以调用pollDog方法，将队列中dog类的实例按照
进队列的先后顺序依次弹出； 用户可以调用pollCat方法，将队列中cat类的实
例按照进队列的先后顺序依次弹出； 用户可以调用isEmpty方法，检查队列中是
否还有dog或cat的实例； 用户可以调用isDogEmpty方法，检查队列中是否有dog
类的实例； 用户可以调用isCatEmpty方法，检查队列中是否有cat类的实例。
 */
public class CatAndDogQueue {
    public Queue<PetEnterQueue> dogQueue;
    public Queue<PetEnterQueue> catQueue;
    public int num=0;
    public CatAndDogQueue(){
        this.dogQueue=new LinkedList<PetEnterQueue>();
        this.catQueue=new LinkedList<PetEnterQueue>();
    }
    public void add(Pet pet){
        if(pet.getPetType()=="dog"){
            dogQueue.add(new PetEnterQueue(new Dog(), num+1));
        }
        else{
            catQueue.add(new PetEnterQueue(new Cat(), num+1));
        }
    }
    public Pet pollAll(){
        
        //判空处理
        if(!dogQueue.isEmpty() && !catQueue.isEmpty()){
            if(dogQueue.peek().getCount()>catQueue.peek().getCount()){
                return catQueue.poll().getPet();
            }
            else{
                return dogQueue.poll().getPet();
            }
        }
        else if(!dogQueue.isEmpty()) return dogQueue.poll().getPet();
        else if(!catQueue.isEmpty()){
            return catQueue.poll().getPet();
        }
        else{
            throw new RuntimeException("no pet");
        }
            
        
    }
    
}
class PetEnterQueue{
    /**
     * 重新定义 类  这个类包含动物的类型  及排序；
     */
    public Pet pet;
    public int count;
    PetEnterQueue(Pet pet,int count){
        this.pet=pet;
        this.count=count;
    }
    public String getType(){
        return this.pet.getPetType();
        
    }
    public int getCount() {
        return count;
    }
    public Pet getPet() {
        return pet;
    }
    public void setPet(Pet pet) {
        this.pet = pet;
    }
    
    
}
class Pet { 
    private String type;
    public Pet(String type) { 
        this.type = type;
        }
    public String getPetType() { 
        return this.type; 
        }
}
class Dog extends Pet { 
    public int num;
    public Dog() { 
        super("dog");
        }
    }
class Cat extends Pet { 
    public Cat() { 
        super("cat"); 
        } 
    }