Java-三个修饰符 

               <p>一.abstract(抽象的)（能修饰符类和 方法）<br> 1.abstract可以用于修饰类<br> （1）被abstract修饰的类称为抽象类。<br> （2）抽象类编译之后会生成独立的.class文件<br> （3）抽象类不能单独创建对象（即不能new对象），但是可以声明抽象类类型的引用（简称：可以声明引用）<br> （4）抽象中可以定义成员变量和成员方法<br> （5）抽象类中有构造方法，但是抽象类中构造方法不能是用于new对象，而是供子类创建对象时，jvm默认创建一个父类对象时应用。</p>

2.abstract可以用于修饰方法
（1）被abstract修饰的方法称为抽象方法
（2）抽象方法只有声明部分，没事方法实现部分（连｛｝都没有）亿分号结尾

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

  • 1

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

  1. 抽象类的子类
    (1) 如果一个类继承抽象类，此类为抽象类的子类
    (2) 如果子类不想定义为抽象类，必须覆盖父类中所有的抽象
    方法，否则子类必须定义抽象类。
    (3) 抽象类类名 引用名 = new 子类类名(形参);
    public class TestAbstract{
    public static void main(String[] args){
    MyClass mc ; mc = new Sub();
    // 强制使用多态 mc.m1(); mc.m2(); mc.m3();
    }
    }
    //抽象类
    abstract class MyClass{
    int a; // 属性
    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()…实现内 容…/”);
    }
    }

  2. 抽象类强制使用多态。

  3. 抽象类的应用场景：【理解即可】
    (1) 通常将一些父类定义为抽象类：具有某一类事物的特性和
    行为，但是
    不具有具体的执行功能(实现)。例如：动物类、图形类等。
    (2) 依赖倒转原则：当一个类和另一类建立关联时，尽可能避
    开直接和子
    类建立关系，而是与其父类建立联系。
    a. 降低程序之间的耦合度，从而实现弱耦合。
    b. 提高代码的可维护性
    在这里插入图片描述

     abstract：能修饰：类和方法

    • 1

二、static (静态的)

  1. static可以修饰属性
    (1) 被 static 修饰的属性称为 静态属性、静态变量、类变量
    (2) 语法：访问修饰符 static 数据类型 变量名;
    访问修饰符 static 数据类型 变量名 = 值；
    注意：访问修饰符 和 static 没有位置先后。
    (3) 特点：静态变量/静态属性/类变量是 依赖于类的变量，和
    创建多少对象没有关系，被每一个对象共享。
    注意：实例变量(非静态变量)每一个对象独有一份
    静态变量让每一个对象共享
    (4) 使用：
    a. 引用名.静态属性名
    b. 类名.静态属性名
    (5) 内存分析如下：
    在这里插入图片描述

案例：

