抽象方法、final关键字、内部类

最新推荐文章于 2023-12-16 16:29:51 发布

weixin_44987227

最新推荐文章于 2023-12-16 16:29:51 发布

阅读量226

点赞数

分类专栏： java面向对象

本文链接：https://blog.csdn.net/weixin_44987227/article/details/114106067

版权

java面向对象专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、抽象方法

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类

二、final关键字

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。 final： 不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

2.1 修饰变量

2.1.1 局部变量——基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。

public class FinalDemo1 {

    public static void main(String[] args) {

    // 声明变量，使用final修饰
    final int a;

    // 第一次赋值
    a = 10;

    // 第二次赋值
    a = 20; // 报错,不可重新赋值

    // 声明变量，直接赋值，使用final修饰
    final int b = 10;

    // 第二次赋值
    b = 20; // 报错,不可重新赋值

   }

}

2.1.2 局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改

public class FinalDemo2 {

    public static void main(String[] args) {

    // 创建 User 对象
    final User u = new User();

    // 创建另一个 User对象
    u = new User(); // 报错，指向了新的对象，地址值改变。

    // 调用setName方法
    u.setName("张三"); // 可以修改

    }

}

2.1.3 成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

显示初始化：

public class User {

    final String USERNAME = "张三";
    private int age;

}

构造方法初始化：

public class User {

    final String USERNAME ;

    private int age;

    public User(String username, int age) {

        this.USERNAME = username;
        this.age = age;

    }

}

三、内部类

3.1 什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

3.2 成员内部类

定义在类中方法外的类。

定义格式：

class 外部类 {
     class 内部类{
     }
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。代码举例：

class Car { //外部类
    class Engine { //内部类
    }
}

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

创建内部类对象格式：

外部类名.内部类名对象名 = new 外部类型().new 内部类型()；

访问演示，代码如下：定义类：

public class Person {
    private boolean live = true;
    class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                System.out.println("心脏不跳了");
           }
        }
    }


    public boolean isLive() {
        return live;
    }


    public void setLive(boolean live) {
        this.live = live;
    }
}

定义测试类：

public class InnerDemo {

    public static void main(String[] args) {
        // 创建外部类对象
        Person p = new Person();
       // 创建内部类对象
       Heart heart = p.new Heart();
       // 调用内部类方法
       heart.jump();
       // 调用外部类方法
       p.setLive(false);
       // 调用内部类方法
       heart.jump();
   }
}

输出结果:
心脏在跳动
心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。比如，Person$Heart.class

3.3 匿名内部类

匿名内部类：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

定义子类
重写接口中的方法
创建子类对象
调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提匿名内部类必须继承一个父类或者实现一个父接口。格式

new 父类名或者接口名(){
     // 方法重写
    @Override
    public void method() {
    // 执行语句
    }
};

使用方式

以接口为例，匿名内部类的使用，代码如下：定义接口：

public abstract class FlyAble{
    public abstract void fly();
}

创建匿名内部类，并调用：

public class InnerDemo {
    public static void main(String[] args) {
    /*
    1.等号右边:是匿名内部类，定义并创建该接口的子类对象
    2.等号左边:是多态赋值,接口类型引用指向子类对象
    */
    FlyAble f = new FlyAble(){
        public void fly() {
            System.out.println("我飞了~~~");
        }
    };


    //调用 fly方法,执行重写后的方法
    f.fly();
   }
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {

     public static void main(String[] args) {
        /*
        创建匿名内部类,直接传递给showFly(FlyAble f)
        */
        showFly( new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        });
    }


    public static void showFly(FlyAble f) {
        f.fly();
    }
}