7-Java核心：面向对象-代码块、内部类、static、final、抽象类、接口

明前大奏

于 2022-10-18 21:15:26 发布

阅读量193

点赞数

分类专栏： JAVA-SE 文章标签： java

本文链接：https://blog.csdn.net/qq_45022770/article/details/127314975

版权

JAVA-SE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、类的其他成员

1.1 代码块(初始化块)

作用：用来初始化类、对象
代码块如果有修饰的化，只能使用static

代码块的分类：

静态代码块

内部可以有输出语句
随着类的加载而执行，而且只执行一次
作用： 初始化类的信息，比如，对静态变量赋值
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行优先于非静态代码块的执行
静态代码块内只能调用静态的属性、方法，不能调用非静态的结构

非静态代码块

内部可以有输出语句
随着对象的创建而执行
每创建一次对象，就执行一次非静态代码块
作用： 可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块可以调用静态 or 非静态的属性、方法

总结： 静态先行【代码块->static main】，由父及子

注：对属性可以赋值的位置：

默认初始化
显式初始化
构造器初始化
有了对象以后，可以通过"对象.属性" 或 "对象.方法"的方式，进行赋值
在代码块中赋值

先后执行顺序： 1-> 2 / 5 -> 3 -> 4

1.2 内部类

Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B为外部类

内部类可以分为成员内部类（静态、非静态）和局部内部类（方法内、代码块内、构造器内）

1.2.1 成员内部类

作为外部类的成员
- 调用外部类的结构【所有成员属性和成员方法（包括静态成员和私有成员)】
- 成员内部类和外部类的属性和方法名同名时，外部类的属性和方法会隐藏；但可以通过"外部类.this.成员变量 "的方式访问外部类的属性和方法
- 可以被static关键字修饰——静态内部类
- 可以被4种不同的权限修饰【外部类只能public 或缺省】
作为一个类
- 类内可以定义属性、方法、构造器等
- 可以被final关键字修饰，表示此类不能被继承<—> 不使用final，就可以被继承
- 可以被abstract 关键字修饰

1.2.2 局部内部类

局部内部类是定义在一个方法、一个代码块、一个构造器内的类

特点：

不能有private、public、protected和static等修饰符，与局部变量类似
只能在定义局部内部类的方法或者作用域中实例化；
局部内部类的对象不能使用该内部类所在方法或者作用域的非final局部变量

问题：
1.如何实例化成员内部类的对象？

静态会随着类的加载而加载

        //创建Dog实例（静态的成员内部类）
        PersonB.Dog dog = new PersonB.Dog();
        dog.show();
        //创建Bird实例（非静态的成员内部类）
//        PersonB.Bird bird = new PersonB.Bird();
        PersonB p = new PersonB();
        PersonB.Bird bird = p.new Bird();
        bird.sing();

2.如何在成员内部类中区分调用外部类的结构

        public void display(String name){
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的属性
            System.out.println(PersonB.this.name);//外部类的属性
        }

3.开发中局部内部类的使用
一个方法会返回会一个局部内部类对象，其中，局部内部类实现了某个接口，具体使用可以先定义一个实现类，或者直接返回匿名类的匿名对象

二、关键字

2.1 static

static 可以用来修饰：属性、方法、代码块、内部类【主要用来修饰类的内部结构，随着类的加载而加载：类加载中->构造器->对象，所以不包括构造器】

使用static 修饰属性：静态变量（或类变量）

属性按是否用static修饰，又分为 静态属性 和 非静态属性（实例变量）
实例变量：当创建了类的多个对象后，每个对象都独立的拥有一套类中的非静态属性；因此，当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改
静态变量：创建了类的多个对象后，多个对象共享同一个静态变量；当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时是修改过的

静态变量随着类的加载而加载——早于对象的创建——可以直接用 "类名.静态变量="的方式进行调用，如初始化静态变量
由于类只会加载一次，则静态变量在内存中也只会存在一份。，存在方法的静态域中

使用static修饰方法：静态方法

随着类的加载而加载，可以通过 "类名.静态方法="的方式进行调用
静态方法中，只能调用静态的方法或属性【生命周期是一致的】；非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

static 注意点：

