java访问权限修饰符

java访问权限修饰符public protected defaultprivate用法总结首先声明：java中，default这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是default。

为了条理清晰，分三种不同情况来总结。

一访问权限修饰符修饰成员变量和方法public：表明该成员变量和方法是共有的，能在任何情况下被访问。

protected：必须在同一包中才能被访问。

(说的比较简单，看个例子就明白了) eg:class A{protected int weight;protected int f( int a,int b ){// 方法体}}假设B与A在同一个包中，则class B{void g(){A a=new A();A.weight=100;//合法A.f(3,4); //合法}}特别说明：什么是在同一个包中？答：用package打包在一起的class ,叫在同一个包中。

(不明白，举个例子) eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io;没有使用package打包的，在同一目录下的类也会被视做同一个包。

default：在这种情况下中，同protected。

区别在第二和第三种情况中。

eg: class A{int weight ;int f( int a,int b ){// 方法体}}假设B与A在同一个包中，则class B{void g(){A a=new A();A.weight=100;//合法A.f(3,4); //合法}}private:只能在本类中访问。

eg: class Test{private int money;Test(){money=2000;}private int getMoney(){return money;}public static void main(String args[]){Test te=new Test();te.money=3000; //合法int m=te.getMoney(); //合法System.out.println("money="+m);}}PS：实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。

二访问权限修饰符修饰类1，不能用protected和private修饰类。

2，用default修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。

三访问权限修饰符与继承这里的访问修饰符指的是修饰成员变量和方法。

可以分为两种情况：1，子类与父类在同一包中此时只有声明为private的变量与方法不能被继承(访问)。

eg:class Father{private int money ;int weight=100;}class Son extends Father{viod f(){money=10000;// 非法weight=100; // 合法}}2,子类与父类不在同一包中此时private与default均不能被继承(访问)，protected与public可以。

eg:Father.javapackage com.aaapublic class Father{int height ;protected int money=120;public int weight;protected int getMoney(){return money;}void setMoney(int newMoney){money=newMoney;}}Son.javapackage com.bbbimport com.aaa.Father;public class Son extends Father{void f(){money=10000;//合法//height=170;//非法，height为default修饰的变量System.out.println(money);//输出结果是10000//setMoney(300); //非法int number=getMoney(); //合法System.out.println(number);//输出结果是10000}public static void main(String args[]){Son sss=new Son();sss.f();}}所以，访问权限修饰符权限从高到低排列是public ,protected ,default, private。

Java中的abstract,static,final修饰符abstract修饰符abstract使用对象：类、接口、方法介绍：类中包括没有实现的方法，不能被实例化。

如果是一个abstract方法，则方法体为空，该方法的实现在子类中被定义，并且包含一个abstract方法的类必须是一个abstract类abstract修饰符表示所修饰的类没有完全实现，还不能实例化。

如果在类的方法声明中使用abstract修饰符，表明该方法是一个抽象方法，它需要在子类实现。

在下面的情况下，类必须是抽象类：1.类中包含一个明确声明的抽象方法;2.类的任何一个父类包含一个没有实现的抽象方法;3.类的直接父接口声明或者继承了一个抽象方法，并且该类没有声明或者实现该抽象方法。

如下例所示：abstract class A1{public int v1;abstract void test();}abstract class A2 extends A1{public int v2;}class Sample extends A2{void test() { }}因为包含一个抽象方法test,类A1必须被声明为抽象类。

它的子类A2继承了抽象方法test，但没有实现它，所以它也必须声明为抽象类。

然而，A2的子类Sample因为实现了test，所以它不必声明为抽象的。

注意:如果试图创建一个抽象类的实例就会产生编译错误;如果一个类是非抽象类却包含一个抽象方法，就会产生编译错误;构造函数和静态函数以及Final修饰的函数不能使用abstract修饰符;接口缺省为abstract。

Static修饰符static使用对象：类、方法、变量、初始化函数通常，在创建类的实例时，每个实例都会创建自己实例变量。

但是在变量的声明中可以使用Static修饰符，它表明该成员变量属于类本身，独立于类产生的任何对象。

这种成员变量称为静态变量（静态属性）。

方法的声明中也可以使用static修饰符，表明该方法从属于类本身。

静态属性和静态方法不需要创建实例就可以使用。

典型的例子是ng包中的System类中的方法和变量。

我们常用System.out.println(“message”);输出信息，并没有创建System的实例，是因为println方法声明为System类的静态方法，它不需创建实例就可以使用。

下面的例子会帮助你更深刻的理解Static修饰符。

注意各个代码块的加载次序。

class Sample{static int s1=3;static int s2;static void display(){System.out.println("s1="+s1);System.out.println("s2="+s2);}static{System.out.println("static block");s2=s1+1;}public static void main(String args[]){Sample.display();}}一旦这个类被调用，所有的静态变量都被初始化，s1被赋为3，然后运行static块，这将打印出一段消息，并且把s2赋为s1+1，即4。

然后解释器调用main成员函数，它调用了成员函数display，该函数输出s1和s2的信息。

运行结果如下：C:\>java Samplestatic blocks1=3s2=4通过上面的例子还可以看出，一个静态成员函数可以通过它所属的类名来调用。

注意：在静态成员函数中只能直接调用其它的静态成员函数或引用静态属性，否则会造成编译错误。

静态成员函数中也不能使用this或者super，因为它们是和类的对象相关联的。

final修饰符final使用对象：类、方法、变量介绍：被定义成final的类不允许出现子类，不能被覆盖，字段值不允许被修改。

如果一个类是完全实现的，并且不再需要继承子类，则它可以声明为Final类。

如果final 类的名字出现在另一个类声明的extends字句的后面就会产生编译错误。

这表明final类不能有任何的子类。

类不能同时被声明为abstract和final，因为abstract类中的abstract方法永远没有机会被实现。

在缺省情况下，所有的成员函数和实例变量都可以被覆盖。

如果你希望你的变量或成员函数不再被子类覆盖，可以把它们声明为final。

例如：class FinalSample{final int MAX_VALUE = 100;public static void main(String args[]){ FinalSample a =new FinalSample();System.out.print(a.MAX_VALUE);}}表示，MAX_VALUE的值为100，并且不能再更改。

final变量用大写标识符是一个一般的约定。