面向对象特征--多态

面向对象特征–多态

同一种事物,在不同时刻表现不同的状态

存在的三个必要条件

要有继承(包括接口的实现)(前提条件)

要有重写(前提条件)

父类引用指向子类对象(当编译期间类型是父类,运行期间类型是子类)

package day5.demo3;
/**
  继承:
     在已有类的基础上,派生出新的类,新类可以拥有父类非私有的属性,方法
     提高代码可重用性,可扩展性

     是一种is-a关系   猫是动物,狗是动物
 Animal  称为  父类/基类
 */
public abstract class Animal {
        int ss=10;
      private String name;
       private  int age;
       public abstract void eat();
     public static void sleep(){
         System.out.println("睡觉");
     }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name ;
     }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package day5.demo3;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
        return;
    }
}

package day5.demo3;

/*
  在Animal的基础上派生出  狗类
       Java中一个类只能直接继承一个父类
 */
public class Dog extends Animal {
       private String type;
        int  ss=5;
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
    public void play(){
        System.out.println("狗会玩");
    }
    public void setType(String type){
           this.type=type;
       }
       public String getType(){
           return type;
       }

}

package day5.demo3;

public class Text {
    /*
      多态:
         同一个事物  在不同时刻表现的不同状态

         前提条件:
            继承    只有继承   父类才可以表示子类
            方法重写   在顶层父类中会定义一些抽象方法(没有方法实现) 只是作一些功能定义
                       子类继承后     重写父类中没有实现的方法

            父类引用指向子类对象
     */
    //编译看左边,运行看右边       针对成员方法
    public static void main(String[] args) {
        Animal dog=new Dog();
               dog.eat();
               //编译运行都看左边     静态方法
               dog.sleep();
        //编译运行都看左边     成员变量
        System.out.println(dog.ss);
        Animal cat=new Cat();
               cat.eat();
    }
}

方法参数具有多态性

特点:提高代码的扩展性

package day5.demo3;

public class Text1 {
    public static void main(String[] args) {
        //方法参数多态性的好处:提高代码的扩展性
        Animal dog=new Dog();
        Animal cat=new Cat();
        Text1 t=new Text1();
        t.feedAnimal(cat);
        t.feedAnimal(dog);
    }
    public void feedAnimal(Animal animal){
        animal.eat();
    }
    //非多态方法
   /*public static void main(String[] args) {
       Dog dog=new Dog();
       Cat cat=new Cat();
       Text1 t=new Text1();
       t.feedCat(cat);
       t.feedDog(dog);}
       public void feedCat(Cat cat){
           cat.eat();
       }
       public void feedDog(Dog dog){
           dog.eat();
       }*/

}

向上转型:

作用:提高程序的扩展性。

向下转型:

作用:为了使用子类中的特有方法。

package day5.demo3;

public class Text2 {
    public static void main(String[] args) {
        Animal animal = new Dog();//向上转型
        //多态问题:  父类类型不能访问子类特有的方法
        //解决办法:  向下转型

        Dog dog=(Dog)animal;// 目的是想要使用子类中的特有的方法
            dog.play();

        String s="sa";
        Object obj=s;    //object中包含String类型的方法
        if(obj instanceof Dog){     //instanceof   大类型   instanceof 小类型  判断俩边对象类型是否相同
            Dog d=(Dog)obj;       //Dog类中没有String类型
        }else {
            System.out.println("不是dog类型");
        }

    }
}

final关键字

用于声明属性,方法和类

属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期都不能修改。

方法:子类里不可被覆盖(重写)。

类:不能被定义为抽象类或是接口,不可被继承。

final属性赋值

在声明时同时赋值,一般与static一起使用

声明时如果不赋值,则必须在构造方法中逐一赋值

总的来说:保证创建每一个对象的时候,final属性的值都是确定的。

package day5.demo4;

/*
  final修饰类,方法,属性

   final 修饰的类不能被其他类继承
public final class  Father {
}
*/
public class Father{
    /*
    * final修饰的属性为常量,值不可改变,将其修饰为static,节省内存空间,所以对象关享一份。
    * */
    final static int NUM=2;//所以对象共享一份
    final int count;//每个对象都有一个常量

    public Father() {
        this.count = 5;
    }
    public void test(){

    }
    /*
    final修饰的方法不能被重写
    public final void test(){

    }*/
    public static void main(String[] args) {

        new Father();
        testFinal(1);
        testFinal(2);
    }
    public static void testFinal(final int a){
        //a=10;
        System.out.println(a);
    }

}
package day5.demo4;

public class Son  extends Father{
    public Son(int count) {
        super();
    }
}

抽象类

类中没有包含足够的信息来描绘一个具体的对象

抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法构造方法的访问方式和普通类一样。

用abstract修饰的类一定是抽象类

如果一个类中包含有抽象方法,那么这个类一定是抽象类

一个类如果是抽象类,它可以没有抽象方法

抽象方法

是一种特殊的方法:它只有声明,而没有具体的实现

必须用abstract关键字进行修饰

package day5.demo5;
/*
 抽象类中有没有未实现功能的方法
    被abstract修饰的类


      如果一个类中有抽象方法(没有实现的方法),那么这个类一定是抽象类
      如果一个类是抽象类  不一定有抽象方法
 */

public abstract class Animal {
    int num;//成员变量
    //构造方法
    public Animal(){

    }
    //抽象方法
    public abstract void eat();

    //成员方法
    public void sleep(){

    }
    //静态方法
    public static void drink(){

    }
}

package day5.demo5;

//public abstract class Dog extends Animal{
/*
     如果一个类继承了抽象类:
          要么重写抽象类中所以抽象方法
          要么将当前类也声明成抽象类

 */
public abstract class Dog extends Animal{

}

抽象类,抽象方法,在软件开发过程中都是设计层面的概念。

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页