3分钟弄明白JAVA三大修饰符

JAVA的三个修饰:static,final,abstract,在JAVA语言里无处不在,但是它们都能修饰什么组件,修饰组件的含义又有什么限制,总是混淆。所以来总结对比一下。

1 static静态修饰符

static修饰符能够修饰属性,方法,初始代码块。不能修饰局部变量和类。

首先要明白属性分为静态和非静态,静态的称为静态属性,又叫类变量,非静态的称为实例变量。

静态变量和静态方法统称为静态成员。


修饰属性


静态属性又称类变量,它不属于某个对象,是属于类的,是所有对象共同享有。


eg:类名.静态属性 =对象1.静态属性=对象2.静态属性=同一块内存里所对应的地址


修饰方法


1:静态方法可以直接类名.方法名调用。

2:静态方法里只能:访问静态成员,不能访问非静态成员。

3:静态方法里不能用this关键字。

4:静态法法里没有多态,只能被静态方法覆盖。


修饰初始代码块


static修饰初始代码块称为静态代码块。静态代码块是在类加载的时候运行。这里回顾一下类加载。

类加载:

//TestPerson .java

class Person{

static{

System.out.println("static here");

}

public Person(){

System.out.println("构造方法");

}

}

public class TestPerson(){

public static void main(){

Person p1 = new Person();

Person p2 = new Person();

}

}

运行 TestPerson .java文件会编译生成TestPerson .class 和 Person.class两个class文件。

执行java  TestPerson 首先会启动JAVA虚拟机(JVM),然后再硬盘上找到TestPeson.calss文件,并开始解释执行,

此时JVM里只有TestPerson.class这一个类的信息,顺序执行到main方法,遇到,Person p1 = new Person(),

创建Person对象,JVM会根据CLASSPATH环境变量找到Person.class文件,把Person类的信息读入到JVM里,

保存起来。这个过程就是类加载。

类加载:加载类信息;

执行静态代码块;

为静态属性分配空间并初始化值。

以上例子的执行顺序结果如下:

static here

构造方法

构造方法

2final修饰符

final修饰符能够修饰变量,方法,和类。


final修饰变量


final修饰的变量称为常量,一旦赋值不能更改。对于基本类型来说是其值不能改变,对于对象类型来说是其址不能改变。


final变量的赋值说明:一般的实例变量在创建时JVM会给其分配空创建默认值。但是final变量只能有一次赋值机会,所以,对于final变量,JVM不会为其赋值,唯一的赋值机会留给程序员。

final类型的实例变量赋值在1:初始化属性,

2:调用构造方法,两种方式必须抓住其中一次机会,但不能试图抓住两种机会。


final修饰方法


final修饰方法,表示该方法不能被子类覆盖。


eg:class A{ public final void a1(){.....}}

class B extends A{public void  a1(.....)}

//编译错误无法覆盖


final修饰类


final修饰类表示该类不能被继承


一个类中有final方法,该类可以被继承,但无法覆盖final方法,但一个类是final类,则该类不能被继承,更无从谈起覆盖。

eg:final赋值

class Person {

final int num = 10 ; //初始化属性

public Perosn(int num){

this.num = num;

}

}

class Person {

final int num ;

public Perosn(int num){//构造方法赋值

this.num = num;

}

}

class Person {

final int num = 10;    // 错误,两种方式都抓住

public Perosn(int num){//错误,两种方式都抓住

this.num = num;

}

}

3 abstract修饰符

abstract可以修饰类和方法,


abstract修饰类


abstract修饰类称为抽象类。抽象类只能用来声明引用不能用来创建对象。从某种意义上来说,抽象类就是让子类去继承,抽象类声明引用,让这个引用指向子类。子类去实现抽象方法。


抽象类中可以有非抽象方法,但一个类里有抽象方法就一定要是抽象类。子类继承抽象类要么自己成为抽象类,要么实现父抽象类里的所有抽象方法。


abstract修饰方法


abstract修饰方法,称为抽象方法。抽象方法指:只有声明没有实现的方法。


public abstract void  a1();//抽象方法。

public void a1(){};//空实现的方法

abstract class A{

public void a1(){}//抽象类中可以有非抽象方法

public abstract void a2();//但有了抽象方法就一定要是抽象类

}

class B extends A{

public void a2(){

System.out.print("子类要么是抽象类,要么实现父抽象类所有的抽象方法");

}

}

public class TestA{

public static void main(){

A a ;//正确,抽象类可以用来引用

a = new A();//错误,A抽象类,抽象类不能用来创建对象

a = new B();//正确

a.a2();//正确

}

}

抽象类最大的作用就是,定义功能,具体实现由子类实现。