在静态的方法内，不能使用this关键字、super关键字【这两个的声明周期在static后面，或者说是基于对象的】

开发中，如何确定一个属性/方法是否要声明为static？

对于属性：
可以被多个对象所共享且不会随着对象的不同而不同
类中的常量也常常声明为static

对于方法：
操作静态属性的方法，通常设置为static
工具类中的方法，习惯上声明为static，如 Math、Arrays、Collection

注： Java内部布局：

栈：局部变量
堆：new出来的结构——对象、数组
方法区：类的加载信息、静态域、常量池

2.2 final

final 可以用来修饰的结构：类、方法、变量

使用 final 修饰一个类：此类就不能被其他类所继承；比如 String、System、StringBuffer
使用 final 修饰一个方法：此方法就不能被重写
使用 final 修饰一个变量：此时的“变量”就称为一个常量
- final修饰属性：可以考虑的赋值位置有：显式初始化、代码块中初始化、构造器中初始化
- final修饰局部变量：该局部变量就是常量，包括一个以final修饰的形参，此时就不能对此类变量进行重新赋值操作【此外，final B b,b这个对象不能重新赋值/重新指向，但里面的属性可以变】

static final： 用来修饰属性：全局常量

三、抽象类与抽象方法

3.1 关键字 abstract

abstract 可以用来修饰的结构：类、方法

abstract 修饰类：抽象类

此类不能实例化
抽象类中一定有构造器，便于此类对象实例化使用（涉及子类对象实例化的全过程）
开发中会提供抽象类的子类，让子类对象实例化，完成相关操作

abstract 修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体
包含抽象方法的类一定是一个抽象类【要保证该方法不能被调用】，反之，抽象类里可以没有抽象方法
若子类重写了父类中的所有的抽象方法，此子类方可实例化；若子类没有重写父类中的所有的抽象方法，则子类也是一个抽象类，需要使用abstract修饰

3.2 abstract的使用注意点

abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰：
私有方法【子类不是抽象类的话就必须重写父类的抽象方法，矛盾】
静态方法【静态的只有一个不需要重写，子类需要重写抽象方法，矛盾】
final方法【不让重写，矛盾】
final类【不让继承，矛盾】

注：抽象类可以继承非抽象的类，如Object类

3.3 抽象类的匿名子类

在这里插入图片描述

//创建了一个匿名子类的对象 p
        PersonA p = new PersonA(){

            @Override
            public void eat() {
                System.out.println("匿名子类吃东西");
            }

            @Override
            public void breathe() {
                System.out.println("匿名子类呼吸");
            }
        };
        method1(p);
        System.out.println("*****************");
        //创建匿名子类的匿名对象
        method1(new PersonA() {
            @Override
            public void eat() {
                System.out.println("好好吃饭");
            }

            @Override
            public void breathe() {
                System.out.println("好好呼吸");
            }
        });

   public static void method1(PersonA p){
        p.eat();
        p.breathe();
   }

四、接口（interface）

4.1 概述

Java中，接口和类是并列的结构

如何定义接口： 定义接口中的成员

JDK7以前：只能定义全局常量和抽象方法
全局常量： public static final,但可以省略不写
抽象方法：public abstract，但可以省略不写

JDK8以后：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
接口中定义的静态方法，只能通过接口来调用
通过实现类的对象，可以调用接口中的默认方法
如果实现类重写了接口中的默认方法，则调用时为实现类中重写的方法
如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么在子类没有重写此方法的情况下，默认调用的是父类中的同名同参的方法——类优先原则
如果实现类实现了多个接口，而者多个接口定义了同名同参的默认方法，那么在实现类没有重写此方法的情况下，报错——接口冲突，解决方式为在实现类中重写此方法
使用” 接口名.super.方法名"调用接口中的被重写的方法，或者"super.方法名"调用父类中的被重写的方法
注：

接口中不能定义构造器，说明接口不可以实例化
开发中，接口通过让类去实现（implements） 的方式【面向接口编程】来使用：
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

4.2 接口的多实现与接口的继承性

Java类可以实现多个接口，意味着弥补了Java单继承的局限性

格式： class AA extends BB implements CC,DD,EE
在这里插入图片描述

