一、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. 类名.静态属性名
-
内存分析如下:
-
案例
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(“全限定名”);
-
- 定义在类以内,方法以外,被 static 修饰的 {}
扩充内容
选择性的理解
- 第一次使用子类的静态成员(静态属性和静态方法)
- 第一次创建子类对象时:
先加载:先加载父类,再子类
再完成对象的创建:
new --> 分配空间
执行子类的构造方法 - 带有类加载创建对象的过程:
- a. 先类加载
- 先加载父类父类静态属性完成初始化(父类的静态代码块)
- 再加载子类
子类静态属性完成初始化(子类的静态代码块)
- b. 再创建对象:
执行子类构造方法第一行遇到super(),代表先完成父类对象的创建- 先完成父类对象的创建:
- 执行父类属性初始化内容(父类属性赋值语句+动态代码块)–
- 父类构造方法中的内容
- 再完成子类对象的创建:
- 执行子类属性初始化内容(子类属性赋值语句+动态代码块)
- 子类构造方法中内容
- 执行子类属性初始化内容(子类属性赋值语句+动态代码块)
- 先完成父类对象的创建:
- a. 先类加载
三、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"