抽象类和多态

 抽象类和多态

                   1. 多个子类中拥有相同的方法:将其提取到父类中,再继承即可

                   2. 多个子类的方法 各不相同:各自处理,不要放父类中

                   3. 多个子类的方法 方法标签相同;但方法体不同 :(用抽象方法)

           标签:public void print() {

                                                   ...........

                                                   }

      抽象类: 抽象方法:abstract

                  只写方法标签,不写方法体;并且abstract修饰

                    抽象方法必须包含在抽象类中,

                 抽象类中,并不一定包含抽象方法 抽象类不能实例化 (new X() ),原因:抽象类中可能存在抽象方法,而抽象方法没有方法体

 

 

       final: (不能再改了)

               final修饰的类:不能被继承

              final修饰的方法:不能被重写

              final修饰的变量,属性:不能被修改

     override:重写

     overload:重载

 

       多态:歧义,一个词语 必须根据上下文才有实际的含义

            打:打篮球 打水 打架

           喂:

   Pet pet=new Dog();  // 多态  大范围 =小范围   
  Pet pet=new Penguin();

父类 引用对象名字=new 子类();

               多态:父类引用指向子类对象;引用在栈空间中,子类对象在堆空间中

          步骤 父类 子类,子类重写父类的方法 Dog,eat(){};

                      运行时,父类 引用对象名字=new 子类();

                                Pet pet=new Pet();

                                         pet.feed(dog);

          多态的几种实现方法:歧义

                                  1. 方法重载: publicint add(int num1,int num2){return num1+num2;}

                                                        publicint add(double num1,double num2 ,double num3){return num1+num2+num3;}

                                               add(1,2);(那就是调第一个方法),写了才知道调哪个

                                  2. 方法重写:  class Father{ public void eat(){吃主食.....}

                                                                                                        }

                                                         class Son extends Father { public void eat(){吃水果}

                                                                                                                   }

                                                                  Father father=new Father();

                                                                                   father.eat();

                                3. 使用父类作为方法的形参

                                4. 使用父类作为方法的返回值

 

package pet2.petduotai;

public class Penguin extends Pet
{
   public void eat(){
       System.out.println("吃鱼");
  }
}

 

package pet2.petduotai;

public class Dog extends Pet
{
   public void eat(){
       System.out.println("吃狗粮......");
  }
}
package pet2.petduotai;

public class Cat extends Pet
{
   public void eat()
  {
       System.out.println("吃猫粮....");
  }
}
package pet2.petduotai;
//主人喂食给动物
public class Master
{
   //Pet pet=外界传入的实参
   //用多态写一份就可以了
   public void feed(Pet pet) //pet:dog 父类作为方法的形参 传的是啥就是啥 如果是 cat
  {
       System.out.println("喂宠物"+pet.getName());
       pet.eat(); //dog.eat();         那cat.eat();
  }

   
   //Pet:1:cat 2:dog   3:penguin
   //4.使用父类作为方法的返回值
   public static Pet getPet(int typeId)
  {
       if (typeId==1)
      {
           Cat cat=new Cat();
           return cat;
      }else if (typeId==2)
      {
           Dog dog=new Dog();
           return dog;
      }else {
           Penguin penguin=new Penguin();
           return penguin;
      }
  }

   

   //喂养
//   public void feedDog(Dog dog)
//   {
//       System.out.println("喂狗粮....");
//   //     System.out.println("吃狗粮....");
//       dog.eat();//狗吃狗粮
//   }
//   public void feedPenguin(Penguin penguin)
//   {
//       System.out.println("喂鱼.......");
//       penguin.eat();
//   }
}
package pet2.petduotai;
//父类
public abstract class Pet
{
   private String name;

   public String getName() {
       return name;
  }
   public void setName(String name) {
       this.name = name;
  }

   public abstract void eat();
}
package pet2.petduotai;

public class TestMaster
{
   public static void main(String[] args)
  {
       Master master=new Master();
       Dog  dog=new Dog();
       Penguin penguin=new Penguin();
//       master.feedDog(dog);
//       master.feedPenguin(penguin);
       dog.setName("wc");
       master.feed(dog);
       penguin.setName("qq");
       master.feed(penguin);
  }
}

必须同时出现在父类,子类(重写)

也就是说:父类引用 不能指向子类独有的方法。

多态时:父类和子类之间的转换(跟基本类型一样转换)

对象:instanceof 类型 判断该对象是否该类型的

 
posted @ 2022-09-22 19:52  zjw_rp  阅读(98)  评论(0)    收藏  举报