巩固java(三)---java修饰符

正文:

      

       下面的表格列出了java中修饰符的一些信息：

修饰符名称	类型	类	变量	方法
abstract	非访问控制符	抽象类	--	抽象方法
final	非访问控制符	最终类	最终变量	最终方法
static	非访问控制符	--	静态变量	静态方法
volatile	非访问控制符	--	易失变量	--
native	非访问控制符	--	--	本地方法
synchronized	非访问控制符	--	--	同步方法
public	访问控制符	有	有	有
默认修饰符	访问控制符	有	有	有
private	访问控制符	无	有	有
protected	访问控制符	无	有	有

1.非访问控制符

1.1类修饰符

1.1.1 抽象类：abstract

                

          在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。使用抽象类需要注意以下几点：

          a.抽象类只能作为基类被继承，而不能实例化对象;

          b.抽象类可以没有抽象方法，但有抽象方法的类必须是抽象类;

          c.抽象类既可以有抽象方法，也可以有非抽象方法。

          看下面这个例子：

         

 abstract class TestAbstract {
     public abstract void say();
    public void tell(){
     System.out.println("我是抽象类的非抽象方法tell()" );
    };
     }

     public class Son extends TestAbstract{
    public void say() {
       System. out.println( "我必须实现父类的抽象方法say()" );
    }
    public static void main(String args[]){
           Son son = new Son();
           son.say();
           son.tell();
    }
     }

1.1.2 最终类：final

          被final修饰的类不可以有子类，即不能被继承。

          final修饰符和abstract修饰符不可以同时用来修饰一个类，因为abstract是抽象类，必须被子类继承来实现他的抽象方法，但final类有不能被继承。

1.2 变量修饰符

1.2.1 静态变量：static

       静态变量属于整个类，而不属于这个类的某一个对象，对于类中的非静态变量，类的每一个对象都有一份自己的拷贝，而静态变量所有对象都使用同一份拷贝。所以在对象被实例化之前我们就可以操作它的静态变量：

      

public class TestStatic {
     static String name = "静态变量";

     public static void main(String[] args) {
          System. out.println(TestStatic. name);
     }

   }

   

     static与一对大括号组成的语句组称为静态初始化器，作用是加载时初始化类的静态变量。

     静态初始化器不同于构造函数：

      1.构造函数是对新创建的对象进行初始化，而静态初始化器是对类自身进行初始化;

      2.出于1的原因，构造函数是在new一个对象的时候由系统自动执行，而静态初始化器是它所在的类加载到内存是自动执行;

     下面这个例子中，main函数中没有进行实例化对象，但运行该类时会打印“我是静态初始化器”

   

public class TestStatic {

static
{
     System.out.println("我是静态初始化器");
}

public static void main(String[] args) {

}
}

1.2.2  最终变量：final

          当用final修饰变量时，即说明该变量其实是一个常量，而且不能被修改。

       

final int N = 100;

    如果再执行下面语句会报错：

          N =
0;

          由于此时对所有对象来说该常量值固定，所以该常量一般定义为static类型的，以节省内存：

         

 static final int N = 100;

   

1.2.3 易失变量：volatile

          volatile常用在多线程的问题中，小编还没用过，大家可以自己查查资料。

1.3 方法修饰符

1.3.1抽象方法：abstract

            就像前边抽象类讲的一样，抽象方法主要是提供一个统一的接口，使所有子类对外呈现一个相同名字的方法。

            抽象方法只有方法头，没有方法体。

            抽象方法必须写在抽象类里边。

 

1.3.2静态方法：static

               被static修饰的方法是整个类的方法，而不专属于某一个对象，而非静态方法是对象的方法。调用静态方法时使用类名直接调用：

                

 public class TestStatic {
          static void method(){
             System. out.println( "我是静态方法" );
          }
          public static void main(String[] args) {
               TestStatic.method();
          }
        }

1.3.3 最终方法：final

                  被final修饰的方法，功能和内部语句不能修改，不能被继承，即父类的final方法不可以被子类重写，如下面的写法是错误的。

              

 class Parents{
         final void say(){
             System. out.println( "我不能被继承" );
           }
       }
       public class TestFinal extends Parents{
           void say(){  //这个方法其实不可以被继承，这样写会报错
              System. out.println( "我可以被继承" );
          }
       }
            

1.3.4 本地方法：native

              native主要用来声明该方法的方法体是由其他语言在程序外部编写的，小编没用过。

  

1.3.5 同步方法：synchronized

                synchronized修饰符主要用于多线程共存的程序中的协调和同步。

                如果synchronized修饰的是一个静态方法，则方法被调用执行前把对应当前类的对象加锁，若修饰的是非静态方法，则方法被调用执行前，把当前对象加锁。

2.访问控制符

    

范围	public	private	protected	默认
同一类中可见	是	是	是	是
同一包中对子类可见	是	否	是	是
同一包中对非子类可见	是	否	是	是
不同包对子类可见	是	否	是	否
不同包对非子类可见	是	否	否	否

 

版权声明：本文为博主原创文章，未经博主允许不得转载。