资深互联网大佬的5000字吐血总结——Java面向对象三大修饰符之abstract、static、final

Gita ·

更新时间:2024-11-13

· 611 次阅读

本文目录一、abstract(抽象的)1. abstract可以用于修饰类2. abstract可以用于修饰方法3. 抽象类的子类4. 抽象类强制使用多态5. 抽象类的应用场景：【理解】二、static (静态的)1. static可以修饰属性2. static 可以修饰成员方法3. static 可以修饰初始化代码块扩充内容三、final（最终的，最后的）1.final可以修饰变量2.final可以修饰方法3.final可以修饰类总结abstract、static、final可以修饰的内容abstract、static、final是否可以修饰构造方法？private、abstract、static、final是否可以联合修饰成员方法？一个方法中必须而且只能有一个访问修饰符 一、abstract(抽象的) 1. abstract可以用于修饰类 被abstract修饰的类称为抽象类
abstract class 类名{} 抽象类编译之后会生成独立的.class 文件抽象类不能单独创建对象(即不能 new 对象)，但是可以声明抽象类类型的引用 (简称：可以声明引用) 抽象中可以定义成员变量和成员方法 抽象类中有构造方法，但是抽象类中构造方法不再是用于new 对象，而是供子类创建对象时，JVM默认创建一个父类对象时应用。 2. abstract可以用于修饰方法

被 abstract 修饰的方法称为抽象方法

抽象方法只有声明部分，没有方法实现部分(即没有 { })，以英文分号结尾

语法：
访问修饰符 abstract 返回值类型方法名(形参列表); 注意：访问修饰符和abstract没有先后位置

抽象方法只能定义在抽象类中；但是抽象类中既可以定义抽象方法，也可以定义非抽象方法。

3. 抽象类的子类 如果一个类继承抽象类，此类为抽象类的子类; 如果子类不想定义为抽象类，必须覆盖父类中所有的抽象方法，否则子类必须定义抽象类； 抽象类类名引用名 = new 子类类名(形参)

public class TestAbstract{
	public static void main(String[] args){
		MyClassmc ;
		mc=new Sub(); // 强制使用多态
		mc.m1();
		mc.m2();
		mc.m3();
	}
}
//抽象类
abstract class MyClass{
	inta; // 属性
	public void m1(){
		System.out.println("m1()...");
	}
	public abstract void m2();
	abstract public void m3();
}
// 子类
class Sub extends MyClass{
	public void m2(){
		System.out.println("m2()实现内容...");
	}
	public void m3(){
		System.out.println("m3()...实现内容.../");
	}
}

4. 抽象类强制使用多态 5. 抽象类的应用场景：【理解】 通常将一些父类定义为抽象类
具有某一类事物的特性和行为，但是不具有具体的执行功能(实现)。例如：动物类、图形类等。依赖倒转原则
当一个类和另一类建立关联时，尽可能避开直接和子类建立关系，而是与其父类建立联系。 a. 降低程序之间的耦合度，从而实现弱耦合。 b. 提高代码的可维护性 二、static (静态的) 1. static可以修饰属性

被 static 修饰的属性称为静态属性、静态变量、类变量

语法：
访问修饰符 static 数据类型变量名;
访问修饰符 static 数据类型变量名 = 值；

注意：访问修饰符和static没有位置先后。

特点
静态变量/静态属性/类变量是依赖于类的变量，和创建多少对象没有关系，被每一个对象共享。

注意：实例变量(非静态变量)每一个对象独有一份静态变量让每一个对象共享

使用

a. 引用名.静态属性名 b. 类名.静态属性名

内存分析如下：
static内存分析图

案例

public class TestMyClass2{
	public static void main(String[] args){
		MyClassmc1=newMyClass();
		MyClass mc2 = new MyClass();
		mc1.value=20;
		mc1.m=3;
		System.out.println("mc1.value="+mc1.value)//20	
		System.out.println("mc1.m="+mc1.m);// 3
		System.out.println("mc2.value="+mc2.value)//10
		System.out.println("mc2.m="+mc2.m);// 3
		MyClassmc3=newMyClass();
		System.out.println("mc3.m="+mc3.m);
		mc3.m=100;
		System.out.println(mc2.m); // 100
		System.out.println(MyClass.m);//100
	}
}
class MyClass{
	int value = 10;
	static int m ;// 静态属性、静态变量、类变量
	static int n;
}

2. static 可以修饰成员方法

被 static 修饰的方法称为静态方法

语法：
访问修饰符 static 返回值类型方法名(形参列表){}

注意：访问修饰符和 static 没有位置的先后顺序。

使用

a. 类名.静态方法名(实参); —>建议 b.对象名.静态方法名(实参);

注意事项

a. 静态方法中不能直接访问本类的非静态成员(实例变量+成员方法) b. 静态方法中可以直接访问本类的静态成员(静态变量+静态方法) c. 非静态方法中既可以直接访问本类非静态的成员，也可以直接访问本类的静态成员。 d. 静态方法中不能使用 this 和super 关键字 e. 父类中的静态方法可以被子类继承子类类名.父类静态方法名(实参); f. 如果子类覆盖父类中的静态方法，则子类覆盖的方法也必须是静态的(静态方法只能被静态方法覆盖)；以父类型的引用调用静态方法，直接访问父类中静态方法，没有体现多态的覆盖结果。

应用场景
为了方便调用，通常将工具类中方法定义为静态方法。
例如： java.util.Arrays.sort(数组名);

思考： System.out.println(); 实现原理？

System : 类(位于 java.lang中的) out: System类中被 static 修饰的静态属性，引用 println：out数据类型中方法。