public class TestMyClass2{ 
public static void main(String[] args){ 
MyClass mc1 = new MyClass(); 
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
MyClass mc3 = new MyClass(); 
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; 
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

  1. static 可以修饰成员方法
    (1) 被 static 修饰的方法称为静态方法
    (2) 语法：
    访问修饰符 static 返回值类型 方法名(形参列表){}
    注意：访问修饰符 和 static 没有位置的先后顺序。
    (3) 使用：
    a. 类名.静态方法名(实参); —》建议
    b.对象名.静态方法名(实参);
    (4) 注意事项：
    a. 静态方法中不能直接访问本类的非静态成员(实例变量+成
    员方法)
    b. 静态方法中可以直接访问本类的静态成员(静态变量+静态
    方法)
    c. 非静态方法中既可以直接访问 本类非静态的成员，也可以
    直接访问
    本类的静态成员。
    d. 静态方法中不能使用 this 和 super 关键字
    e. 父类中的静态方法可以被子类继承
    子类类名.父类静态方法名(实参);
    f. 如果子类覆盖父类中的静态方法，则子类覆盖的方法也必
    须是静态的(静态方法只能被静态方法覆盖)；以父类型的引
    用调用静态方法，直接访问父类中静态方法，没有体现多态
    的覆盖结果。
    (5) 应用场景：为了方便调用，通常将工具类中方法定义为静
    态方法。
    例如： java.util.Arrays.sort(数组名);

     public class Test2{ 
 public static void main(String[] args){ 
 System.out.println("实现原理..."); A.b.method(); 
 }

    • 1
    • 2
    • 3
    • 4

    }
    // 类
    class A{ static B b = new B();
    //自定义类型的关系属性
    }
    // 类
    class B{
    public void method(){}
    }

3.static 可以修饰初始化代码块
初始化代码：也称为动态代码块
（1）定义在类以内，方法以外的｛｝
（2）作用：创建对象时，按照和属性（实例变量）定义的先后顺序完成对属性初始化的工作。
在这里插入图片描述
静态初始化代码块【】
（1）定义在类以内，方法以外，被static修饰的｛｝
static｛｝
（2）作用：在类加载的时候，按照和静态属性定义的先后顺序完成静态属性的初始化工作。

（3）类加载：
1.类加载：JVM第一次使用一个类的时候，通过classPath｛类路径｝找到所需要的类对应的.clas文件，获取类对应信息（包名、类名、属性、构造方法、成员方法、父类等信息）将信息保存到JVM内存中，一个类类加载进行一次。
2.第一次使用一个类：
a.第一次调用类中静态成员
b.第一次创建一个类的对象：先进行类加载，在完成对象创建
c.子类类加载 会 先导致其父类进行类加载：
-》第一次使用子类的静态成员（静态属性和静态方法）
-》第一次创建子类对象时：
先加载：先加载父类，再子类
再完成对象的创建：
new–》分配空间
执行之类的构造方法：
super（）；
3.带有类加载创建对象的过程：
a.先类加载
-》先加载父类
父类静态属性完成初始化（父类的静态代码块）
-》再加载子类
子类静态属性完成初始化（子类的静态代码块）
d.在创建对象：
执行子类构造方法第一行遇到super（）；代表先完成父类对象的创建
-》先完成父类对象的创建；
-》执行父类属性初始化内容（父类属性赋值语句+动态代码块）
-》父类构造方法中的内容
-》在完成子类对象的创建；
-》执行子类属性初始化内容（）

三：
1、final 可以修饰符变量（局部变量、实例变量、静态变量）
（1）final修饰的变量是作用范围内的常量、只允许一次赋值，不允许更改
注意：final修饰的变量 通常以全大写字母作为名字
（2）final修饰 实例变量，jvm不再分配默认值
final修饰实例变量初始化的位置：
a.在声明的同时给其初始化
b.可以在构造方法中对其初始化，但是必须保证每一个构造方法中都有对其初始化的语句。
（3）final修饰静态变量，jvm不在分配默认值 final修饰的静态变量初始化位置。
1.声明的同时为其初始化
2.可以在静态代码块中完成对其初始化
3.如果引用final修饰，代表引用中存储的对象地址不可以改变，但是可以通过引用对对象中的属性进行改变。
在这里插入图片描述

2、final可以修饰的方法：被final修饰的方法能被子类继承、但是不允许子类覆盖

3、final可以修饰方法：被final修饰的方法能被子类继承、但是不允许子类覆盖
System、String、Math等一系工具类通常会定义为final类。

	总结：
	（1）abstract、static、final 可以修饰那些内容？
	abstract：可以修饰类、方法
	static：可以修饰属性、方法、静态代码块
	final：可以修饰 变量（局部变量、实例变量、静态变量）、方法、类
	（2）abstract、static、final 都不能修饰构造方法。
	abstract 抽象方法只能有方法的声明，没有方法的实现、实现部分让子类完成；但是构造方法是不能被子类继承、如果构造方法被abstract修饰，则子类无法完成构造方法的实现内容。
	static：static和对象没有关系，但是构造方法是用于创建跌的，相互矛盾；同时static修饰的方法可以直接通过。类名.静态方法名（实参）；但是构造方法不允许手动调用。
	final:final方法是约束子类不能覆盖，但是构造方法本身就不允许子类继承、谈不上覆盖。

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

（3）private、abstract、static、final是否能联合修饰成员方法？
private 和 abstract
static 和 abstract
final 和 abstract

	a. private 和 abstract：private 修饰的方法不能被 子类继承，asbtract修饰的方法需要通过子类覆盖给与方法的实现部 分，联合修饰一个成员方法，矛盾。 
	b. static 和 abstract：：static 修饰方法可以直接 通过类名调 用， 如果通过类名调用的是一个抽象方法 (半成品)，jvm无 法执行，不能 联合修饰一个成员方法。 
	c. final 和 abstract：final修饰的方法可以被子类 继承，但是不允 许被覆盖；而 abstract修饰的方法的实现需要通过子类 覆盖时给与实现。所以不能联合使用

  • 1
  • 2
  • 3
本文链接：https://blog.csdn.net/weixin_46553106/article/details/105081007

Copyright © 2021 半边星

欢迎任何形式的转载，但请务必注明出处。
限于本人水平，如果文章和代码有表述不当之处，还请不吝赐教。

posted @ 2021-06-05 08:33  半边星  阅读(324)  评论(0)  编辑  收藏  举报