JavaSE基础语法--接口、多态-12.05

JavaSE基础语法–接口、多态

1.多态

多态

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

多态存在的三个必要条件

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

2.要有重写(前提条件)

3.父类引用指向子类对象

class  Animal{             
}
class Cat  extends Animal{
}
class Dog extends Animal {
}
Animal x = new Cat()  //Animal 的引用指向Cat的对象

多态的成员特点：

成员变量、静态成员方法：编译运行都看左边。

成员方法：编译看左边，运行看右边。

多态的定义与使用格式：

​ 定义格式：父类类型 变量名 =new 子类类型();

多态的转型

​ 多态的转型分为向上转型和向下转型

​ 1.向上转型：多态本身就是向上转型过的过程。

​ 使用格式：父类类型 变量名 = new 子类类型();

​ 适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

class Animal{
   void eat(){ }
}
class Cat extends Animal{
      void play() {
	System.out.println("狗会玩");
	 }
    }      
 ………
   Animal x=new Cat()  //向上造型，Cat对象提升到Animal对象
   x.eat()   //只能使用父类中的方法
   x.play()  //报错！不能使用子类中的方法

​ 作用：提供程序的扩展性

​ 2.向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型。

​ 使用格式：子类类型 变量名 = (子类类型) 父类类型的变量;

​ 适用场景：当要使用子类特有功能时。

class Animal{
      void eat(){ }
}
class Cat extends Animal{
      void catchMouse() {
          System.out.println("猫抓老鼠");
      }
    }      
 ………
Animal x=new Cat()
Cat  m=(Cat)x;  //向下转型
   m.eat() ;
   m.catchMouse();//子父类中的方法都可以使用

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

instanceof关键字

大类型 instanceof 小类型

作用：判断大类型中是否包含具体的小类型。

String s = "abc";
Object obj = s;
if(obj instance Dog){
    Dog.d = (Dog)obj;
}else{
    System.out.println("不包含Dog类型")
}

2.final关键字

范围：用于声明类、属性、方法。

属性：定义就必须赋值，或者在构造方法中赋值，并且后期不能修改(相当于常量)。

方法 ：子类中不可被重写(覆盖)。

类 ：不能被定义为抽象类或是接口，不能被继承。

public class Demo{
    final int a=10;//被final修饰的变量变为常量，值不能改变
    static final int b=3;
   // final int count;
    public Demo(){}

   /* public Demo(int x) {
        count =x;
    }*/

    public final void eat(){}//被final修饰的类不能被子类重写
    public void sleep(){}

    public final void Test(final int c){
        System.out.println(c);
       // c=5;被final修饰方法中的参数的值不能被改变
    }

3.接口

java是单继承的，利用接口来实现多继承，而且接口的好处是只需要声明接口里有什么，不用实现具体的功能，具体的功能是由实现类来实现。

接口时一种与类相似的结构，只包含常量和抽象方法。

格式：

修饰符 interface 接口名{

常量声明

方法签名

}

public interface DemoInterFace1 {
    int SUM=10;//默认被public static final修饰，必须是常量
    void eat();//被public abstruct修饰，没有方法体
    void sleep();
}

接口的特征：

1.接口不可以被实例化。

2.默认public，接口不能声明为private。

3.实现类必须重写接口的所有方法。

4.实现类可以实现多个接口。

5.接口中的变量都是静态变量。

6.extends是继承其他接口，interface是声明接口，implements继承接口。

常作为类型使用。

一个接口可以继承多个接口

public interface Cat extends 接口1，接口2...{}

实现接口：

public class Dog implements DemoInterFace1{//implements使用接口
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗睡觉");
    }
}

测试：

public class TestInterFace {
    public static void main(String[] args) {
        System.out.println(DemoInterFace1.SUM);
        DemoInterFace1 dog=new Dog();
        //接口不能实例化对象(无构造函数)，但可以声明对象的引用(多态性)
        dog.eat();
        dog.sleep();
    }
}

​ 接口与抽象类的区别：

1.抽象类里面与构造方法，而接口不能有构造方法。

2.抽象类中可以有不同成员，而接口中不能有不同变量。

3.抽象方法的抽象方法的访问类型可以是public、protected，默认类型，但是接口的抽象方法的默认为public abstract类型。

4.抽象类中的静态成员变量的访问类型可以任意，但是接口中只能是静态常量。

相同点：都不能用来创建对象。

若有错误，欢迎私信指正。