public class Test2{
	public static void main(String[] args){
		System.out.println("实现原理...");
		A.b.method();
	}
}
// 类
classA{
	static Bb = newB();//自定义类型的关系属性
}
// 类
classB{
	public void method(){}
}

3. static 可以修饰初始化代码块 初始化代码：也称为动态代码块【了解】定义在类以内，方法以外的 {} 作用：创建对象时，按照和属性(实例变量)定义的先后顺序完成对属性初始化工作。
在这里插入图片描述

静态初始化代码块【重点】定义在类以内，方法以外，被 static 修饰的 {}
static{} 作用
在类加载的时候，按照和静态属性定义的先后顺序完成静态属性的初始化工作。类加载

概念
JVM第一次使用一个类的时候，通过classPath(类路径)找到所需要的类对应的 .class 文件，读取并获取类对应信息(包名、类名、属性、构造方法、成员方法、父类等信息)，将类的信息保存到JVM内存中，一个类类加载进行一次。

第一次使用一个类

a. 第一次调用类中静态成员(静态属性和静态方法) b. 第一次创建一个类的对象：先进行类加载，再完成对象的创建； c. 子类类加载会先导致其父类进行类加载注意：只是声明引用，不会导致类加载。

类加载的时机

创建对象创建子类对象加载父类访问静态属性访问静态方法 Class.forName(“全限定名”); 扩充内容

选择性的理解

第一次使用子类的静态成员(静态属性和静态方法) 第一次创建子类对象时：
先加载：先加载父类，再子类
再完成对象的创建：
new --> 分配空间
执行子类的构造方法带有类加载创建对象的过程： a. 先类加载先加载父类父类静态属性完成初始化(父类的静态代码块) 再加载子类
子类静态属性完成初始化(子类的静态代码块) b. 再创建对象：
执行子类构造方法第一行遇到super()，代表先完成父类对象的创建先完成父类对象的创建：执行父类属性初始化内容(父类属性赋值语句+动态代码块)– 父类构造方法中的内容再完成子类对象的创建：执行子类属性初始化内容(子类属性赋值语句+动态代码块) 子类构造方法中内容 三、final（最终的，最后的） 1.final可以修饰变量

成员变量、局部变量

final修饰的变量是作用范围内的常量，只允许一次赋值，不允许修改

注意：final修饰的变量，通常以全大写字母作为名

//局部变量
main(){
    final int A=5;//局部变量
}

final修饰的实例变量，jvm虚拟机不再分配默认值

final修饰的实例变量初始化的位置：

在声明同时初始化

可以在构造方法中对其初始化，但是必须保证每一个构造方法都必须初始化

//实例变量
main(){
}
class class1{
    //实例变量
    final int a=1;//在声明时初始化
    public class1(){
        a=2;//可以在构造方法中对其初始化
    }
}

final修饰静态变量，jvm不再分配默认值

final修饰的静态变量初始化的位置：

声明时为其初始化

可以在静态代码块中完成对其初始化

//3)静态变量、静态属性、类变量
main(){
}
class class2{
    final static int a=1;//声明时初始化
}
//静态代码块
static{
    a=2;//在静态代码块中进行初始化
}

如果引用被final修饰，代表引用中存储的对象地址不可以改变，但是可以通过引用对象中的属性进行改变

//引用被final修饰
main(){
    final MyClass mc=new MyClass();//引用中存储的地址不允许改变
    mc.a=5;
    sout(mc.a);
}
class MyClass{
    int a;
}

2.final可以修饰方法 final修饰的方法可以被子类继承，不允许被子类覆盖

main(){
}
class class1{
    public final void m1(){
        sout("m1方法");
    }
}
class class2 extends class1{//编译不通过，final修饰的方法不允许被子类覆盖
    public final void m1(){
        sout("子类中m1方法");
    }
}

3.final可以修饰类 final修饰的类不允许被继承

main(){
}
final class class1{
    public final void m1(){
        sout("m1方法");
    }
}
class class2 extends class1{//编译出错，final修饰的类不允许被继承
}

总结 abstract、static、final可以修饰的内容 abstract 可以修饰类和方法 static可以修饰属性、方法和静态代码块 final可以修饰变量（局部变量、实例变量、静态变量）、方法和类 abstract、static、final是否可以修饰构造方法？ abstract：抽象方法只能有方法的声明，没有方法实现,实现部分（构造方法）让子类完成；
但是构造方法不能被子类继承，如果构造方法被abstract修饰，则子类无法完成构造方法的实现内容。 static：无法修饰构造方法，static和对象没有关系，但是构造方法是用于创建对象的，相互矛盾；
同时static修饰的方法可以直接通过类名.静态方法名(实参)；
但是构造方法不允许手动调用 final:final方法是约束子类不能覆盖，但是构造方法本身就不允许子类继承，谈不上覆盖。 private、abstract、static、final是否可以联合修饰成员方法？ private和abstract
private修饰的方法不能被子类继承，abstract修饰的方法需要通过子类覆盖给予方法的实现部分，联合修饰一个成员方法，矛盾； static和abstract
static修饰方法可以直接通过类名调用，如果通过类名调用的是一个抽象方法（半成品），jvm无法执行，不能联合修饰一个成员方法； final和abstract
final修饰的方法可以被子类继承，但是不允许被覆盖；
而abstract修饰的方法的实现需要通过子类覆盖时给予实现，所以不能联合使用。 private、static、final可以联合使用。 一个方法中必须而且只能有一个访问修饰符 private、default、protected、public

整理不易，喜欢请点个赞！
编者微信：1014961803，添加时请备注"CSDN"

作者：微笑·不失礼

JAVA final abstract 对象修饰符 static 互联网