面向对象3大特性：封装、继承、多态——多态（引用类型转换、抽象类、接口Interface）

多态

对象的多种形象（使用多态时两个类一定要是继承关系，继承是多态实现的基础）

1、引用多态

  父类的引用可以指向本类的对象 Animal obj1=new Animal();

  父类的引用可以指向子类的对象 Animal obj2=new Dog(); 子类不可以指向父类对象

 

public class Initial {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dog dog=new Dog();
        Animal animal=new Animal();
        Animal dog3=new Dog();//父类的引用可以指向子类对象
        //Dog dog4=new Animal(); *错误！子类引用不可以指向父类对象
    }
}

 

2、方法多态

  创建本类对象时，调用的方法为本类的方法

  创建子类对象时，调用的方法为子类重写的方法或是继承的方法（没有重写就用继承的）

tips:

如果不是从父类继承的方法，而是子类独有的，那么父类引用子类的对象是不可以调用该方法的

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal obj=new Dog();//父类的引用可以指向子类对象
        Animal obj3=new Cat();
        obj.eat();//狗是吃肉的
        obj3.eat();//动物具有吃东西的能力
    } 

引用类型转换

1、向上类型转换（隐式/自动类型转换），是小类型到大类型的转换——无风险

2、向下类型转换（强制类型转换），是大类型到小类型的转换——有风险

3、instanceof运算符，用来解决引用对象的类型转换风险，避免类型转换的安全性问题

Dog dog=new Dog();//创建子类对象
        Animal animal=dog;//父类对象指向子类对象,自动类型提升，向上类型转换
        Dog dog2=(Dog)animal;//向下类型转换，强制类型转换
        //向下类型转换，强制类型转换——这个是不行的
        //Cat cat=(Cat)animal;//1.编译时 Cat类型 2.运行时 Dog类型  所以是不行的
        //通过instanceof运算符避免类型转换的安全问题
        if(animal instanceof Cat){//如果animal对象含有Cat
            Cat cat=(Cat)animal;
        }else{
            System.out.println("无法进行类型转换");
        }

抽象类

1、语法定义

抽象类前使用abstract关键字修饰，则该类为抽象类

2、应用场景

a、在某些情况下，某个父类知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模版，从而避免了子类设计的随意性

3、作用

限制规定子类必须实现某些方法，但不关注细节

4、使用规则

a、abstract定义抽象类

b、abstract定义抽象方法，只有声明不需要实现

c、包含抽象类方法的类就是抽象类

d、抽象类中可以包含普通的方法，也可以没有抽象方法

e、抽象类不能直接创建，可以定义引用变量

public abstract class Shape {
    double wide=5.0;
    double length=6.0;
    double radii=5.3;
    double peri;
    double acre;
    //定义计算周长的方法
    public abstract double perimeter();
    //定义计算面积的方法
    public abstract double acreage();
}
public class Rectangle extends Shape {

    @Override
    public double perimeter() {
        // TODO Auto-generated method stub
        return (length+wide)*2;
    }
    @Override
    public double acreage() {
        // TODO Auto-generated method stub
        return length*wide;
    }
}
public class Circle extends Shape {

    @Override
    public double perimeter() {
        // TODO Auto-generated method stub
        return 3.1415*(radii*2);
    }
    @Override
    public double acreage() {
        // TODO Auto-generated method stub
        return 3.1415*(radii*radii);
    }
}
public class Initail {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Shape rect=new Rectangle();
        System.out.println(rect.perimeter());
        System.out.println(rect.acreage());
        Shape cir=new Circle();
        System.out.println(cir.perimeter());
        System.out.println(cir.acreage());
    }
}

 

java中的接口 interface

[访问修饰符] interface 接口名 [extends 父接口1,父接口2 ...] {

0到多个常量的定义...

0到多个抽象方法的定义...

 }

接口就是用来被继承、被实现的，修饰符一般建议用public

注意：不能使用private和protected修饰接口

接口的概念：

接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成

类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定了这些类里必须提供某些方法。

常量：

接口中的属性是常量，即使定义时不添加public static final 修饰符，系统也会自动加上

方法：

接口中的方法只能是抽象方法，即使定义时不添加public static final 修饰符，系统也会自动加上

 

使用接口1：

一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。

继承父类实现接口的语法为：

[访问修饰符]  class 类名 extends 父类 implements 接口1,接口2 ... {

  类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法

} //如果要继承父类，继承父类必须在实现接口之前

public interface IPlayGame {
    public abstract void palyGame();
}
public class Smartphone extends Telphone implements IPlayGame{
    @Override
    public void palyGame() {
        // TODO Auto-generated method stub
        System.out.println("智能具有了玩游戏的功能！");
    }
}
public class Psp implements IPlayGame {

    @Override
    public void palyGame() {
        // TODO Auto-generated method stub
        System.out.println("PSP具有了玩游戏的功能！");
    }
}
public static void main(String[] args) {
        // TODO Auto-generated method stub
        IPlayGame ip1=new Smartphone();//使用接口类指向一个实现了接口方法的对象
        ip1.palyGame();
        IPlayGame ip2=new Psp();
        ip2.palyGame();
    }

使用接口2：

接口在使用过程当中，还经常与匿名内部类配合使用

匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称

语法格式

Interface i=new Interface(){

 public void method(){

 System.out.println(“匿名内部类实现接口的方式”);  } }

 

接口中方法不能有方法体，同时方法的访问修饰符

不能是private和protected

 

public static void main(String[] args) {
        // TODO Auto-generated method stub
        IPlayGame ip1=new Smartphone();//使用接口类指向一个实现了接口方法的对象
        ip1.palyGame();
        IPlayGame ip2=new Psp();
        ip2.palyGame();
        //使用匿名内部类的方式直接new一个接口
        IPlayGame ip3=new IPlayGame(){
            @Override
            public void palyGame(){
                // TODO Auto-generated method stub
                System.out.println("匿名内部类实现接口的方式");
            }
        };//这里需要用一个 ; 结束
        ip3.palyGame();
        //直接new一个接口的引用，在里面实现，然后调用
        new IPlayGame(){
            @Override
            public void palyGame(){
                // TODO Auto-generated method stub
                System.out.println("匿名内部类实现接口的方式");
            }
        }.palyGame();
    }

 

 

 

*** END