接口与接口之间可以继承，而且可以多继承

格式： interface CC extends AA,BB{}

4.3 接口的使用

接口的具体使用体现多态性
接口实质上可以看作是一种规范

面试题：

代码找错

public class test0 extends B implements A{
    public void px(){
        System.out.println(x);
    }

    public static void main(String[] args) {
        new test0().px();
    }
}
interface A{
    int x = 0;
}
class B{
    int x = 1;
}

在这里插入图片描述
改正：

        //编译不通过，x模糊
        //System.out.println(x);
        System.out.println(super.x);//父类的
        System.out.println(A.x);//全局变量
		//或者，父类和接口中的名字不一样

抽象类与接口有哪些异同？

相同点：不能实例化；都可以包含抽象方法；可以被继承
不同点：
抽象类和接口的定义、内部结构解释说明
类：单继承，接口：多继承；接口：多实现

五、补充

5.1 单例（Singleton）设计模式【static的应用】

设计模式是在大量的实践中中介和理论化之后优选的代码结构、编程风格以及解决问题的思考方式【“套路”】

单例设计模式： 采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例 ，并且该类只提供一个取得对象的方法

—— 类的构造器的访问权限设置为private：这样就不能用new操作符在类的外部产生类的对象了，只能在类内部产生该类的对象
——在类内部创建一个静态对象
——提供一个静态方法以返回类内部创建的对象
——指向类内部产生的该类对象的变量也必须定义成静态的

具体步骤：

饿汉式

public class SingletonTest0 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);
    }
}
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }
    //2.类内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();
    //3.提供公共的静态的方法，返回内部对象
    public  static Bank getInstance(){
        return instance;
    }
}

懒汉式

public class SingletonTest1 {
    public static void main(String[] args) {
        Order o1 = Order.getInstance();
        Order o2 = Order.getInstance();
        System.out.println(o1 ==  o2);
    }
}
class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明内部类对象
    //4.此对象也必须声明为static
    private static Order instance = null;//这里就是主要区别
    //3.声明公共的静态的返回内部类对象的方法
    public static  Order getInstance(){
        if(instance == null){//没有判断，那不得调一次方法创建一次对象
            instance  = new Order();
        }
        return instance;
    }

}

一点想法： 是不是可以联想装箱的valueOf，比如Integer的范围-128 ~ +127

区分饿汉式与懒汉式：

饿汉式
好处：线程安全
缺点：对象加载时间过长

懒汉式：
优点：延迟对象的创建
缺点：线程不安全【eg，两个线程同时进入静态方法，同时判断为null -> 同时new】---- > 后续会优化

应用场景
在这里插入图片描述

5.2 main方法的语法

main()方法是程序的入口
main()方法也是一个普通的静态函数
main()方法可以作为与控制台交互的方式，看下图

在这里插入图片描述

5.3 模板方法设计模式(TemplateMethod)【抽象类的应用】

当功能内部一部分实现是确定的，一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类去实现
具体做法：类为抽象类，不确定的方法是抽象方法

5.4 代理模式（Proxy）【接口的应用】

代理设计就是为其他对象提供一种带来以控制对这个对象的访问
会用到多态

在这里插入图片描述

5.5工厂模式（Proxy）【接口的应用】

实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的
实例化对象这个操作由工厂来做【包装new操作】

注：设计模型和面向对象设计，原则都是为了使得开发项目更加容易扩展和维护，解决方式就是“分工”

工厂模式的分类：

简单工厂模式：用于生产同一等级结构中的任意产品（对于增加新的产品，需要修改已有的代码，不能进行扩展即违反了开闭原则OCP——对扩展开放，对修改关闭）
工厂方法模式：用来生产同一等级结构中的固定产品——设置一个工厂接口，再细分为不同产品的产品工厂【不同的实现类】（支持增加任意产品，但还是无法正真避免代码改动，增加新产品时要么再抽象工厂【接口】中增添判断逻辑——像简单工厂一样，要么再重新写一个新产品对应的工厂——这也是写死了）—— 一种解决： Java的反射机制结合配置文件
抽象工厂模式：用来生产不同产品族的全部产品(对于增加新的产品，无能为力:支持增加产品族)