第十二天（多态内部类 instanceof关键字）

最新推荐文章于 2023-01-14 10:26:38 发布

下雨烨

最新推荐文章于 2023-01-14 10:26:38 发布

阅读量342

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_47154206/article/details/127388494

版权

多态

同一个对象，在不同时刻表现出来的不同形态

举列：猫

我们可以说猫是猫：猫 cat = new 猫();

也可以说猫是动物：动物 animal = new 猫();

这里猫在不同时刻表现出来的不同形态，这就是多态。

多态的前提和体现

有继承/实现关系
有方法重写
有父类引用指向子类对象

多态中成员访问特点

构造方法：同继承一样，子类会通过super访问父类构造方法。

成员变量：编译看左边（父类），运行看左边（父类）

成员方法：编译看左边（父亲），执行看右边（子类）

为什么成员变量和成员方法的访问不一样呢？因为成员方法有重写，而成员变量没有。

public class Test1Polymorpic {
    public static void main(String[] args) {
        Animal a =new Cat();//当前事物是一个动物
        System.out.println(a.num);//10
        a.eat();//猫吃鱼
    }
}
class Animal{
    int num = 10;
    public void eat(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal{
    int num = 20;
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

多态的好处与弊端

好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的任意子类对象
多态的弊端：不能使用子类的特有功能

多态中的转型

向上转型
从子到父
父类引用指向子类对象

向下转型
        从父到子
        父类引用转为子类对象
        Zi z = (Zi)f;

instanceof 关键字

避免强转出现的问题

使用格式：变量名 instanceof 类型

通俗理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果。

if(a instanceof Dog){//判断是否为dog类型
Dog dog = (Dog) a;//向下类型强制转换
dog.watchHome;//调用子类特有的方法
}

内部类

内部类概述

内部类：就是在一个类中定义一个类。举例：在一个A类的内部定义一个B类，B类就被称为内部类范例：

public void Outer{
	public void Inner{
	
	}
}

在类的成员位置：成员内部类
在类的局部位置：局部内部类

成员内部类

格式：
外部类名.内部类名对象名 = new 外部类对象().new 内部类对象()；
例：Outer.Inner i = new Outer().new Inner();

特点：
内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。

public class Test1Lnner {
    public static void main(String[] args) {
        /*
            创建内部类对象格式：
                外部类名.内部类名 对象名 = new 外部类对象（）.new 内部类对象（）；
         */
    Outer.Inner i = new Outer().new Inner();
        System.out.println(i.num);//10
        i.show();//Inner..show
    }
}
class Outer{
  private   int a = 10;
    class Inner{
        int num = 10;
        public void show(){
            System.out.println("Inner..show");
            //内部类访问外部类成员，可以直接访问，包括私有private
            System.out.println(a);//10
        }
    }
    }

成员内部类也属于（成员），即然是成员就可以被一些修饰符修饰。

private
私有成员内部类访问：在自己所在的外部类中创建对象访问。

static
静态成员内部类访问格式：外部类.内部类名对象名 = new 外部类名.内部类名();
静态成员内部类中的静态方法：外部类名.内部类名.方法名();

局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用。该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

public class Innerclass {

    public static void main(String[] args) {
    Outer o = new Outer();
        o.method();
    }
}
class Outer{
    int a=10;
    public void method(){
        int b = 20;
        class Inner{
            public void show(){
                System.out.println("show...");
                System.out.println(a);//10
                System.out.println(b);//20
            }
        }
        Inner i=new Inner();
        i.show();
    }

}

匿名内部类

概述：匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）
前提：需要存在一个接口或类

格式：

new 类名或者接口名（）{ 重写方法； }；

public class Test5 {
    public static void main(String[] args) {
        //匿名内部类的理解：将继承|实现，方法重写，创建对象，放在了 一步进行。
        //解释：实现了Inter接口的，一个实现类对象。
        new  Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类中的show方法");
            }
        }.show();
        
        Inter2 i = new Inter2(){
            @Override
            public void show1() {
            }
            @Override
            public void show2() {
            }
        };
        i.show1();
        i.show2();
    }
}
interface Inter{
    void  show();
}
interface Inter2{
    void show1();
    void show2();
}

内部类使用场景

当方法的形式参数是接口或者抽象类时，可以将匿名内部类作为实际参数进行传递。

public class Test {
    public static void main(String[] args) {
 goSwimming(new Swimming() {
     @Override
     public void swim() {
         System.out.println("帖子我们去游泳吧");
     }
 });
    }
    //使用接口方法
    public static void goSwimming(Swimming swimming){
        swimming.swim();
    }
}
interface Swimming{
    void swim();
}