其充分体现了共性放在父类,这个基本原则里。抽象和多态是联系紧密的,其思想大家可以参考JAVA三大特性。

限于文章篇幅原因,这里仅仅介绍冰山一角。由于笔者的水平有限,编写时间也很仓促,文中难免会出现一些错误或者不准确的地方,不妥之处恳请读者批评指正。

以上内容希望对大家有所帮助。欢迎讨论,共同进步。

时间: 2024-08-26 08:08:58

3分钟弄明白JAVA三大修饰符的相关文章

Java三大修饰符

1.static 修饰: 修饰属性:类变量,全类共有 修饰方法:静态方法,静态方法中不能直接访问非静态的方法和属性 静态方法只能被静态方法覆盖,并且没有多态 静态的方法或者属性不依赖于对象:类名.方法名(属性名直接访问) 修饰静态代码块:在类加载下执行 类加载: 在第一次使用这个类时(创建对象之前),JVM会通过classpath找到 对应.class文件,并且把类的信息加载起来. 2.final 最终的 修饰变量:常量(值不可以改变,只能赋值一次),修饰属性时, 要么直接给初始值,或者在构造方

java类修饰符

java的修饰符有:权限修饰符:public.protected.default.private                修饰符:abstract.static.final public   使用对象:最广,类.接口.变量.方法    protected使用对象:变量.方法 注意:不能修饰类(外部类)    default  使用对象:类.接口.变量.方法.(即缺省,什么也不写)    private  使用对象:变量.方法 注意:不能修饰类(外部类) abstract使用对象:类.接口.

java常见修饰符总结

1.访问修饰符:public 对外公开  所有是类都能访问 protected 受保护的 子类及其同一个包中的类可以访问 默认的:没有访问修饰符,只向同一个包中的类公开 private : 私有的 只有类本身可以访问,不对外公开 2.abstract :可以用来修饰类和成员方法 A:用该修饰符修饰的类表示抽象类,抽象类位于继承树的抽象层,该类不能被实例化,即不允许创建抽象类本身的实例 B:用该修饰符修饰的方法表示抽象方法,该方法没有方法体,抽象方法是用来表述系统具有什么功能,但不提供具体的实现.

Java的修饰符

转自:http://blog.csdn.net/manyizilin/article/details/51926230#L42 修饰符: 像其他语言一样,Java可以使用修饰符来修饰类中方法和属性.主要有两类修饰符: 访问修饰符:default, public , protected, private 非访问修饰符:final, abstract, strictfp 修饰符一般使用在一个语句的前端,例: [html] view plain copy public void Pig{ int a 

java访问修饰符

了解面向对象思想的同学们,都知道"封装"这一基本特征,如何正确运用访问修饰符,恰恰能体现出封装的好坏. java访问修饰符有四个: 1)public:访问权限最高,其修饰的类.类变量.方法所有类都可见. 2)protected:其修饰的类.类变量.方法在同包中(包括同类)可见,不同包的子类可见. 3)default:默认修饰符,即在定义类.类变量或方法时不加任何修饰符.其仅在同包(包括同类)中可见. 4)private:最低访问权限,其修饰的类.类变量和方法仅在本类中可见. ps:pr

C#和JAVA 访问修饰符

JAVA ----------------------------------------------- 访问修饰符        描述 ----------------------------------------------- private            只能在本类内使用(可见) 不写修饰符    表示该成员只能在同一个包内才能互相访问 protected        也是同包内访问,区别上面的地方在于:除了同包,其他包的子类也可以访问 public             

Java高手真经_编程基础卷——读书笔记(9)——Java类修饰符

Java修饰符 一.简述 访问控制修饰符:public .默认无修饰符.private.protected 其他修饰符:abstract.static.final.native public:意思是公开的,使用范围最广 默认无修饰符,什么也不写:在同一个包内可见 private :私有的 protected:受保护的 abstract:抽象的 static:静态的 final:最终的 native:本地的 sysnchronized:同步 以上是修饰符子字面意思,但其真实的意义也差不多少.下面就

Java访问修饰符(访问控制符)

Java 通过修饰符来控制类.属性和方法的访问权限和其他功能,通常放在语句的最前端.例如: public class className { // body of class } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // body of meth

JAVA访问修饰符 构造函数的问题(转)

JAVA访问修饰符 构造函数的问题 java访问修饰符-限定符总结(类比C#) JAVA访问修饰符----------[public | default | protected | private ] public: 完全开发protected: 同包及子类访问default(无): 同包访问private: 只能本类访问 JAVA用于类的修饰符(2个)和限定符(2个):---------------public: 完全开发default(无) : 同包访问 abstract: 指定为抽象类fi